home *** CD-ROM | disk | FTP | other *** search
/ HTML Examples / WP.iso / wordpress / wp-includes / js / codemirror / jshint.js < prev    next >
Encoding:
JavaScript  |  2018-01-22  |  277.5 KB  |  6,745 lines
  1. (function webpackUniversalModuleDefinition(root, factory) {
  2. /* istanbul ignore next */
  3.     if(typeof exports === 'object' && typeof module === 'object')
  4.         module.exports = factory();
  5.     else if(typeof define === 'function' && define.amd)
  6.         define([], factory);
  7. /* istanbul ignore next */
  8.     else if(typeof exports === 'object')
  9.         exports["esprima"] = factory();
  10.     else
  11.         root["esprima"] = factory();
  12. })(this, function() {
  13. return /******/ (function(modules) { // webpackBootstrap
  14. /******/     // The module cache
  15. /******/     var installedModules = {};
  16.  
  17. /******/     // The require function
  18. /******/     function __webpack_require__(moduleId) {
  19.  
  20. /******/         // Check if module is in cache
  21. /* istanbul ignore if */
  22. /******/         if(installedModules[moduleId])
  23. /******/             return installedModules[moduleId].exports;
  24.  
  25. /******/         // Create a new module (and put it into the cache)
  26. /******/         var module = installedModules[moduleId] = {
  27. /******/             exports: {},
  28. /******/             id: moduleId,
  29. /******/             loaded: false
  30. /******/         };
  31.  
  32. /******/         // Execute the module function
  33. /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  34.  
  35. /******/         // Flag the module as loaded
  36. /******/         module.loaded = true;
  37.  
  38. /******/         // Return the exports of the module
  39. /******/         return module.exports;
  40. /******/     }
  41.  
  42.  
  43. /******/     // expose the modules object (__webpack_modules__)
  44. /******/     __webpack_require__.m = modules;
  45.  
  46. /******/     // expose the module cache
  47. /******/     __webpack_require__.c = installedModules;
  48.  
  49. /******/     // __webpack_public_path__
  50. /******/     __webpack_require__.p = "";
  51.  
  52. /******/     // Load entry module and return exports
  53. /******/     return __webpack_require__(0);
  54. /******/ })
  55. /************************************************************************/
  56. /******/ ([
  57. /* 0 */
  58. /***/ function(module, exports, __webpack_require__) {
  59.  
  60.     "use strict";
  61.     /*
  62.       Copyright JS Foundation and other contributors, https://js.foundation/
  63.  
  64.       Redistribution and use in source and binary forms, with or without
  65.       modification, are permitted provided that the following conditions are met:
  66.  
  67.         * Redistributions of source code must retain the above copyright
  68.           notice, this list of conditions and the following disclaimer.
  69.         * Redistributions in binary form must reproduce the above copyright
  70.           notice, this list of conditions and the following disclaimer in the
  71.           documentation and/or other materials provided with the distribution.
  72.  
  73.       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  74.       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  75.       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  76.       ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  77.       DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  78.       (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  79.       LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  80.       ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  81.       (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  82.       THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  83.     */
  84.     Object.defineProperty(exports, "__esModule", { value: true });
  85.     var comment_handler_1 = __webpack_require__(1);
  86.     var jsx_parser_1 = __webpack_require__(3);
  87.     var parser_1 = __webpack_require__(8);
  88.     var tokenizer_1 = __webpack_require__(15);
  89.     function parse(code, options, delegate) {
  90.         var commentHandler = null;
  91.         var proxyDelegate = function (node, metadata) {
  92.             if (delegate) {
  93.                 delegate(node, metadata);
  94.             }
  95.             if (commentHandler) {
  96.                 commentHandler.visit(node, metadata);
  97.             }
  98.         };
  99.         var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null;
  100.         var collectComment = false;
  101.         if (options) {
  102.             collectComment = (typeof options.comment === 'boolean' && options.comment);
  103.             var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment);
  104.             if (collectComment || attachComment) {
  105.                 commentHandler = new comment_handler_1.CommentHandler();
  106.                 commentHandler.attach = attachComment;
  107.                 options.comment = true;
  108.                 parserDelegate = proxyDelegate;
  109.             }
  110.         }
  111.         var isModule = false;
  112.         if (options && typeof options.sourceType === 'string') {
  113.             isModule = (options.sourceType === 'module');
  114.         }
  115.         var parser;
  116.         if (options && typeof options.jsx === 'boolean' && options.jsx) {
  117.             parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);
  118.         }
  119.         else {
  120.             parser = new parser_1.Parser(code, options, parserDelegate);
  121.         }
  122.         var program = isModule ? parser.parseModule() : parser.parseScript();
  123.         var ast = program;
  124.         if (collectComment && commentHandler) {
  125.             ast.comments = commentHandler.comments;
  126.         }
  127.         if (parser.config.tokens) {
  128.             ast.tokens = parser.tokens;
  129.         }
  130.         if (parser.config.tolerant) {
  131.             ast.errors = parser.errorHandler.errors;
  132.         }
  133.         return ast;
  134.     }
  135.     exports.parse = parse;
  136.     function parseModule(code, options, delegate) {
  137.         var parsingOptions = options || {};
  138.         parsingOptions.sourceType = 'module';
  139.         return parse(code, parsingOptions, delegate);
  140.     }
  141.     exports.parseModule = parseModule;
  142.     function parseScript(code, options, delegate) {
  143.         var parsingOptions = options || {};
  144.         parsingOptions.sourceType = 'script';
  145.         return parse(code, parsingOptions, delegate);
  146.     }
  147.     exports.parseScript = parseScript;
  148.     function tokenize(code, options, delegate) {
  149.         var tokenizer = new tokenizer_1.Tokenizer(code, options);
  150.         var tokens;
  151.         tokens = [];
  152.         try {
  153.             while (true) {
  154.                 var token = tokenizer.getNextToken();
  155.                 if (!token) {
  156.                     break;
  157.                 }
  158.                 if (delegate) {
  159.                     token = delegate(token);
  160.                 }
  161.                 tokens.push(token);
  162.             }
  163.         }
  164.         catch (e) {
  165.             tokenizer.errorHandler.tolerate(e);
  166.         }
  167.         if (tokenizer.errorHandler.tolerant) {
  168.             tokens.errors = tokenizer.errors();
  169.         }
  170.         return tokens;
  171.     }
  172.     exports.tokenize = tokenize;
  173.     var syntax_1 = __webpack_require__(2);
  174.     exports.Syntax = syntax_1.Syntax;
  175.     // Sync with *.json manifests.
  176.     exports.version = '4.0.0';
  177.  
  178.  
  179. /***/ },
  180. /* 1 */
  181. /***/ function(module, exports, __webpack_require__) {
  182.  
  183.     "use strict";
  184.     Object.defineProperty(exports, "__esModule", { value: true });
  185.     var syntax_1 = __webpack_require__(2);
  186.     var CommentHandler = (function () {
  187.         function CommentHandler() {
  188.             this.attach = false;
  189.             this.comments = [];
  190.             this.stack = [];
  191.             this.leading = [];
  192.             this.trailing = [];
  193.         }
  194.         CommentHandler.prototype.insertInnerComments = function (node, metadata) {
  195.             //  innnerComments for properties empty block
  196.             //  `function a() {/** comments **\/}`
  197.             if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {
  198.                 var innerComments = [];
  199.                 for (var i = this.leading.length - 1; i >= 0; --i) {
  200.                     var entry = this.leading[i];
  201.                     if (metadata.end.offset >= entry.start) {
  202.                         innerComments.unshift(entry.comment);
  203.                         this.leading.splice(i, 1);
  204.                         this.trailing.splice(i, 1);
  205.                     }
  206.                 }
  207.                 if (innerComments.length) {
  208.                     node.innerComments = innerComments;
  209.                 }
  210.             }
  211.         };
  212.         CommentHandler.prototype.findTrailingComments = function (metadata) {
  213.             var trailingComments = [];
  214.             if (this.trailing.length > 0) {
  215.                 for (var i = this.trailing.length - 1; i >= 0; --i) {
  216.                     var entry_1 = this.trailing[i];
  217.                     if (entry_1.start >= metadata.end.offset) {
  218.                         trailingComments.unshift(entry_1.comment);
  219.                     }
  220.                 }
  221.                 this.trailing.length = 0;
  222.                 return trailingComments;
  223.             }
  224.             var entry = this.stack[this.stack.length - 1];
  225.             if (entry && entry.node.trailingComments) {
  226.                 var firstComment = entry.node.trailingComments[0];
  227.                 if (firstComment && firstComment.range[0] >= metadata.end.offset) {
  228.                     trailingComments = entry.node.trailingComments;
  229.                     delete entry.node.trailingComments;
  230.                 }
  231.             }
  232.             return trailingComments;
  233.         };
  234.         CommentHandler.prototype.findLeadingComments = function (metadata) {
  235.             var leadingComments = [];
  236.             var target;
  237.             while (this.stack.length > 0) {
  238.                 var entry = this.stack[this.stack.length - 1];
  239.                 if (entry && entry.start >= metadata.start.offset) {
  240.                     target = entry.node;
  241.                     this.stack.pop();
  242.                 }
  243.                 else {
  244.                     break;
  245.                 }
  246.             }
  247.             if (target) {
  248.                 var count = target.leadingComments ? target.leadingComments.length : 0;
  249.                 for (var i = count - 1; i >= 0; --i) {
  250.                     var comment = target.leadingComments[i];
  251.                     if (comment.range[1] <= metadata.start.offset) {
  252.                         leadingComments.unshift(comment);
  253.                         target.leadingComments.splice(i, 1);
  254.                     }
  255.                 }
  256.                 if (target.leadingComments && target.leadingComments.length === 0) {
  257.                     delete target.leadingComments;
  258.                 }
  259.                 return leadingComments;
  260.             }
  261.             for (var i = this.leading.length - 1; i >= 0; --i) {
  262.                 var entry = this.leading[i];
  263.                 if (entry.start <= metadata.start.offset) {
  264.                     leadingComments.unshift(entry.comment);
  265.                     this.leading.splice(i, 1);
  266.                 }
  267.             }
  268.             return leadingComments;
  269.         };
  270.         CommentHandler.prototype.visitNode = function (node, metadata) {
  271.             if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {
  272.                 return;
  273.             }
  274.             this.insertInnerComments(node, metadata);
  275.             var trailingComments = this.findTrailingComments(metadata);
  276.             var leadingComments = this.findLeadingComments(metadata);
  277.             if (leadingComments.length > 0) {
  278.                 node.leadingComments = leadingComments;
  279.             }
  280.             if (trailingComments.length > 0) {
  281.                 node.trailingComments = trailingComments;
  282.             }
  283.             this.stack.push({
  284.                 node: node,
  285.                 start: metadata.start.offset
  286.             });
  287.         };
  288.         CommentHandler.prototype.visitComment = function (node, metadata) {
  289.             var type = (node.type[0] === 'L') ? 'Line' : 'Block';
  290.             var comment = {
  291.                 type: type,
  292.                 value: node.value
  293.             };
  294.             if (node.range) {
  295.                 comment.range = node.range;
  296.             }
  297.             if (node.loc) {
  298.                 comment.loc = node.loc;
  299.             }
  300.             this.comments.push(comment);
  301.             if (this.attach) {
  302.                 var entry = {
  303.                     comment: {
  304.                         type: type,
  305.                         value: node.value,
  306.                         range: [metadata.start.offset, metadata.end.offset]
  307.                     },
  308.                     start: metadata.start.offset
  309.                 };
  310.                 if (node.loc) {
  311.                     entry.comment.loc = node.loc;
  312.                 }
  313.                 node.type = type;
  314.                 this.leading.push(entry);
  315.                 this.trailing.push(entry);
  316.             }
  317.         };
  318.         CommentHandler.prototype.visit = function (node, metadata) {
  319.             if (node.type === 'LineComment') {
  320.                 this.visitComment(node, metadata);
  321.             }
  322.             else if (node.type === 'BlockComment') {
  323.                 this.visitComment(node, metadata);
  324.             }
  325.             else if (this.attach) {
  326.                 this.visitNode(node, metadata);
  327.             }
  328.         };
  329.         return CommentHandler;
  330.     }());
  331.     exports.CommentHandler = CommentHandler;
  332.  
  333.  
  334. /***/ },
  335. /* 2 */
  336. /***/ function(module, exports) {
  337.  
  338.     "use strict";
  339.     Object.defineProperty(exports, "__esModule", { value: true });
  340.     exports.Syntax = {
  341.         AssignmentExpression: 'AssignmentExpression',
  342.         AssignmentPattern: 'AssignmentPattern',
  343.         ArrayExpression: 'ArrayExpression',
  344.         ArrayPattern: 'ArrayPattern',
  345.         ArrowFunctionExpression: 'ArrowFunctionExpression',
  346.         AwaitExpression: 'AwaitExpression',
  347.         BlockStatement: 'BlockStatement',
  348.         BinaryExpression: 'BinaryExpression',
  349.         BreakStatement: 'BreakStatement',
  350.         CallExpression: 'CallExpression',
  351.         CatchClause: 'CatchClause',
  352.         ClassBody: 'ClassBody',
  353.         ClassDeclaration: 'ClassDeclaration',
  354.         ClassExpression: 'ClassExpression',
  355.         ConditionalExpression: 'ConditionalExpression',
  356.         ContinueStatement: 'ContinueStatement',
  357.         DoWhileStatement: 'DoWhileStatement',
  358.         DebuggerStatement: 'DebuggerStatement',
  359.         EmptyStatement: 'EmptyStatement',
  360.         ExportAllDeclaration: 'ExportAllDeclaration',
  361.         ExportDefaultDeclaration: 'ExportDefaultDeclaration',
  362.         ExportNamedDeclaration: 'ExportNamedDeclaration',
  363.         ExportSpecifier: 'ExportSpecifier',
  364.         ExpressionStatement: 'ExpressionStatement',
  365.         ForStatement: 'ForStatement',
  366.         ForOfStatement: 'ForOfStatement',
  367.         ForInStatement: 'ForInStatement',
  368.         FunctionDeclaration: 'FunctionDeclaration',
  369.         FunctionExpression: 'FunctionExpression',
  370.         Identifier: 'Identifier',
  371.         IfStatement: 'IfStatement',
  372.         ImportDeclaration: 'ImportDeclaration',
  373.         ImportDefaultSpecifier: 'ImportDefaultSpecifier',
  374.         ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
  375.         ImportSpecifier: 'ImportSpecifier',
  376.         Literal: 'Literal',
  377.         LabeledStatement: 'LabeledStatement',
  378.         LogicalExpression: 'LogicalExpression',
  379.         MemberExpression: 'MemberExpression',
  380.         MetaProperty: 'MetaProperty',
  381.         MethodDefinition: 'MethodDefinition',
  382.         NewExpression: 'NewExpression',
  383.         ObjectExpression: 'ObjectExpression',
  384.         ObjectPattern: 'ObjectPattern',
  385.         Program: 'Program',
  386.         Property: 'Property',
  387.         RestElement: 'RestElement',
  388.         ReturnStatement: 'ReturnStatement',
  389.         SequenceExpression: 'SequenceExpression',
  390.         SpreadElement: 'SpreadElement',
  391.         Super: 'Super',
  392.         SwitchCase: 'SwitchCase',
  393.         SwitchStatement: 'SwitchStatement',
  394.         TaggedTemplateExpression: 'TaggedTemplateExpression',
  395.         TemplateElement: 'TemplateElement',
  396.         TemplateLiteral: 'TemplateLiteral',
  397.         ThisExpression: 'ThisExpression',
  398.         ThrowStatement: 'ThrowStatement',
  399.         TryStatement: 'TryStatement',
  400.         UnaryExpression: 'UnaryExpression',
  401.         UpdateExpression: 'UpdateExpression',
  402.         VariableDeclaration: 'VariableDeclaration',
  403.         VariableDeclarator: 'VariableDeclarator',
  404.         WhileStatement: 'WhileStatement',
  405.         WithStatement: 'WithStatement',
  406.         YieldExpression: 'YieldExpression'
  407.     };
  408.  
  409.  
  410. /***/ },
  411. /* 3 */
  412. /***/ function(module, exports, __webpack_require__) {
  413.  
  414.     "use strict";
  415. /* istanbul ignore next */
  416.     var __extends = (this && this.__extends) || (function () {
  417.         var extendStatics = Object.setPrototypeOf ||
  418.             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
  419.             function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
  420.         return function (d, b) {
  421.             extendStatics(d, b);
  422.             function __() { this.constructor = d; }
  423.             d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  424.         };
  425.     })();
  426.     Object.defineProperty(exports, "__esModule", { value: true });
  427.     var character_1 = __webpack_require__(4);
  428.     var JSXNode = __webpack_require__(5);
  429.     var jsx_syntax_1 = __webpack_require__(6);
  430.     var Node = __webpack_require__(7);
  431.     var parser_1 = __webpack_require__(8);
  432.     var token_1 = __webpack_require__(13);
  433.     var xhtml_entities_1 = __webpack_require__(14);
  434.     token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier';
  435.     token_1.TokenName[101 /* Text */] = 'JSXText';
  436.     // Fully qualified element name, e.g. <svg:path> returns "svg:path"
  437.     function getQualifiedElementName(elementName) {
  438.         var qualifiedName;
  439.         switch (elementName.type) {
  440.             case jsx_syntax_1.JSXSyntax.JSXIdentifier:
  441.                 var id = elementName;
  442.                 qualifiedName = id.name;
  443.                 break;
  444.             case jsx_syntax_1.JSXSyntax.JSXNamespacedName:
  445.                 var ns = elementName;
  446.                 qualifiedName = getQualifiedElementName(ns.namespace) + ':' +
  447.                     getQualifiedElementName(ns.name);
  448.                 break;
  449.             case jsx_syntax_1.JSXSyntax.JSXMemberExpression:
  450.                 var expr = elementName;
  451.                 qualifiedName = getQualifiedElementName(expr.object) + '.' +
  452.                     getQualifiedElementName(expr.property);
  453.                 break;
  454.             /* istanbul ignore next */
  455.             default:
  456.                 break;
  457.         }
  458.         return qualifiedName;
  459.     }
  460.     var JSXParser = (function (_super) {
  461.         __extends(JSXParser, _super);
  462.         function JSXParser(code, options, delegate) {
  463.             return _super.call(this, code, options, delegate) || this;
  464.         }
  465.         JSXParser.prototype.parsePrimaryExpression = function () {
  466.             return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
  467.         };
  468.         JSXParser.prototype.startJSX = function () {
  469.             // Unwind the scanner before the lookahead token.
  470.             this.scanner.index = this.startMarker.index;
  471.             this.scanner.lineNumber = this.startMarker.line;
  472.             this.scanner.lineStart = this.startMarker.index - this.startMarker.column;
  473.         };
  474.         JSXParser.prototype.finishJSX = function () {
  475.             // Prime the next lookahead.
  476.             this.nextToken();
  477.         };
  478.         JSXParser.prototype.reenterJSX = function () {
  479.             this.startJSX();
  480.             this.expectJSX('}');
  481.             // Pop the closing '}' added from the lookahead.
  482.             if (this.config.tokens) {
  483.                 this.tokens.pop();
  484.             }
  485.         };
  486.         JSXParser.prototype.createJSXNode = function () {
  487.             this.collectComments();
  488.             return {
  489.                 index: this.scanner.index,
  490.                 line: this.scanner.lineNumber,
  491.                 column: this.scanner.index - this.scanner.lineStart
  492.             };
  493.         };
  494.         JSXParser.prototype.createJSXChildNode = function () {
  495.             return {
  496.                 index: this.scanner.index,
  497.                 line: this.scanner.lineNumber,
  498.                 column: this.scanner.index - this.scanner.lineStart
  499.             };
  500.         };
  501.         JSXParser.prototype.scanXHTMLEntity = function (quote) {
  502.             var result = '&';
  503.             var valid = true;
  504.             var terminated = false;
  505.             var numeric = false;
  506.             var hex = false;
  507.             while (!this.scanner.eof() && valid && !terminated) {
  508.                 var ch = this.scanner.source[this.scanner.index];
  509.                 if (ch === quote) {
  510.                     break;
  511.                 }
  512.                 terminated = (ch === ';');
  513.                 result += ch;
  514.                 ++this.scanner.index;
  515.                 if (!terminated) {
  516.                     switch (result.length) {
  517.                         case 2:
  518.                             // e.g. '{'
  519.                             numeric = (ch === '#');
  520.                             break;
  521.                         case 3:
  522.                             if (numeric) {
  523.                                 // e.g. 'A'
  524.                                 hex = (ch === 'x');
  525.                                 valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));
  526.                                 numeric = numeric && !hex;
  527.                             }
  528.                             break;
  529.                         default:
  530.                             valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));
  531.                             valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));
  532.                             break;
  533.                     }
  534.                 }
  535.             }
  536.             if (valid && terminated && result.length > 2) {
  537.                 // e.g. 'A' becomes just '#x41'
  538.                 var str = result.substr(1, result.length - 2);
  539.                 if (numeric && str.length > 1) {
  540.                     result = String.fromCharCode(parseInt(str.substr(1), 10));
  541.                 }
  542.                 else if (hex && str.length > 2) {
  543.                     result = String.fromCharCode(parseInt('0' + str.substr(1), 16));
  544.                 }
  545.                 else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {
  546.                     result = xhtml_entities_1.XHTMLEntities[str];
  547.                 }
  548.             }
  549.             return result;
  550.         };
  551.         // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.
  552.         JSXParser.prototype.lexJSX = function () {
  553.             var cp = this.scanner.source.charCodeAt(this.scanner.index);
  554.             // < > / : = { }
  555.             if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
  556.                 var value = this.scanner.source[this.scanner.index++];
  557.                 return {
  558.                     type: 7 /* Punctuator */,
  559.                     value: value,
  560.                     lineNumber: this.scanner.lineNumber,
  561.                     lineStart: this.scanner.lineStart,
  562.                     start: this.scanner.index - 1,
  563.                     end: this.scanner.index
  564.                 };
  565.             }
  566.             // " '
  567.             if (cp === 34 || cp === 39) {
  568.                 var start = this.scanner.index;
  569.                 var quote = this.scanner.source[this.scanner.index++];
  570.                 var str = '';
  571.                 while (!this.scanner.eof()) {
  572.                     var ch = this.scanner.source[this.scanner.index++];
  573.                     if (ch === quote) {
  574.                         break;
  575.                     }
  576.                     else if (ch === '&') {
  577.                         str += this.scanXHTMLEntity(quote);
  578.                     }
  579.                     else {
  580.                         str += ch;
  581.                     }
  582.                 }
  583.                 return {
  584.                     type: 8 /* StringLiteral */,
  585.                     value: str,
  586.                     lineNumber: this.scanner.lineNumber,
  587.                     lineStart: this.scanner.lineStart,
  588.                     start: start,
  589.                     end: this.scanner.index
  590.                 };
  591.             }
  592.             // ... or .
  593.             if (cp === 46) {
  594.                 var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
  595.                 var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
  596.                 var value = (n1 === 46 && n2 === 46) ? '...' : '.';
  597.                 var start = this.scanner.index;
  598.                 this.scanner.index += value.length;
  599.                 return {
  600.                     type: 7 /* Punctuator */,
  601.                     value: value,
  602.                     lineNumber: this.scanner.lineNumber,
  603.                     lineStart: this.scanner.lineStart,
  604.                     start: start,
  605.                     end: this.scanner.index
  606.                 };
  607.             }
  608.             // `
  609.             if (cp === 96) {
  610.                 // Only placeholder, since it will be rescanned as a real assignment expression.
  611.                 return {
  612.                     type: 10 /* Template */,
  613.                     value: '',
  614.                     lineNumber: this.scanner.lineNumber,
  615.                     lineStart: this.scanner.lineStart,
  616.                     start: this.scanner.index,
  617.                     end: this.scanner.index
  618.                 };
  619.             }
  620.             // Identifer can not contain backslash (char code 92).
  621.             if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) {
  622.                 var start = this.scanner.index;
  623.                 ++this.scanner.index;
  624.                 while (!this.scanner.eof()) {
  625.                     var ch = this.scanner.source.charCodeAt(this.scanner.index);
  626.                     if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) {
  627.                         ++this.scanner.index;
  628.                     }
  629.                     else if (ch === 45) {
  630.                         // Hyphen (char code 45) can be part of an identifier.
  631.                         ++this.scanner.index;
  632.                     }
  633.                     else {
  634.                         break;
  635.                     }
  636.                 }
  637.                 var id = this.scanner.source.slice(start, this.scanner.index);
  638.                 return {
  639.                     type: 100 /* Identifier */,
  640.                     value: id,
  641.                     lineNumber: this.scanner.lineNumber,
  642.                     lineStart: this.scanner.lineStart,
  643.                     start: start,
  644.                     end: this.scanner.index
  645.                 };
  646.             }
  647.             return this.scanner.lex();
  648.         };
  649.         JSXParser.prototype.nextJSXToken = function () {
  650.             this.collectComments();
  651.             this.startMarker.index = this.scanner.index;
  652.             this.startMarker.line = this.scanner.lineNumber;
  653.             this.startMarker.column = this.scanner.index - this.scanner.lineStart;
  654.             var token = this.lexJSX();
  655.             this.lastMarker.index = this.scanner.index;
  656.             this.lastMarker.line = this.scanner.lineNumber;
  657.             this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
  658.             if (this.config.tokens) {
  659.                 this.tokens.push(this.convertToken(token));
  660.             }
  661.             return token;
  662.         };
  663.         JSXParser.prototype.nextJSXText = function () {
  664.             this.startMarker.index = this.scanner.index;
  665.             this.startMarker.line = this.scanner.lineNumber;
  666.             this.startMarker.column = this.scanner.index - this.scanner.lineStart;
  667.             var start = this.scanner.index;
  668.             var text = '';
  669.             while (!this.scanner.eof()) {
  670.                 var ch = this.scanner.source[this.scanner.index];
  671.                 if (ch === '{' || ch === '<') {
  672.                     break;
  673.                 }
  674.                 ++this.scanner.index;
  675.                 text += ch;
  676.                 if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  677.                     ++this.scanner.lineNumber;
  678.                     if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {
  679.                         ++this.scanner.index;
  680.                     }
  681.                     this.scanner.lineStart = this.scanner.index;
  682.                 }
  683.             }
  684.             this.lastMarker.index = this.scanner.index;
  685.             this.lastMarker.line = this.scanner.lineNumber;
  686.             this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
  687.             var token = {
  688.                 type: 101 /* Text */,
  689.                 value: text,
  690.                 lineNumber: this.scanner.lineNumber,
  691.                 lineStart: this.scanner.lineStart,
  692.                 start: start,
  693.                 end: this.scanner.index
  694.             };
  695.             if ((text.length > 0) && this.config.tokens) {
  696.                 this.tokens.push(this.convertToken(token));
  697.             }
  698.             return token;
  699.         };
  700.         JSXParser.prototype.peekJSXToken = function () {
  701.             var state = this.scanner.saveState();
  702.             this.scanner.scanComments();
  703.             var next = this.lexJSX();
  704.             this.scanner.restoreState(state);
  705.             return next;
  706.         };
  707.         // Expect the next JSX token to match the specified punctuator.
  708.         // If not, an exception will be thrown.
  709.         JSXParser.prototype.expectJSX = function (value) {
  710.             var token = this.nextJSXToken();
  711.             if (token.type !== 7 /* Punctuator */ || token.value !== value) {
  712.                 this.throwUnexpectedToken(token);
  713.             }
  714.         };
  715.         // Return true if the next JSX token matches the specified punctuator.
  716.         JSXParser.prototype.matchJSX = function (value) {
  717.             var next = this.peekJSXToken();
  718.             return next.type === 7 /* Punctuator */ && next.value === value;
  719.         };
  720.         JSXParser.prototype.parseJSXIdentifier = function () {
  721.             var node = this.createJSXNode();
  722.             var token = this.nextJSXToken();
  723.             if (token.type !== 100 /* Identifier */) {
  724.                 this.throwUnexpectedToken(token);
  725.             }
  726.             return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
  727.         };
  728.         JSXParser.prototype.parseJSXElementName = function () {
  729.             var node = this.createJSXNode();
  730.             var elementName = this.parseJSXIdentifier();
  731.             if (this.matchJSX(':')) {
  732.                 var namespace = elementName;
  733.                 this.expectJSX(':');
  734.                 var name_1 = this.parseJSXIdentifier();
  735.                 elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));
  736.             }
  737.             else if (this.matchJSX('.')) {
  738.                 while (this.matchJSX('.')) {
  739.                     var object = elementName;
  740.                     this.expectJSX('.');
  741.                     var property = this.parseJSXIdentifier();
  742.                     elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));
  743.                 }
  744.             }
  745.             return elementName;
  746.         };
  747.         JSXParser.prototype.parseJSXAttributeName = function () {
  748.             var node = this.createJSXNode();
  749.             var attributeName;
  750.             var identifier = this.parseJSXIdentifier();
  751.             if (this.matchJSX(':')) {
  752.                 var namespace = identifier;
  753.                 this.expectJSX(':');
  754.                 var name_2 = this.parseJSXIdentifier();
  755.                 attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));
  756.             }
  757.             else {
  758.                 attributeName = identifier;
  759.             }
  760.             return attributeName;
  761.         };
  762.         JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
  763.             var node = this.createJSXNode();
  764.             var token = this.nextJSXToken();
  765.             if (token.type !== 8 /* StringLiteral */) {
  766.                 this.throwUnexpectedToken(token);
  767.             }
  768.             var raw = this.getTokenRaw(token);
  769.             return this.finalize(node, new Node.Literal(token.value, raw));
  770.         };
  771.         JSXParser.prototype.parseJSXExpressionAttribute = function () {
  772.             var node = this.createJSXNode();
  773.             this.expectJSX('{');
  774.             this.finishJSX();
  775.             if (this.match('}')) {
  776.                 this.tolerateError('JSX attributes must only be assigned a non-empty expression');
  777.             }
  778.             var expression = this.parseAssignmentExpression();
  779.             this.reenterJSX();
  780.             return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
  781.         };
  782.         JSXParser.prototype.parseJSXAttributeValue = function () {
  783.             return this.matchJSX('{') ? this.parseJSXExpressionAttribute() :
  784.                 this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();
  785.         };
  786.         JSXParser.prototype.parseJSXNameValueAttribute = function () {
  787.             var node = this.createJSXNode();
  788.             var name = this.parseJSXAttributeName();
  789.             var value = null;
  790.             if (this.matchJSX('=')) {
  791.                 this.expectJSX('=');
  792.                 value = this.parseJSXAttributeValue();
  793.             }
  794.             return this.finalize(node, new JSXNode.JSXAttribute(name, value));
  795.         };
  796.         JSXParser.prototype.parseJSXSpreadAttribute = function () {
  797.             var node = this.createJSXNode();
  798.             this.expectJSX('{');
  799.             this.expectJSX('...');
  800.             this.finishJSX();
  801.             var argument = this.parseAssignmentExpression();
  802.             this.reenterJSX();
  803.             return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));
  804.         };
  805.         JSXParser.prototype.parseJSXAttributes = function () {
  806.             var attributes = [];
  807.             while (!this.matchJSX('/') && !this.matchJSX('>')) {
  808.                 var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
  809.                     this.parseJSXNameValueAttribute();
  810.                 attributes.push(attribute);
  811.             }
  812.             return attributes;
  813.         };
  814.         JSXParser.prototype.parseJSXOpeningElement = function () {
  815.             var node = this.createJSXNode();
  816.             this.expectJSX('<');
  817.             var name = this.parseJSXElementName();
  818.             var attributes = this.parseJSXAttributes();
  819.             var selfClosing = this.matchJSX('/');
  820.             if (selfClosing) {
  821.                 this.expectJSX('/');
  822.             }
  823.             this.expectJSX('>');
  824.             return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
  825.         };
  826.         JSXParser.prototype.parseJSXBoundaryElement = function () {
  827.             var node = this.createJSXNode();
  828.             this.expectJSX('<');
  829.             if (this.matchJSX('/')) {
  830.                 this.expectJSX('/');
  831.                 var name_3 = this.parseJSXElementName();
  832.                 this.expectJSX('>');
  833.                 return this.finalize(node, new JSXNode.JSXClosingElement(name_3));
  834.             }
  835.             var name = this.parseJSXElementName();
  836.             var attributes = this.parseJSXAttributes();
  837.             var selfClosing = this.matchJSX('/');
  838.             if (selfClosing) {
  839.                 this.expectJSX('/');
  840.             }
  841.             this.expectJSX('>');
  842.             return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
  843.         };
  844.         JSXParser.prototype.parseJSXEmptyExpression = function () {
  845.             var node = this.createJSXChildNode();
  846.             this.collectComments();
  847.             this.lastMarker.index = this.scanner.index;
  848.             this.lastMarker.line = this.scanner.lineNumber;
  849.             this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
  850.             return this.finalize(node, new JSXNode.JSXEmptyExpression());
  851.         };
  852.         JSXParser.prototype.parseJSXExpressionContainer = function () {
  853.             var node = this.createJSXNode();
  854.             this.expectJSX('{');
  855.             var expression;
  856.             if (this.matchJSX('}')) {
  857.                 expression = this.parseJSXEmptyExpression();
  858.                 this.expectJSX('}');
  859.             }
  860.             else {
  861.                 this.finishJSX();
  862.                 expression = this.parseAssignmentExpression();
  863.                 this.reenterJSX();
  864.             }
  865.             return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
  866.         };
  867.         JSXParser.prototype.parseJSXChildren = function () {
  868.             var children = [];
  869.             while (!this.scanner.eof()) {
  870.                 var node = this.createJSXChildNode();
  871.                 var token = this.nextJSXText();
  872.                 if (token.start < token.end) {
  873.                     var raw = this.getTokenRaw(token);
  874.                     var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));
  875.                     children.push(child);
  876.                 }
  877.                 if (this.scanner.source[this.scanner.index] === '{') {
  878.                     var container = this.parseJSXExpressionContainer();
  879.                     children.push(container);
  880.                 }
  881.                 else {
  882.                     break;
  883.                 }
  884.             }
  885.             return children;
  886.         };
  887.         JSXParser.prototype.parseComplexJSXElement = function (el) {
  888.             var stack = [];
  889.             while (!this.scanner.eof()) {
  890.                 el.children = el.children.concat(this.parseJSXChildren());
  891.                 var node = this.createJSXChildNode();
  892.                 var element = this.parseJSXBoundaryElement();
  893.                 if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {
  894.                     var opening = element;
  895.                     if (opening.selfClosing) {
  896.                         var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));
  897.                         el.children.push(child);
  898.                     }
  899.                     else {
  900.                         stack.push(el);
  901.                         el = { node: node, opening: opening, closing: null, children: [] };
  902.                     }
  903.                 }
  904.                 if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {
  905.                     el.closing = element;
  906.                     var open_1 = getQualifiedElementName(el.opening.name);
  907.                     var close_1 = getQualifiedElementName(el.closing.name);
  908.                     if (open_1 !== close_1) {
  909.                         this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);
  910.                     }
  911.                     if (stack.length > 0) {
  912.                         var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));
  913.                         el = stack[stack.length - 1];
  914.                         el.children.push(child);
  915.                         stack.pop();
  916.                     }
  917.                     else {
  918.                         break;
  919.                     }
  920.                 }
  921.             }
  922.             return el;
  923.         };
  924.         JSXParser.prototype.parseJSXElement = function () {
  925.             var node = this.createJSXNode();
  926.             var opening = this.parseJSXOpeningElement();
  927.             var children = [];
  928.             var closing = null;
  929.             if (!opening.selfClosing) {
  930.                 var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children });
  931.                 children = el.children;
  932.                 closing = el.closing;
  933.             }
  934.             return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
  935.         };
  936.         JSXParser.prototype.parseJSXRoot = function () {
  937.             // Pop the opening '<' added from the lookahead.
  938.             if (this.config.tokens) {
  939.                 this.tokens.pop();
  940.             }
  941.             this.startJSX();
  942.             var element = this.parseJSXElement();
  943.             this.finishJSX();
  944.             return element;
  945.         };
  946.         JSXParser.prototype.isStartOfExpression = function () {
  947.             return _super.prototype.isStartOfExpression.call(this) || this.match('<');
  948.         };
  949.         return JSXParser;
  950.     }(parser_1.Parser));
  951.     exports.JSXParser = JSXParser;
  952.  
  953.  
  954. /***/ },
  955. /* 4 */
  956. /***/ function(module, exports) {
  957.  
  958.     "use strict";
  959.     Object.defineProperty(exports, "__esModule", { value: true });
  960.     // See also tools/generate-unicode-regex.js.
  961.     var Regex = {
  962.         // Unicode v8.0.0 NonAsciiIdentifierStart:
  963.         NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,
  964.         // Unicode v8.0.0 NonAsciiIdentifierPart:
  965.         NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
  966.     };
  967.     exports.Character = {
  968.         /* tslint:disable:no-bitwise */
  969.         fromCodePoint: function (cp) {
  970.             return (cp < 0x10000) ? String.fromCharCode(cp) :
  971.                 String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +
  972.                     String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));
  973.         },
  974.         // https://tc39.github.io/ecma262/#sec-white-space
  975.         isWhiteSpace: function (cp) {
  976.             return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) ||
  977.                 (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0);
  978.         },
  979.         // https://tc39.github.io/ecma262/#sec-line-terminators
  980.         isLineTerminator: function (cp) {
  981.             return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
  982.         },
  983.         // https://tc39.github.io/ecma262/#sec-names-and-keywords
  984.         isIdentifierStart: function (cp) {
  985.             return (cp === 0x24) || (cp === 0x5F) ||
  986.                 (cp >= 0x41 && cp <= 0x5A) ||
  987.                 (cp >= 0x61 && cp <= 0x7A) ||
  988.                 (cp === 0x5C) ||
  989.                 ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));
  990.         },
  991.         isIdentifierPart: function (cp) {
  992.             return (cp === 0x24) || (cp === 0x5F) ||
  993.                 (cp >= 0x41 && cp <= 0x5A) ||
  994.                 (cp >= 0x61 && cp <= 0x7A) ||
  995.                 (cp >= 0x30 && cp <= 0x39) ||
  996.                 (cp === 0x5C) ||
  997.                 ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
  998.         },
  999.         // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
  1000.         isDecimalDigit: function (cp) {
  1001.             return (cp >= 0x30 && cp <= 0x39); // 0..9
  1002.         },
  1003.         isHexDigit: function (cp) {
  1004.             return (cp >= 0x30 && cp <= 0x39) ||
  1005.                 (cp >= 0x41 && cp <= 0x46) ||
  1006.                 (cp >= 0x61 && cp <= 0x66); // a..f
  1007.         },
  1008.         isOctalDigit: function (cp) {
  1009.             return (cp >= 0x30 && cp <= 0x37); // 0..7
  1010.         }
  1011.     };
  1012.  
  1013.  
  1014. /***/ },
  1015. /* 5 */
  1016. /***/ function(module, exports, __webpack_require__) {
  1017.  
  1018.     "use strict";
  1019.     Object.defineProperty(exports, "__esModule", { value: true });
  1020.     var jsx_syntax_1 = __webpack_require__(6);
  1021.     /* tslint:disable:max-classes-per-file */
  1022.     var JSXClosingElement = (function () {
  1023.         function JSXClosingElement(name) {
  1024.             this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;
  1025.             this.name = name;
  1026.         }
  1027.         return JSXClosingElement;
  1028.     }());
  1029.     exports.JSXClosingElement = JSXClosingElement;
  1030.     var JSXElement = (function () {
  1031.         function JSXElement(openingElement, children, closingElement) {
  1032.             this.type = jsx_syntax_1.JSXSyntax.JSXElement;
  1033.             this.openingElement = openingElement;
  1034.             this.children = children;
  1035.             this.closingElement = closingElement;
  1036.         }
  1037.         return JSXElement;
  1038.     }());
  1039.     exports.JSXElement = JSXElement;
  1040.     var JSXEmptyExpression = (function () {
  1041.         function JSXEmptyExpression() {
  1042.             this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;
  1043.         }
  1044.         return JSXEmptyExpression;
  1045.     }());
  1046.     exports.JSXEmptyExpression = JSXEmptyExpression;
  1047.     var JSXExpressionContainer = (function () {
  1048.         function JSXExpressionContainer(expression) {
  1049.             this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;
  1050.             this.expression = expression;
  1051.         }
  1052.         return JSXExpressionContainer;
  1053.     }());
  1054.     exports.JSXExpressionContainer = JSXExpressionContainer;
  1055.     var JSXIdentifier = (function () {
  1056.         function JSXIdentifier(name) {
  1057.             this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;
  1058.             this.name = name;
  1059.         }
  1060.         return JSXIdentifier;
  1061.     }());
  1062.     exports.JSXIdentifier = JSXIdentifier;
  1063.     var JSXMemberExpression = (function () {
  1064.         function JSXMemberExpression(object, property) {
  1065.             this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
  1066.             this.object = object;
  1067.             this.property = property;
  1068.         }
  1069.         return JSXMemberExpression;
  1070.     }());
  1071.     exports.JSXMemberExpression = JSXMemberExpression;
  1072.     var JSXAttribute = (function () {
  1073.         function JSXAttribute(name, value) {
  1074.             this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
  1075.             this.name = name;
  1076.             this.value = value;
  1077.         }
  1078.         return JSXAttribute;
  1079.     }());
  1080.     exports.JSXAttribute = JSXAttribute;
  1081.     var JSXNamespacedName = (function () {
  1082.         function JSXNamespacedName(namespace, name) {
  1083.             this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
  1084.             this.namespace = namespace;
  1085.             this.name = name;
  1086.         }
  1087.         return JSXNamespacedName;
  1088.     }());
  1089.     exports.JSXNamespacedName = JSXNamespacedName;
  1090.     var JSXOpeningElement = (function () {
  1091.         function JSXOpeningElement(name, selfClosing, attributes) {
  1092.             this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
  1093.             this.name = name;
  1094.             this.selfClosing = selfClosing;
  1095.             this.attributes = attributes;
  1096.         }
  1097.         return JSXOpeningElement;
  1098.     }());
  1099.     exports.JSXOpeningElement = JSXOpeningElement;
  1100.     var JSXSpreadAttribute = (function () {
  1101.         function JSXSpreadAttribute(argument) {
  1102.             this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;
  1103.             this.argument = argument;
  1104.         }
  1105.         return JSXSpreadAttribute;
  1106.     }());
  1107.     exports.JSXSpreadAttribute = JSXSpreadAttribute;
  1108.     var JSXText = (function () {
  1109.         function JSXText(value, raw) {
  1110.             this.type = jsx_syntax_1.JSXSyntax.JSXText;
  1111.             this.value = value;
  1112.             this.raw = raw;
  1113.         }
  1114.         return JSXText;
  1115.     }());
  1116.     exports.JSXText = JSXText;
  1117.  
  1118.  
  1119. /***/ },
  1120. /* 6 */
  1121. /***/ function(module, exports) {
  1122.  
  1123.     "use strict";
  1124.     Object.defineProperty(exports, "__esModule", { value: true });
  1125.     exports.JSXSyntax = {
  1126.         JSXAttribute: 'JSXAttribute',
  1127.         JSXClosingElement: 'JSXClosingElement',
  1128.         JSXElement: 'JSXElement',
  1129.         JSXEmptyExpression: 'JSXEmptyExpression',
  1130.         JSXExpressionContainer: 'JSXExpressionContainer',
  1131.         JSXIdentifier: 'JSXIdentifier',
  1132.         JSXMemberExpression: 'JSXMemberExpression',
  1133.         JSXNamespacedName: 'JSXNamespacedName',
  1134.         JSXOpeningElement: 'JSXOpeningElement',
  1135.         JSXSpreadAttribute: 'JSXSpreadAttribute',
  1136.         JSXText: 'JSXText'
  1137.     };
  1138.  
  1139.  
  1140. /***/ },
  1141. /* 7 */
  1142. /***/ function(module, exports, __webpack_require__) {
  1143.  
  1144.     "use strict";
  1145.     Object.defineProperty(exports, "__esModule", { value: true });
  1146.     var syntax_1 = __webpack_require__(2);
  1147.     /* tslint:disable:max-classes-per-file */
  1148.     var ArrayExpression = (function () {
  1149.         function ArrayExpression(elements) {
  1150.             this.type = syntax_1.Syntax.ArrayExpression;
  1151.             this.elements = elements;
  1152.         }
  1153.         return ArrayExpression;
  1154.     }());
  1155.     exports.ArrayExpression = ArrayExpression;
  1156.     var ArrayPattern = (function () {
  1157.         function ArrayPattern(elements) {
  1158.             this.type = syntax_1.Syntax.ArrayPattern;
  1159.             this.elements = elements;
  1160.         }
  1161.         return ArrayPattern;
  1162.     }());
  1163.     exports.ArrayPattern = ArrayPattern;
  1164.     var ArrowFunctionExpression = (function () {
  1165.         function ArrowFunctionExpression(params, body, expression) {
  1166.             this.type = syntax_1.Syntax.ArrowFunctionExpression;
  1167.             this.id = null;
  1168.             this.params = params;
  1169.             this.body = body;
  1170.             this.generator = false;
  1171.             this.expression = expression;
  1172.             this.async = false;
  1173.         }
  1174.         return ArrowFunctionExpression;
  1175.     }());
  1176.     exports.ArrowFunctionExpression = ArrowFunctionExpression;
  1177.     var AssignmentExpression = (function () {
  1178.         function AssignmentExpression(operator, left, right) {
  1179.             this.type = syntax_1.Syntax.AssignmentExpression;
  1180.             this.operator = operator;
  1181.             this.left = left;
  1182.             this.right = right;
  1183.         }
  1184.         return AssignmentExpression;
  1185.     }());
  1186.     exports.AssignmentExpression = AssignmentExpression;
  1187.     var AssignmentPattern = (function () {
  1188.         function AssignmentPattern(left, right) {
  1189.             this.type = syntax_1.Syntax.AssignmentPattern;
  1190.             this.left = left;
  1191.             this.right = right;
  1192.         }
  1193.         return AssignmentPattern;
  1194.     }());
  1195.     exports.AssignmentPattern = AssignmentPattern;
  1196.     var AsyncArrowFunctionExpression = (function () {
  1197.         function AsyncArrowFunctionExpression(params, body, expression) {
  1198.             this.type = syntax_1.Syntax.ArrowFunctionExpression;
  1199.             this.id = null;
  1200.             this.params = params;
  1201.             this.body = body;
  1202.             this.generator = false;
  1203.             this.expression = expression;
  1204.             this.async = true;
  1205.         }
  1206.         return AsyncArrowFunctionExpression;
  1207.     }());
  1208.     exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;
  1209.     var AsyncFunctionDeclaration = (function () {
  1210.         function AsyncFunctionDeclaration(id, params, body) {
  1211.             this.type = syntax_1.Syntax.FunctionDeclaration;
  1212.             this.id = id;
  1213.             this.params = params;
  1214.             this.body = body;
  1215.             this.generator = false;
  1216.             this.expression = false;
  1217.             this.async = true;
  1218.         }
  1219.         return AsyncFunctionDeclaration;
  1220.     }());
  1221.     exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;
  1222.     var AsyncFunctionExpression = (function () {
  1223.         function AsyncFunctionExpression(id, params, body) {
  1224.             this.type = syntax_1.Syntax.FunctionExpression;
  1225.             this.id = id;
  1226.             this.params = params;
  1227.             this.body = body;
  1228.             this.generator = false;
  1229.             this.expression = false;
  1230.             this.async = true;
  1231.         }
  1232.         return AsyncFunctionExpression;
  1233.     }());
  1234.     exports.AsyncFunctionExpression = AsyncFunctionExpression;
  1235.     var AwaitExpression = (function () {
  1236.         function AwaitExpression(argument) {
  1237.             this.type = syntax_1.Syntax.AwaitExpression;
  1238.             this.argument = argument;
  1239.         }
  1240.         return AwaitExpression;
  1241.     }());
  1242.     exports.AwaitExpression = AwaitExpression;
  1243.     var BinaryExpression = (function () {
  1244.         function BinaryExpression(operator, left, right) {
  1245.             var logical = (operator === '||' || operator === '&&');
  1246.             this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
  1247.             this.operator = operator;
  1248.             this.left = left;
  1249.             this.right = right;
  1250.         }
  1251.         return BinaryExpression;
  1252.     }());
  1253.     exports.BinaryExpression = BinaryExpression;
  1254.     var BlockStatement = (function () {
  1255.         function BlockStatement(body) {
  1256.             this.type = syntax_1.Syntax.BlockStatement;
  1257.             this.body = body;
  1258.         }
  1259.         return BlockStatement;
  1260.     }());
  1261.     exports.BlockStatement = BlockStatement;
  1262.     var BreakStatement = (function () {
  1263.         function BreakStatement(label) {
  1264.             this.type = syntax_1.Syntax.BreakStatement;
  1265.             this.label = label;
  1266.         }
  1267.         return BreakStatement;
  1268.     }());
  1269.     exports.BreakStatement = BreakStatement;
  1270.     var CallExpression = (function () {
  1271.         function CallExpression(callee, args) {
  1272.             this.type = syntax_1.Syntax.CallExpression;
  1273.             this.callee = callee;
  1274.             this.arguments = args;
  1275.         }
  1276.         return CallExpression;
  1277.     }());
  1278.     exports.CallExpression = CallExpression;
  1279.     var CatchClause = (function () {
  1280.         function CatchClause(param, body) {
  1281.             this.type = syntax_1.Syntax.CatchClause;
  1282.             this.param = param;
  1283.             this.body = body;
  1284.         }
  1285.         return CatchClause;
  1286.     }());
  1287.     exports.CatchClause = CatchClause;
  1288.     var ClassBody = (function () {
  1289.         function ClassBody(body) {
  1290.             this.type = syntax_1.Syntax.ClassBody;
  1291.             this.body = body;
  1292.         }
  1293.         return ClassBody;
  1294.     }());
  1295.     exports.ClassBody = ClassBody;
  1296.     var ClassDeclaration = (function () {
  1297.         function ClassDeclaration(id, superClass, body) {
  1298.             this.type = syntax_1.Syntax.ClassDeclaration;
  1299.             this.id = id;
  1300.             this.superClass = superClass;
  1301.             this.body = body;
  1302.         }
  1303.         return ClassDeclaration;
  1304.     }());
  1305.     exports.ClassDeclaration = ClassDeclaration;
  1306.     var ClassExpression = (function () {
  1307.         function ClassExpression(id, superClass, body) {
  1308.             this.type = syntax_1.Syntax.ClassExpression;
  1309.             this.id = id;
  1310.             this.superClass = superClass;
  1311.             this.body = body;
  1312.         }
  1313.         return ClassExpression;
  1314.     }());
  1315.     exports.ClassExpression = ClassExpression;
  1316.     var ComputedMemberExpression = (function () {
  1317.         function ComputedMemberExpression(object, property) {
  1318.             this.type = syntax_1.Syntax.MemberExpression;
  1319.             this.computed = true;
  1320.             this.object = object;
  1321.             this.property = property;
  1322.         }
  1323.         return ComputedMemberExpression;
  1324.     }());
  1325.     exports.ComputedMemberExpression = ComputedMemberExpression;
  1326.     var ConditionalExpression = (function () {
  1327.         function ConditionalExpression(test, consequent, alternate) {
  1328.             this.type = syntax_1.Syntax.ConditionalExpression;
  1329.             this.test = test;
  1330.             this.consequent = consequent;
  1331.             this.alternate = alternate;
  1332.         }
  1333.         return ConditionalExpression;
  1334.     }());
  1335.     exports.ConditionalExpression = ConditionalExpression;
  1336.     var ContinueStatement = (function () {
  1337.         function ContinueStatement(label) {
  1338.             this.type = syntax_1.Syntax.ContinueStatement;
  1339.             this.label = label;
  1340.         }
  1341.         return ContinueStatement;
  1342.     }());
  1343.     exports.ContinueStatement = ContinueStatement;
  1344.     var DebuggerStatement = (function () {
  1345.         function DebuggerStatement() {
  1346.             this.type = syntax_1.Syntax.DebuggerStatement;
  1347.         }
  1348.         return DebuggerStatement;
  1349.     }());
  1350.     exports.DebuggerStatement = DebuggerStatement;
  1351.     var Directive = (function () {
  1352.         function Directive(expression, directive) {
  1353.             this.type = syntax_1.Syntax.ExpressionStatement;
  1354.             this.expression = expression;
  1355.             this.directive = directive;
  1356.         }
  1357.         return Directive;
  1358.     }());
  1359.     exports.Directive = Directive;
  1360.     var DoWhileStatement = (function () {
  1361.         function DoWhileStatement(body, test) {
  1362.             this.type = syntax_1.Syntax.DoWhileStatement;
  1363.             this.body = body;
  1364.             this.test = test;
  1365.         }
  1366.         return DoWhileStatement;
  1367.     }());
  1368.     exports.DoWhileStatement = DoWhileStatement;
  1369.     var EmptyStatement = (function () {
  1370.         function EmptyStatement() {
  1371.             this.type = syntax_1.Syntax.EmptyStatement;
  1372.         }
  1373.         return EmptyStatement;
  1374.     }());
  1375.     exports.EmptyStatement = EmptyStatement;
  1376.     var ExportAllDeclaration = (function () {
  1377.         function ExportAllDeclaration(source) {
  1378.             this.type = syntax_1.Syntax.ExportAllDeclaration;
  1379.             this.source = source;
  1380.         }
  1381.         return ExportAllDeclaration;
  1382.     }());
  1383.     exports.ExportAllDeclaration = ExportAllDeclaration;
  1384.     var ExportDefaultDeclaration = (function () {
  1385.         function ExportDefaultDeclaration(declaration) {
  1386.             this.type = syntax_1.Syntax.ExportDefaultDeclaration;
  1387.             this.declaration = declaration;
  1388.         }
  1389.         return ExportDefaultDeclaration;
  1390.     }());
  1391.     exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
  1392.     var ExportNamedDeclaration = (function () {
  1393.         function ExportNamedDeclaration(declaration, specifiers, source) {
  1394.             this.type = syntax_1.Syntax.ExportNamedDeclaration;
  1395.             this.declaration = declaration;
  1396.             this.specifiers = specifiers;
  1397.             this.source = source;
  1398.         }
  1399.         return ExportNamedDeclaration;
  1400.     }());
  1401.     exports.ExportNamedDeclaration = ExportNamedDeclaration;
  1402.     var ExportSpecifier = (function () {
  1403.         function ExportSpecifier(local, exported) {
  1404.             this.type = syntax_1.Syntax.ExportSpecifier;
  1405.             this.exported = exported;
  1406.             this.local = local;
  1407.         }
  1408.         return ExportSpecifier;
  1409.     }());
  1410.     exports.ExportSpecifier = ExportSpecifier;
  1411.     var ExpressionStatement = (function () {
  1412.         function ExpressionStatement(expression) {
  1413.             this.type = syntax_1.Syntax.ExpressionStatement;
  1414.             this.expression = expression;
  1415.         }
  1416.         return ExpressionStatement;
  1417.     }());
  1418.     exports.ExpressionStatement = ExpressionStatement;
  1419.     var ForInStatement = (function () {
  1420.         function ForInStatement(left, right, body) {
  1421.             this.type = syntax_1.Syntax.ForInStatement;
  1422.             this.left = left;
  1423.             this.right = right;
  1424.             this.body = body;
  1425.             this.each = false;
  1426.         }
  1427.         return ForInStatement;
  1428.     }());
  1429.     exports.ForInStatement = ForInStatement;
  1430.     var ForOfStatement = (function () {
  1431.         function ForOfStatement(left, right, body) {
  1432.             this.type = syntax_1.Syntax.ForOfStatement;
  1433.             this.left = left;
  1434.             this.right = right;
  1435.             this.body = body;
  1436.         }
  1437.         return ForOfStatement;
  1438.     }());
  1439.     exports.ForOfStatement = ForOfStatement;
  1440.     var ForStatement = (function () {
  1441.         function ForStatement(init, test, update, body) {
  1442.             this.type = syntax_1.Syntax.ForStatement;
  1443.             this.init = init;
  1444.             this.test = test;
  1445.             this.update = update;
  1446.             this.body = body;
  1447.         }
  1448.         return ForStatement;
  1449.     }());
  1450.     exports.ForStatement = ForStatement;
  1451.     var FunctionDeclaration = (function () {
  1452.         function FunctionDeclaration(id, params, body, generator) {
  1453.             this.type = syntax_1.Syntax.FunctionDeclaration;
  1454.             this.id = id;
  1455.             this.params = params;
  1456.             this.body = body;
  1457.             this.generator = generator;
  1458.             this.expression = false;
  1459.             this.async = false;
  1460.         }
  1461.         return FunctionDeclaration;
  1462.     }());
  1463.     exports.FunctionDeclaration = FunctionDeclaration;
  1464.     var FunctionExpression = (function () {
  1465.         function FunctionExpression(id, params, body, generator) {
  1466.             this.type = syntax_1.Syntax.FunctionExpression;
  1467.             this.id = id;
  1468.             this.params = params;
  1469.             this.body = body;
  1470.             this.generator = generator;
  1471.             this.expression = false;
  1472.             this.async = false;
  1473.         }
  1474.         return FunctionExpression;
  1475.     }());
  1476.     exports.FunctionExpression = FunctionExpression;
  1477.     var Identifier = (function () {
  1478.         function Identifier(name) {
  1479.             this.type = syntax_1.Syntax.Identifier;
  1480.             this.name = name;
  1481.         }
  1482.         return Identifier;
  1483.     }());
  1484.     exports.Identifier = Identifier;
  1485.     var IfStatement = (function () {
  1486.         function IfStatement(test, consequent, alternate) {
  1487.             this.type = syntax_1.Syntax.IfStatement;
  1488.             this.test = test;
  1489.             this.consequent = consequent;
  1490.             this.alternate = alternate;
  1491.         }
  1492.         return IfStatement;
  1493.     }());
  1494.     exports.IfStatement = IfStatement;
  1495.     var ImportDeclaration = (function () {
  1496.         function ImportDeclaration(specifiers, source) {
  1497.             this.type = syntax_1.Syntax.ImportDeclaration;
  1498.             this.specifiers = specifiers;
  1499.             this.source = source;
  1500.         }
  1501.         return ImportDeclaration;
  1502.     }());
  1503.     exports.ImportDeclaration = ImportDeclaration;
  1504.     var ImportDefaultSpecifier = (function () {
  1505.         function ImportDefaultSpecifier(local) {
  1506.             this.type = syntax_1.Syntax.ImportDefaultSpecifier;
  1507.             this.local = local;
  1508.         }
  1509.         return ImportDefaultSpecifier;
  1510.     }());
  1511.     exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
  1512.     var ImportNamespaceSpecifier = (function () {
  1513.         function ImportNamespaceSpecifier(local) {
  1514.             this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
  1515.             this.local = local;
  1516.         }
  1517.         return ImportNamespaceSpecifier;
  1518.     }());
  1519.     exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
  1520.     var ImportSpecifier = (function () {
  1521.         function ImportSpecifier(local, imported) {
  1522.             this.type = syntax_1.Syntax.ImportSpecifier;
  1523.             this.local = local;
  1524.             this.imported = imported;
  1525.         }
  1526.         return ImportSpecifier;
  1527.     }());
  1528.     exports.ImportSpecifier = ImportSpecifier;
  1529.     var LabeledStatement = (function () {
  1530.         function LabeledStatement(label, body) {
  1531.             this.type = syntax_1.Syntax.LabeledStatement;
  1532.             this.label = label;
  1533.             this.body = body;
  1534.         }
  1535.         return LabeledStatement;
  1536.     }());
  1537.     exports.LabeledStatement = LabeledStatement;
  1538.     var Literal = (function () {
  1539.         function Literal(value, raw) {
  1540.             this.type = syntax_1.Syntax.Literal;
  1541.             this.value = value;
  1542.             this.raw = raw;
  1543.         }
  1544.         return Literal;
  1545.     }());
  1546.     exports.Literal = Literal;
  1547.     var MetaProperty = (function () {
  1548.         function MetaProperty(meta, property) {
  1549.             this.type = syntax_1.Syntax.MetaProperty;
  1550.             this.meta = meta;
  1551.             this.property = property;
  1552.         }
  1553.         return MetaProperty;
  1554.     }());
  1555.     exports.MetaProperty = MetaProperty;
  1556.     var MethodDefinition = (function () {
  1557.         function MethodDefinition(key, computed, value, kind, isStatic) {
  1558.             this.type = syntax_1.Syntax.MethodDefinition;
  1559.             this.key = key;
  1560.             this.computed = computed;
  1561.             this.value = value;
  1562.             this.kind = kind;
  1563.             this.static = isStatic;
  1564.         }
  1565.         return MethodDefinition;
  1566.     }());
  1567.     exports.MethodDefinition = MethodDefinition;
  1568.     var Module = (function () {
  1569.         function Module(body) {
  1570.             this.type = syntax_1.Syntax.Program;
  1571.             this.body = body;
  1572.             this.sourceType = 'module';
  1573.         }
  1574.         return Module;
  1575.     }());
  1576.     exports.Module = Module;
  1577.     var NewExpression = (function () {
  1578.         function NewExpression(callee, args) {
  1579.             this.type = syntax_1.Syntax.NewExpression;
  1580.             this.callee = callee;
  1581.             this.arguments = args;
  1582.         }
  1583.         return NewExpression;
  1584.     }());
  1585.     exports.NewExpression = NewExpression;
  1586.     var ObjectExpression = (function () {
  1587.         function ObjectExpression(properties) {
  1588.             this.type = syntax_1.Syntax.ObjectExpression;
  1589.             this.properties = properties;
  1590.         }
  1591.         return ObjectExpression;
  1592.     }());
  1593.     exports.ObjectExpression = ObjectExpression;
  1594.     var ObjectPattern = (function () {
  1595.         function ObjectPattern(properties) {
  1596.             this.type = syntax_1.Syntax.ObjectPattern;
  1597.             this.properties = properties;
  1598.         }
  1599.         return ObjectPattern;
  1600.     }());
  1601.     exports.ObjectPattern = ObjectPattern;
  1602.     var Property = (function () {
  1603.         function Property(kind, key, computed, value, method, shorthand) {
  1604.             this.type = syntax_1.Syntax.Property;
  1605.             this.key = key;
  1606.             this.computed = computed;
  1607.             this.value = value;
  1608.             this.kind = kind;
  1609.             this.method = method;
  1610.             this.shorthand = shorthand;
  1611.         }
  1612.         return Property;
  1613.     }());
  1614.     exports.Property = Property;
  1615.     var RegexLiteral = (function () {
  1616.         function RegexLiteral(value, raw, pattern, flags) {
  1617.             this.type = syntax_1.Syntax.Literal;
  1618.             this.value = value;
  1619.             this.raw = raw;
  1620.             this.regex = { pattern: pattern, flags: flags };
  1621.         }
  1622.         return RegexLiteral;
  1623.     }());
  1624.     exports.RegexLiteral = RegexLiteral;
  1625.     var RestElement = (function () {
  1626.         function RestElement(argument) {
  1627.             this.type = syntax_1.Syntax.RestElement;
  1628.             this.argument = argument;
  1629.         }
  1630.         return RestElement;
  1631.     }());
  1632.     exports.RestElement = RestElement;
  1633.     var ReturnStatement = (function () {
  1634.         function ReturnStatement(argument) {
  1635.             this.type = syntax_1.Syntax.ReturnStatement;
  1636.             this.argument = argument;
  1637.         }
  1638.         return ReturnStatement;
  1639.     }());
  1640.     exports.ReturnStatement = ReturnStatement;
  1641.     var Script = (function () {
  1642.         function Script(body) {
  1643.             this.type = syntax_1.Syntax.Program;
  1644.             this.body = body;
  1645.             this.sourceType = 'script';
  1646.         }
  1647.         return Script;
  1648.     }());
  1649.     exports.Script = Script;
  1650.     var SequenceExpression = (function () {
  1651.         function SequenceExpression(expressions) {
  1652.             this.type = syntax_1.Syntax.SequenceExpression;
  1653.             this.expressions = expressions;
  1654.         }
  1655.         return SequenceExpression;
  1656.     }());
  1657.     exports.SequenceExpression = SequenceExpression;
  1658.     var SpreadElement = (function () {
  1659.         function SpreadElement(argument) {
  1660.             this.type = syntax_1.Syntax.SpreadElement;
  1661.             this.argument = argument;
  1662.         }
  1663.         return SpreadElement;
  1664.     }());
  1665.     exports.SpreadElement = SpreadElement;
  1666.     var StaticMemberExpression = (function () {
  1667.         function StaticMemberExpression(object, property) {
  1668.             this.type = syntax_1.Syntax.MemberExpression;
  1669.             this.computed = false;
  1670.             this.object = object;
  1671.             this.property = property;
  1672.         }
  1673.         return StaticMemberExpression;
  1674.     }());
  1675.     exports.StaticMemberExpression = StaticMemberExpression;
  1676.     var Super = (function () {
  1677.         function Super() {
  1678.             this.type = syntax_1.Syntax.Super;
  1679.         }
  1680.         return Super;
  1681.     }());
  1682.     exports.Super = Super;
  1683.     var SwitchCase = (function () {
  1684.         function SwitchCase(test, consequent) {
  1685.             this.type = syntax_1.Syntax.SwitchCase;
  1686.             this.test = test;
  1687.             this.consequent = consequent;
  1688.         }
  1689.         return SwitchCase;
  1690.     }());
  1691.     exports.SwitchCase = SwitchCase;
  1692.     var SwitchStatement = (function () {
  1693.         function SwitchStatement(discriminant, cases) {
  1694.             this.type = syntax_1.Syntax.SwitchStatement;
  1695.             this.discriminant = discriminant;
  1696.             this.cases = cases;
  1697.         }
  1698.         return SwitchStatement;
  1699.     }());
  1700.     exports.SwitchStatement = SwitchStatement;
  1701.     var TaggedTemplateExpression = (function () {
  1702.         function TaggedTemplateExpression(tag, quasi) {
  1703.             this.type = syntax_1.Syntax.TaggedTemplateExpression;
  1704.             this.tag = tag;
  1705.             this.quasi = quasi;
  1706.         }
  1707.         return TaggedTemplateExpression;
  1708.     }());
  1709.     exports.TaggedTemplateExpression = TaggedTemplateExpression;
  1710.     var TemplateElement = (function () {
  1711.         function TemplateElement(value, tail) {
  1712.             this.type = syntax_1.Syntax.TemplateElement;
  1713.             this.value = value;
  1714.             this.tail = tail;
  1715.         }
  1716.         return TemplateElement;
  1717.     }());
  1718.     exports.TemplateElement = TemplateElement;
  1719.     var TemplateLiteral = (function () {
  1720.         function TemplateLiteral(quasis, expressions) {
  1721.             this.type = syntax_1.Syntax.TemplateLiteral;
  1722.             this.quasis = quasis;
  1723.             this.expressions = expressions;
  1724.         }
  1725.         return TemplateLiteral;
  1726.     }());
  1727.     exports.TemplateLiteral = TemplateLiteral;
  1728.     var ThisExpression = (function () {
  1729.         function ThisExpression() {
  1730.             this.type = syntax_1.Syntax.ThisExpression;
  1731.         }
  1732.         return ThisExpression;
  1733.     }());
  1734.     exports.ThisExpression = ThisExpression;
  1735.     var ThrowStatement = (function () {
  1736.         function ThrowStatement(argument) {
  1737.             this.type = syntax_1.Syntax.ThrowStatement;
  1738.             this.argument = argument;
  1739.         }
  1740.         return ThrowStatement;
  1741.     }());
  1742.     exports.ThrowStatement = ThrowStatement;
  1743.     var TryStatement = (function () {
  1744.         function TryStatement(block, handler, finalizer) {
  1745.             this.type = syntax_1.Syntax.TryStatement;
  1746.             this.block = block;
  1747.             this.handler = handler;
  1748.             this.finalizer = finalizer;
  1749.         }
  1750.         return TryStatement;
  1751.     }());
  1752.     exports.TryStatement = TryStatement;
  1753.     var UnaryExpression = (function () {
  1754.         function UnaryExpression(operator, argument) {
  1755.             this.type = syntax_1.Syntax.UnaryExpression;
  1756.             this.operator = operator;
  1757.             this.argument = argument;
  1758.             this.prefix = true;
  1759.         }
  1760.         return UnaryExpression;
  1761.     }());
  1762.     exports.UnaryExpression = UnaryExpression;
  1763.     var UpdateExpression = (function () {
  1764.         function UpdateExpression(operator, argument, prefix) {
  1765.             this.type = syntax_1.Syntax.UpdateExpression;
  1766.             this.operator = operator;
  1767.             this.argument = argument;
  1768.             this.prefix = prefix;
  1769.         }
  1770.         return UpdateExpression;
  1771.     }());
  1772.     exports.UpdateExpression = UpdateExpression;
  1773.     var VariableDeclaration = (function () {
  1774.         function VariableDeclaration(declarations, kind) {
  1775.             this.type = syntax_1.Syntax.VariableDeclaration;
  1776.             this.declarations = declarations;
  1777.             this.kind = kind;
  1778.         }
  1779.         return VariableDeclaration;
  1780.     }());
  1781.     exports.VariableDeclaration = VariableDeclaration;
  1782.     var VariableDeclarator = (function () {
  1783.         function VariableDeclarator(id, init) {
  1784.             this.type = syntax_1.Syntax.VariableDeclarator;
  1785.             this.id = id;
  1786.             this.init = init;
  1787.         }
  1788.         return VariableDeclarator;
  1789.     }());
  1790.     exports.VariableDeclarator = VariableDeclarator;
  1791.     var WhileStatement = (function () {
  1792.         function WhileStatement(test, body) {
  1793.             this.type = syntax_1.Syntax.WhileStatement;
  1794.             this.test = test;
  1795.             this.body = body;
  1796.         }
  1797.         return WhileStatement;
  1798.     }());
  1799.     exports.WhileStatement = WhileStatement;
  1800.     var WithStatement = (function () {
  1801.         function WithStatement(object, body) {
  1802.             this.type = syntax_1.Syntax.WithStatement;
  1803.             this.object = object;
  1804.             this.body = body;
  1805.         }
  1806.         return WithStatement;
  1807.     }());
  1808.     exports.WithStatement = WithStatement;
  1809.     var YieldExpression = (function () {
  1810.         function YieldExpression(argument, delegate) {
  1811.             this.type = syntax_1.Syntax.YieldExpression;
  1812.             this.argument = argument;
  1813.             this.delegate = delegate;
  1814.         }
  1815.         return YieldExpression;
  1816.     }());
  1817.     exports.YieldExpression = YieldExpression;
  1818.  
  1819.  
  1820. /***/ },
  1821. /* 8 */
  1822. /***/ function(module, exports, __webpack_require__) {
  1823.  
  1824.     "use strict";
  1825.     Object.defineProperty(exports, "__esModule", { value: true });
  1826.     var assert_1 = __webpack_require__(9);
  1827.     var error_handler_1 = __webpack_require__(10);
  1828.     var messages_1 = __webpack_require__(11);
  1829.     var Node = __webpack_require__(7);
  1830.     var scanner_1 = __webpack_require__(12);
  1831.     var syntax_1 = __webpack_require__(2);
  1832.     var token_1 = __webpack_require__(13);
  1833.     var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
  1834.     var Parser = (function () {
  1835.         function Parser(code, options, delegate) {
  1836.             if (options === void 0) { options = {}; }
  1837.             this.config = {
  1838.                 range: (typeof options.range === 'boolean') && options.range,
  1839.                 loc: (typeof options.loc === 'boolean') && options.loc,
  1840.                 source: null,
  1841.                 tokens: (typeof options.tokens === 'boolean') && options.tokens,
  1842.                 comment: (typeof options.comment === 'boolean') && options.comment,
  1843.                 tolerant: (typeof options.tolerant === 'boolean') && options.tolerant
  1844.             };
  1845.             if (this.config.loc && options.source && options.source !== null) {
  1846.                 this.config.source = String(options.source);
  1847.             }
  1848.             this.delegate = delegate;
  1849.             this.errorHandler = new error_handler_1.ErrorHandler();
  1850.             this.errorHandler.tolerant = this.config.tolerant;
  1851.             this.scanner = new scanner_1.Scanner(code, this.errorHandler);
  1852.             this.scanner.trackComment = this.config.comment;
  1853.             this.operatorPrecedence = {
  1854.                 ')': 0,
  1855.                 ';': 0,
  1856.                 ',': 0,
  1857.                 '=': 0,
  1858.                 ']': 0,
  1859.                 '||': 1,
  1860.                 '&&': 2,
  1861.                 '|': 3,
  1862.                 '^': 4,
  1863.                 '&': 5,
  1864.                 '==': 6,
  1865.                 '!=': 6,
  1866.                 '===': 6,
  1867.                 '!==': 6,
  1868.                 '<': 7,
  1869.                 '>': 7,
  1870.                 '<=': 7,
  1871.                 '>=': 7,
  1872.                 '<<': 8,
  1873.                 '>>': 8,
  1874.                 '>>>': 8,
  1875.                 '+': 9,
  1876.                 '-': 9,
  1877.                 '*': 11,
  1878.                 '/': 11,
  1879.                 '%': 11
  1880.             };
  1881.             this.lookahead = {
  1882.                 type: 2 /* EOF */,
  1883.                 value: '',
  1884.                 lineNumber: this.scanner.lineNumber,
  1885.                 lineStart: 0,
  1886.                 start: 0,
  1887.                 end: 0
  1888.             };
  1889.             this.hasLineTerminator = false;
  1890.             this.context = {
  1891.                 isModule: false,
  1892.                 await: false,
  1893.                 allowIn: true,
  1894.                 allowStrictDirective: true,
  1895.                 allowYield: true,
  1896.                 firstCoverInitializedNameError: null,
  1897.                 isAssignmentTarget: false,
  1898.                 isBindingElement: false,
  1899.                 inFunctionBody: false,
  1900.                 inIteration: false,
  1901.                 inSwitch: false,
  1902.                 labelSet: {},
  1903.                 strict: false
  1904.             };
  1905.             this.tokens = [];
  1906.             this.startMarker = {
  1907.                 index: 0,
  1908.                 line: this.scanner.lineNumber,
  1909.                 column: 0
  1910.             };
  1911.             this.lastMarker = {
  1912.                 index: 0,
  1913.                 line: this.scanner.lineNumber,
  1914.                 column: 0
  1915.             };
  1916.             this.nextToken();
  1917.             this.lastMarker = {
  1918.                 index: this.scanner.index,
  1919.                 line: this.scanner.lineNumber,
  1920.                 column: this.scanner.index - this.scanner.lineStart
  1921.             };
  1922.         }
  1923.         Parser.prototype.throwError = function (messageFormat) {
  1924.             var values = [];
  1925.             for (var _i = 1; _i < arguments.length; _i++) {
  1926.                 values[_i - 1] = arguments[_i];
  1927.             }
  1928.             var args = Array.prototype.slice.call(arguments, 1);
  1929.             var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
  1930.                 assert_1.assert(idx < args.length, 'Message reference must be in range');
  1931.                 return args[idx];
  1932.             });
  1933.             var index = this.lastMarker.index;
  1934.             var line = this.lastMarker.line;
  1935.             var column = this.lastMarker.column + 1;
  1936.             throw this.errorHandler.createError(index, line, column, msg);
  1937.         };
  1938.         Parser.prototype.tolerateError = function (messageFormat) {
  1939.             var values = [];
  1940.             for (var _i = 1; _i < arguments.length; _i++) {
  1941.                 values[_i - 1] = arguments[_i];
  1942.             }
  1943.             var args = Array.prototype.slice.call(arguments, 1);
  1944.             var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
  1945.                 assert_1.assert(idx < args.length, 'Message reference must be in range');
  1946.                 return args[idx];
  1947.             });
  1948.             var index = this.lastMarker.index;
  1949.             var line = this.scanner.lineNumber;
  1950.             var column = this.lastMarker.column + 1;
  1951.             this.errorHandler.tolerateError(index, line, column, msg);
  1952.         };
  1953.         // Throw an exception because of the token.
  1954.         Parser.prototype.unexpectedTokenError = function (token, message) {
  1955.             var msg = message || messages_1.Messages.UnexpectedToken;
  1956.             var value;
  1957.             if (token) {
  1958.                 if (!message) {
  1959.                     msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS :
  1960.                         (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier :
  1961.                             (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber :
  1962.                                 (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString :
  1963.                                     (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate :
  1964.                                         messages_1.Messages.UnexpectedToken;
  1965.                     if (token.type === 4 /* Keyword */) {
  1966.                         if (this.scanner.isFutureReservedWord(token.value)) {
  1967.                             msg = messages_1.Messages.UnexpectedReserved;
  1968.                         }
  1969.                         else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
  1970.                             msg = messages_1.Messages.StrictReservedWord;
  1971.                         }
  1972.                     }
  1973.                 }
  1974.                 value = token.value;
  1975.             }
  1976.             else {
  1977.                 value = 'ILLEGAL';
  1978.             }
  1979.             msg = msg.replace('%0', value);
  1980.             if (token && typeof token.lineNumber === 'number') {
  1981.                 var index = token.start;
  1982.                 var line = token.lineNumber;
  1983.                 var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
  1984.                 var column = token.start - lastMarkerLineStart + 1;
  1985.                 return this.errorHandler.createError(index, line, column, msg);
  1986.             }
  1987.             else {
  1988.                 var index = this.lastMarker.index;
  1989.                 var line = this.lastMarker.line;
  1990.                 var column = this.lastMarker.column + 1;
  1991.                 return this.errorHandler.createError(index, line, column, msg);
  1992.             }
  1993.         };
  1994.         Parser.prototype.throwUnexpectedToken = function (token, message) {
  1995.             throw this.unexpectedTokenError(token, message);
  1996.         };
  1997.         Parser.prototype.tolerateUnexpectedToken = function (token, message) {
  1998.             this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
  1999.         };
  2000.         Parser.prototype.collectComments = function () {
  2001.             if (!this.config.comment) {
  2002.                 this.scanner.scanComments();
  2003.             }
  2004.             else {
  2005.                 var comments = this.scanner.scanComments();
  2006.                 if (comments.length > 0 && this.delegate) {
  2007.                     for (var i = 0; i < comments.length; ++i) {
  2008.                         var e = comments[i];
  2009.                         var node = void 0;
  2010.                         node = {
  2011.                             type: e.multiLine ? 'BlockComment' : 'LineComment',
  2012.                             value: this.scanner.source.slice(e.slice[0], e.slice[1])
  2013.                         };
  2014.                         if (this.config.range) {
  2015.                             node.range = e.range;
  2016.                         }
  2017.                         if (this.config.loc) {
  2018.                             node.loc = e.loc;
  2019.                         }
  2020.                         var metadata = {
  2021.                             start: {
  2022.                                 line: e.loc.start.line,
  2023.                                 column: e.loc.start.column,
  2024.                                 offset: e.range[0]
  2025.                             },
  2026.                             end: {
  2027.                                 line: e.loc.end.line,
  2028.                                 column: e.loc.end.column,
  2029.                                 offset: e.range[1]
  2030.                             }
  2031.                         };
  2032.                         this.delegate(node, metadata);
  2033.                     }
  2034.                 }
  2035.             }
  2036.         };
  2037.         // From internal representation to an external structure
  2038.         Parser.prototype.getTokenRaw = function (token) {
  2039.             return this.scanner.source.slice(token.start, token.end);
  2040.         };
  2041.         Parser.prototype.convertToken = function (token) {
  2042.             var t = {
  2043.                 type: token_1.TokenName[token.type],
  2044.                 value: this.getTokenRaw(token)
  2045.             };
  2046.             if (this.config.range) {
  2047.                 t.range = [token.start, token.end];
  2048.             }
  2049.             if (this.config.loc) {
  2050.                 t.loc = {
  2051.                     start: {
  2052.                         line: this.startMarker.line,
  2053.                         column: this.startMarker.column
  2054.                     },
  2055.                     end: {
  2056.                         line: this.scanner.lineNumber,
  2057.                         column: this.scanner.index - this.scanner.lineStart
  2058.                     }
  2059.                 };
  2060.             }
  2061.             if (token.type === 9 /* RegularExpression */) {
  2062.                 var pattern = token.pattern;
  2063.                 var flags = token.flags;
  2064.                 t.regex = { pattern: pattern, flags: flags };
  2065.             }
  2066.             return t;
  2067.         };
  2068.         Parser.prototype.nextToken = function () {
  2069.             var token = this.lookahead;
  2070.             this.lastMarker.index = this.scanner.index;
  2071.             this.lastMarker.line = this.scanner.lineNumber;
  2072.             this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
  2073.             this.collectComments();
  2074.             if (this.scanner.index !== this.startMarker.index) {
  2075.                 this.startMarker.index = this.scanner.index;
  2076.                 this.startMarker.line = this.scanner.lineNumber;
  2077.                 this.startMarker.column = this.scanner.index - this.scanner.lineStart;
  2078.             }
  2079.             var next = this.scanner.lex();
  2080.             this.hasLineTerminator = (token.lineNumber !== next.lineNumber);
  2081.             if (next && this.context.strict && next.type === 3 /* Identifier */) {
  2082.                 if (this.scanner.isStrictModeReservedWord(next.value)) {
  2083.                     next.type = 4 /* Keyword */;
  2084.                 }
  2085.             }
  2086.             this.lookahead = next;
  2087.             if (this.config.tokens && next.type !== 2 /* EOF */) {
  2088.                 this.tokens.push(this.convertToken(next));
  2089.             }
  2090.             return token;
  2091.         };
  2092.         Parser.prototype.nextRegexToken = function () {
  2093.             this.collectComments();
  2094.             var token = this.scanner.scanRegExp();
  2095.             if (this.config.tokens) {
  2096.                 // Pop the previous token, '/' or '/='
  2097.                 // This is added from the lookahead token.
  2098.                 this.tokens.pop();
  2099.                 this.tokens.push(this.convertToken(token));
  2100.             }
  2101.             // Prime the next lookahead.
  2102.             this.lookahead = token;
  2103.             this.nextToken();
  2104.             return token;
  2105.         };
  2106.         Parser.prototype.createNode = function () {
  2107.             return {
  2108.                 index: this.startMarker.index,
  2109.                 line: this.startMarker.line,
  2110.                 column: this.startMarker.column
  2111.             };
  2112.         };
  2113.         Parser.prototype.startNode = function (token) {
  2114.             return {
  2115.                 index: token.start,
  2116.                 line: token.lineNumber,
  2117.                 column: token.start - token.lineStart
  2118.             };
  2119.         };
  2120.         Parser.prototype.finalize = function (marker, node) {
  2121.             if (this.config.range) {
  2122.                 node.range = [marker.index, this.lastMarker.index];
  2123.             }
  2124.             if (this.config.loc) {
  2125.                 node.loc = {
  2126.                     start: {
  2127.                         line: marker.line,
  2128.                         column: marker.column,
  2129.                     },
  2130.                     end: {
  2131.                         line: this.lastMarker.line,
  2132.                         column: this.lastMarker.column
  2133.                     }
  2134.                 };
  2135.                 if (this.config.source) {
  2136.                     node.loc.source = this.config.source;
  2137.                 }
  2138.             }
  2139.             if (this.delegate) {
  2140.                 var metadata = {
  2141.                     start: {
  2142.                         line: marker.line,
  2143.                         column: marker.column,
  2144.                         offset: marker.index
  2145.                     },
  2146.                     end: {
  2147.                         line: this.lastMarker.line,
  2148.                         column: this.lastMarker.column,
  2149.                         offset: this.lastMarker.index
  2150.                     }
  2151.                 };
  2152.                 this.delegate(node, metadata);
  2153.             }
  2154.             return node;
  2155.         };
  2156.         // Expect the next token to match the specified punctuator.
  2157.         // If not, an exception will be thrown.
  2158.         Parser.prototype.expect = function (value) {
  2159.             var token = this.nextToken();
  2160.             if (token.type !== 7 /* Punctuator */ || token.value !== value) {
  2161.                 this.throwUnexpectedToken(token);
  2162.             }
  2163.         };
  2164.         // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
  2165.         Parser.prototype.expectCommaSeparator = function () {
  2166.             if (this.config.tolerant) {
  2167.                 var token = this.lookahead;
  2168.                 if (token.type === 7 /* Punctuator */ && token.value === ',') {
  2169.                     this.nextToken();
  2170.                 }
  2171.                 else if (token.type === 7 /* Punctuator */ && token.value === ';') {
  2172.                     this.nextToken();
  2173.                     this.tolerateUnexpectedToken(token);
  2174.                 }
  2175.                 else {
  2176.                     this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
  2177.                 }
  2178.             }
  2179.             else {
  2180.                 this.expect(',');
  2181.             }
  2182.         };
  2183.         // Expect the next token to match the specified keyword.
  2184.         // If not, an exception will be thrown.
  2185.         Parser.prototype.expectKeyword = function (keyword) {
  2186.             var token = this.nextToken();
  2187.             if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
  2188.                 this.throwUnexpectedToken(token);
  2189.             }
  2190.         };
  2191.         // Return true if the next token matches the specified punctuator.
  2192.         Parser.prototype.match = function (value) {
  2193.             return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
  2194.         };
  2195.         // Return true if the next token matches the specified keyword
  2196.         Parser.prototype.matchKeyword = function (keyword) {
  2197.             return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
  2198.         };
  2199.         // Return true if the next token matches the specified contextual keyword
  2200.         // (where an identifier is sometimes a keyword depending on the context)
  2201.         Parser.prototype.matchContextualKeyword = function (keyword) {
  2202.             return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
  2203.         };
  2204.         // Return true if the next token is an assignment operator
  2205.         Parser.prototype.matchAssign = function () {
  2206.             if (this.lookahead.type !== 7 /* Punctuator */) {
  2207.                 return false;
  2208.             }
  2209.             var op = this.lookahead.value;
  2210.             return op === '=' ||
  2211.                 op === '*=' ||
  2212.                 op === '**=' ||
  2213.                 op === '/=' ||
  2214.                 op === '%=' ||
  2215.                 op === '+=' ||
  2216.                 op === '-=' ||
  2217.                 op === '<<=' ||
  2218.                 op === '>>=' ||
  2219.                 op === '>>>=' ||
  2220.                 op === '&=' ||
  2221.                 op === '^=' ||
  2222.                 op === '|=';
  2223.         };
  2224.         // Cover grammar support.
  2225.         //
  2226.         // When an assignment expression position starts with an left parenthesis, the determination of the type
  2227.         // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
  2228.         // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
  2229.         //
  2230.         // There are three productions that can be parsed in a parentheses pair that needs to be determined
  2231.         // after the outermost pair is closed. They are:
  2232.         //
  2233.         //   1. AssignmentExpression
  2234.         //   2. BindingElements
  2235.         //   3. AssignmentTargets
  2236.         //
  2237.         // In order to avoid exponential backtracking, we use two flags to denote if the production can be
  2238.         // binding element or assignment target.
  2239.         //
  2240.         // The three productions have the relationship:
  2241.         //
  2242.         //   BindingElements Î“èå AssignmentTargets Î“èå AssignmentExpression
  2243.         //
  2244.         // with a single exception that CoverInitializedName when used directly in an Expression, generates
  2245.         // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
  2246.         // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
  2247.         //
  2248.         // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
  2249.         // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
  2250.         // the CoverInitializedName check is conducted.
  2251.         //
  2252.         // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
  2253.         // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
  2254.         // pattern. The CoverInitializedName check is deferred.
  2255.         Parser.prototype.isolateCoverGrammar = function (parseFunction) {
  2256.             var previousIsBindingElement = this.context.isBindingElement;
  2257.             var previousIsAssignmentTarget = this.context.isAssignmentTarget;
  2258.             var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
  2259.             this.context.isBindingElement = true;
  2260.             this.context.isAssignmentTarget = true;
  2261.             this.context.firstCoverInitializedNameError = null;
  2262.             var result = parseFunction.call(this);
  2263.             if (this.context.firstCoverInitializedNameError !== null) {
  2264.                 this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
  2265.             }
  2266.             this.context.isBindingElement = previousIsBindingElement;
  2267.             this.context.isAssignmentTarget = previousIsAssignmentTarget;
  2268.             this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
  2269.             return result;
  2270.         };
  2271.         Parser.prototype.inheritCoverGrammar = function (parseFunction) {
  2272.             var previousIsBindingElement = this.context.isBindingElement;
  2273.             var previousIsAssignmentTarget = this.context.isAssignmentTarget;
  2274.             var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
  2275.             this.context.isBindingElement = true;
  2276.             this.context.isAssignmentTarget = true;
  2277.             this.context.firstCoverInitializedNameError = null;
  2278.             var result = parseFunction.call(this);
  2279.             this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
  2280.             this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
  2281.             this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
  2282.             return result;
  2283.         };
  2284.         Parser.prototype.consumeSemicolon = function () {
  2285.             if (this.match(';')) {
  2286.                 this.nextToken();
  2287.             }
  2288.             else if (!this.hasLineTerminator) {
  2289.                 if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
  2290.                     this.throwUnexpectedToken(this.lookahead);
  2291.                 }
  2292.                 this.lastMarker.index = this.startMarker.index;
  2293.                 this.lastMarker.line = this.startMarker.line;
  2294.                 this.lastMarker.column = this.startMarker.column;
  2295.             }
  2296.         };
  2297.         // https://tc39.github.io/ecma262/#sec-primary-expression
  2298.         Parser.prototype.parsePrimaryExpression = function () {
  2299.             var node = this.createNode();
  2300.             var expr;
  2301.             var token, raw;
  2302.             switch (this.lookahead.type) {
  2303.                 case 3 /* Identifier */:
  2304.                     if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
  2305.                         this.tolerateUnexpectedToken(this.lookahead);
  2306.                     }
  2307.                     expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
  2308.                     break;
  2309.                 case 6 /* NumericLiteral */:
  2310.                 case 8 /* StringLiteral */:
  2311.                     if (this.context.strict && this.lookahead.octal) {
  2312.                         this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
  2313.                     }
  2314.                     this.context.isAssignmentTarget = false;
  2315.                     this.context.isBindingElement = false;
  2316.                     token = this.nextToken();
  2317.                     raw = this.getTokenRaw(token);
  2318.                     expr = this.finalize(node, new Node.Literal(token.value, raw));
  2319.                     break;
  2320.                 case 1 /* BooleanLiteral */:
  2321.                     this.context.isAssignmentTarget = false;
  2322.                     this.context.isBindingElement = false;
  2323.                     token = this.nextToken();
  2324.                     raw = this.getTokenRaw(token);
  2325.                     expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
  2326.                     break;
  2327.                 case 5 /* NullLiteral */:
  2328.                     this.context.isAssignmentTarget = false;
  2329.                     this.context.isBindingElement = false;
  2330.                     token = this.nextToken();
  2331.                     raw = this.getTokenRaw(token);
  2332.                     expr = this.finalize(node, new Node.Literal(null, raw));
  2333.                     break;
  2334.                 case 10 /* Template */:
  2335.                     expr = this.parseTemplateLiteral();
  2336.                     break;
  2337.                 case 7 /* Punctuator */:
  2338.                     switch (this.lookahead.value) {
  2339.                         case '(':
  2340.                             this.context.isBindingElement = false;
  2341.                             expr = this.inheritCoverGrammar(this.parseGroupExpression);
  2342.                             break;
  2343.                         case '[':
  2344.                             expr = this.inheritCoverGrammar(this.parseArrayInitializer);
  2345.                             break;
  2346.                         case '{':
  2347.                             expr = this.inheritCoverGrammar(this.parseObjectInitializer);
  2348.                             break;
  2349.                         case '/':
  2350.                         case '/=':
  2351.                             this.context.isAssignmentTarget = false;
  2352.                             this.context.isBindingElement = false;
  2353.                             this.scanner.index = this.startMarker.index;
  2354.                             token = this.nextRegexToken();
  2355.                             raw = this.getTokenRaw(token);
  2356.                             expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
  2357.                             break;
  2358.                         default:
  2359.                             expr = this.throwUnexpectedToken(this.nextToken());
  2360.                     }
  2361.                     break;
  2362.                 case 4 /* Keyword */:
  2363.                     if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
  2364.                         expr = this.parseIdentifierName();
  2365.                     }
  2366.                     else if (!this.context.strict && this.matchKeyword('let')) {
  2367.                         expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
  2368.                     }
  2369.                     else {
  2370.                         this.context.isAssignmentTarget = false;
  2371.                         this.context.isBindingElement = false;
  2372.                         if (this.matchKeyword('function')) {
  2373.                             expr = this.parseFunctionExpression();
  2374.                         }
  2375.                         else if (this.matchKeyword('this')) {
  2376.                             this.nextToken();
  2377.                             expr = this.finalize(node, new Node.ThisExpression());
  2378.                         }
  2379.                         else if (this.matchKeyword('class')) {
  2380.                             expr = this.parseClassExpression();
  2381.                         }
  2382.                         else {
  2383.                             expr = this.throwUnexpectedToken(this.nextToken());
  2384.                         }
  2385.                     }
  2386.                     break;
  2387.                 default:
  2388.                     expr = this.throwUnexpectedToken(this.nextToken());
  2389.             }
  2390.             return expr;
  2391.         };
  2392.         // https://tc39.github.io/ecma262/#sec-array-initializer
  2393.         Parser.prototype.parseSpreadElement = function () {
  2394.             var node = this.createNode();
  2395.             this.expect('...');
  2396.             var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
  2397.             return this.finalize(node, new Node.SpreadElement(arg));
  2398.         };
  2399.         Parser.prototype.parseArrayInitializer = function () {
  2400.             var node = this.createNode();
  2401.             var elements = [];
  2402.             this.expect('[');
  2403.             while (!this.match(']')) {
  2404.                 if (this.match(',')) {
  2405.                     this.nextToken();
  2406.                     elements.push(null);
  2407.                 }
  2408.                 else if (this.match('...')) {
  2409.                     var element = this.parseSpreadElement();
  2410.                     if (!this.match(']')) {
  2411.                         this.context.isAssignmentTarget = false;
  2412.                         this.context.isBindingElement = false;
  2413.                         this.expect(',');
  2414.                     }
  2415.                     elements.push(element);
  2416.                 }
  2417.                 else {
  2418.                     elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
  2419.                     if (!this.match(']')) {
  2420.                         this.expect(',');
  2421.                     }
  2422.                 }
  2423.             }
  2424.             this.expect(']');
  2425.             return this.finalize(node, new Node.ArrayExpression(elements));
  2426.         };
  2427.         // https://tc39.github.io/ecma262/#sec-object-initializer
  2428.         Parser.prototype.parsePropertyMethod = function (params) {
  2429.             this.context.isAssignmentTarget = false;
  2430.             this.context.isBindingElement = false;
  2431.             var previousStrict = this.context.strict;
  2432.             var previousAllowStrictDirective = this.context.allowStrictDirective;
  2433.             this.context.allowStrictDirective = params.simple;
  2434.             var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
  2435.             if (this.context.strict && params.firstRestricted) {
  2436.                 this.tolerateUnexpectedToken(params.firstRestricted, params.message);
  2437.             }
  2438.             if (this.context.strict && params.stricted) {
  2439.                 this.tolerateUnexpectedToken(params.stricted, params.message);
  2440.             }
  2441.             this.context.strict = previousStrict;
  2442.             this.context.allowStrictDirective = previousAllowStrictDirective;
  2443.             return body;
  2444.         };
  2445.         Parser.prototype.parsePropertyMethodFunction = function () {
  2446.             var isGenerator = false;
  2447.             var node = this.createNode();
  2448.             var previousAllowYield = this.context.allowYield;
  2449.             this.context.allowYield = false;
  2450.             var params = this.parseFormalParameters();
  2451.             var method = this.parsePropertyMethod(params);
  2452.             this.context.allowYield = previousAllowYield;
  2453.             return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
  2454.         };
  2455.         Parser.prototype.parsePropertyMethodAsyncFunction = function () {
  2456.             var node = this.createNode();
  2457.             var previousAllowYield = this.context.allowYield;
  2458.             var previousAwait = this.context.await;
  2459.             this.context.allowYield = false;
  2460.             this.context.await = true;
  2461.             var params = this.parseFormalParameters();
  2462.             var method = this.parsePropertyMethod(params);
  2463.             this.context.allowYield = previousAllowYield;
  2464.             this.context.await = previousAwait;
  2465.             return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
  2466.         };
  2467.         Parser.prototype.parseObjectPropertyKey = function () {
  2468.             var node = this.createNode();
  2469.             var token = this.nextToken();
  2470.             var key;
  2471.             switch (token.type) {
  2472.                 case 8 /* StringLiteral */:
  2473.                 case 6 /* NumericLiteral */:
  2474.                     if (this.context.strict && token.octal) {
  2475.                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
  2476.                     }
  2477.                     var raw = this.getTokenRaw(token);
  2478.                     key = this.finalize(node, new Node.Literal(token.value, raw));
  2479.                     break;
  2480.                 case 3 /* Identifier */:
  2481.                 case 1 /* BooleanLiteral */:
  2482.                 case 5 /* NullLiteral */:
  2483.                 case 4 /* Keyword */:
  2484.                     key = this.finalize(node, new Node.Identifier(token.value));
  2485.                     break;
  2486.                 case 7 /* Punctuator */:
  2487.                     if (token.value === '[') {
  2488.                         key = this.isolateCoverGrammar(this.parseAssignmentExpression);
  2489.                         this.expect(']');
  2490.                     }
  2491.                     else {
  2492.                         key = this.throwUnexpectedToken(token);
  2493.                     }
  2494.                     break;
  2495.                 default:
  2496.                     key = this.throwUnexpectedToken(token);
  2497.             }
  2498.             return key;
  2499.         };
  2500.         Parser.prototype.isPropertyKey = function (key, value) {
  2501.             return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
  2502.                 (key.type === syntax_1.Syntax.Literal && key.value === value);
  2503.         };
  2504.         Parser.prototype.parseObjectProperty = function (hasProto) {
  2505.             var node = this.createNode();
  2506.             var token = this.lookahead;
  2507.             var kind;
  2508.             var key = null;
  2509.             var value = null;
  2510.             var computed = false;
  2511.             var method = false;
  2512.             var shorthand = false;
  2513.             var isAsync = false;
  2514.             if (token.type === 3 /* Identifier */) {
  2515.                 var id = token.value;
  2516.                 this.nextToken();
  2517.                 computed = this.match('[');
  2518.                 isAsync = !this.hasLineTerminator && (id === 'async') &&
  2519.                     !this.match(':') && !this.match('(') && !this.match('*');
  2520.                 key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));
  2521.             }
  2522.             else if (this.match('*')) {
  2523.                 this.nextToken();
  2524.             }
  2525.             else {
  2526.                 computed = this.match('[');
  2527.                 key = this.parseObjectPropertyKey();
  2528.             }
  2529.             var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
  2530.             if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
  2531.                 kind = 'get';
  2532.                 computed = this.match('[');
  2533.                 key = this.parseObjectPropertyKey();
  2534.                 this.context.allowYield = false;
  2535.                 value = this.parseGetterMethod();
  2536.             }
  2537.             else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
  2538.                 kind = 'set';
  2539.                 computed = this.match('[');
  2540.                 key = this.parseObjectPropertyKey();
  2541.                 value = this.parseSetterMethod();
  2542.             }
  2543.             else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
  2544.                 kind = 'init';
  2545.                 computed = this.match('[');
  2546.                 key = this.parseObjectPropertyKey();
  2547.                 value = this.parseGeneratorMethod();
  2548.                 method = true;
  2549.             }
  2550.             else {
  2551.                 if (!key) {
  2552.                     this.throwUnexpectedToken(this.lookahead);
  2553.                 }
  2554.                 kind = 'init';
  2555.                 if (this.match(':') && !isAsync) {
  2556.                     if (!computed && this.isPropertyKey(key, '__proto__')) {
  2557.                         if (hasProto.value) {
  2558.                             this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
  2559.                         }
  2560.                         hasProto.value = true;
  2561.                     }
  2562.                     this.nextToken();
  2563.                     value = this.inheritCoverGrammar(this.parseAssignmentExpression);
  2564.                 }
  2565.                 else if (this.match('(')) {
  2566.                     value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
  2567.                     method = true;
  2568.                 }
  2569.                 else if (token.type === 3 /* Identifier */) {
  2570.                     var id = this.finalize(node, new Node.Identifier(token.value));
  2571.                     if (this.match('=')) {
  2572.                         this.context.firstCoverInitializedNameError = this.lookahead;
  2573.                         this.nextToken();
  2574.                         shorthand = true;
  2575.                         var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
  2576.                         value = this.finalize(node, new Node.AssignmentPattern(id, init));
  2577.                     }
  2578.                     else {
  2579.                         shorthand = true;
  2580.                         value = id;
  2581.                     }
  2582.                 }
  2583.                 else {
  2584.                     this.throwUnexpectedToken(this.nextToken());
  2585.                 }
  2586.             }
  2587.             return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
  2588.         };
  2589.         Parser.prototype.parseObjectInitializer = function () {
  2590.             var node = this.createNode();
  2591.             this.expect('{');
  2592.             var properties = [];
  2593.             var hasProto = { value: false };
  2594.             while (!this.match('}')) {
  2595.                 properties.push(this.parseObjectProperty(hasProto));
  2596.                 if (!this.match('}')) {
  2597.                     this.expectCommaSeparator();
  2598.                 }
  2599.             }
  2600.             this.expect('}');
  2601.             return this.finalize(node, new Node.ObjectExpression(properties));
  2602.         };
  2603.         // https://tc39.github.io/ecma262/#sec-template-literals
  2604.         Parser.prototype.parseTemplateHead = function () {
  2605.             assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
  2606.             var node = this.createNode();
  2607.             var token = this.nextToken();
  2608.             var raw = token.value;
  2609.             var cooked = token.cooked;
  2610.             return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
  2611.         };
  2612.         Parser.prototype.parseTemplateElement = function () {
  2613.             if (this.lookahead.type !== 10 /* Template */) {
  2614.                 this.throwUnexpectedToken();
  2615.             }
  2616.             var node = this.createNode();
  2617.             var token = this.nextToken();
  2618.             var raw = token.value;
  2619.             var cooked = token.cooked;
  2620.             return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
  2621.         };
  2622.         Parser.prototype.parseTemplateLiteral = function () {
  2623.             var node = this.createNode();
  2624.             var expressions = [];
  2625.             var quasis = [];
  2626.             var quasi = this.parseTemplateHead();
  2627.             quasis.push(quasi);
  2628.             while (!quasi.tail) {
  2629.                 expressions.push(this.parseExpression());
  2630.                 quasi = this.parseTemplateElement();
  2631.                 quasis.push(quasi);
  2632.             }
  2633.             return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
  2634.         };
  2635.         // https://tc39.github.io/ecma262/#sec-grouping-operator
  2636.         Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
  2637.             switch (expr.type) {
  2638.                 case syntax_1.Syntax.Identifier:
  2639.                 case syntax_1.Syntax.MemberExpression:
  2640.                 case syntax_1.Syntax.RestElement:
  2641.                 case syntax_1.Syntax.AssignmentPattern:
  2642.                     break;
  2643.                 case syntax_1.Syntax.SpreadElement:
  2644.                     expr.type = syntax_1.Syntax.RestElement;
  2645.                     this.reinterpretExpressionAsPattern(expr.argument);
  2646.                     break;
  2647.                 case syntax_1.Syntax.ArrayExpression:
  2648.                     expr.type = syntax_1.Syntax.ArrayPattern;
  2649.                     for (var i = 0; i < expr.elements.length; i++) {
  2650.                         if (expr.elements[i] !== null) {
  2651.                             this.reinterpretExpressionAsPattern(expr.elements[i]);
  2652.                         }
  2653.                     }
  2654.                     break;
  2655.                 case syntax_1.Syntax.ObjectExpression:
  2656.                     expr.type = syntax_1.Syntax.ObjectPattern;
  2657.                     for (var i = 0; i < expr.properties.length; i++) {
  2658.                         this.reinterpretExpressionAsPattern(expr.properties[i].value);
  2659.                     }
  2660.                     break;
  2661.                 case syntax_1.Syntax.AssignmentExpression:
  2662.                     expr.type = syntax_1.Syntax.AssignmentPattern;
  2663.                     delete expr.operator;
  2664.                     this.reinterpretExpressionAsPattern(expr.left);
  2665.                     break;
  2666.                 default:
  2667.                     // Allow other node type for tolerant parsing.
  2668.                     break;
  2669.             }
  2670.         };
  2671.         Parser.prototype.parseGroupExpression = function () {
  2672.             var expr;
  2673.             this.expect('(');
  2674.             if (this.match(')')) {
  2675.                 this.nextToken();
  2676.                 if (!this.match('=>')) {
  2677.                     this.expect('=>');
  2678.                 }
  2679.                 expr = {
  2680.                     type: ArrowParameterPlaceHolder,
  2681.                     params: [],
  2682.                     async: false
  2683.                 };
  2684.             }
  2685.             else {
  2686.                 var startToken = this.lookahead;
  2687.                 var params = [];
  2688.                 if (this.match('...')) {
  2689.                     expr = this.parseRestElement(params);
  2690.                     this.expect(')');
  2691.                     if (!this.match('=>')) {
  2692.                         this.expect('=>');
  2693.                     }
  2694.                     expr = {
  2695.                         type: ArrowParameterPlaceHolder,
  2696.                         params: [expr],
  2697.                         async: false
  2698.                     };
  2699.                 }
  2700.                 else {
  2701.                     var arrow = false;
  2702.                     this.context.isBindingElement = true;
  2703.                     expr = this.inheritCoverGrammar(this.parseAssignmentExpression);
  2704.                     if (this.match(',')) {
  2705.                         var expressions = [];
  2706.                         this.context.isAssignmentTarget = false;
  2707.                         expressions.push(expr);
  2708.                         while (this.lookahead.type !== 2 /* EOF */) {
  2709.                             if (!this.match(',')) {
  2710.                                 break;
  2711.                             }
  2712.                             this.nextToken();
  2713.                             if (this.match(')')) {
  2714.                                 this.nextToken();
  2715.                                 for (var i = 0; i < expressions.length; i++) {
  2716.                                     this.reinterpretExpressionAsPattern(expressions[i]);
  2717.                                 }
  2718.                                 arrow = true;
  2719.                                 expr = {
  2720.                                     type: ArrowParameterPlaceHolder,
  2721.                                     params: expressions,
  2722.                                     async: false
  2723.                                 };
  2724.                             }
  2725.                             else if (this.match('...')) {
  2726.                                 if (!this.context.isBindingElement) {
  2727.                                     this.throwUnexpectedToken(this.lookahead);
  2728.                                 }
  2729.                                 expressions.push(this.parseRestElement(params));
  2730.                                 this.expect(')');
  2731.                                 if (!this.match('=>')) {
  2732.                                     this.expect('=>');
  2733.                                 }
  2734.                                 this.context.isBindingElement = false;
  2735.                                 for (var i = 0; i < expressions.length; i++) {
  2736.                                     this.reinterpretExpressionAsPattern(expressions[i]);
  2737.                                 }
  2738.                                 arrow = true;
  2739.                                 expr = {
  2740.                                     type: ArrowParameterPlaceHolder,
  2741.                                     params: expressions,
  2742.                                     async: false
  2743.                                 };
  2744.                             }
  2745.                             else {
  2746.                                 expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
  2747.                             }
  2748.                             if (arrow) {
  2749.                                 break;
  2750.                             }
  2751.                         }
  2752.                         if (!arrow) {
  2753.                             expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
  2754.                         }
  2755.                     }
  2756.                     if (!arrow) {
  2757.                         this.expect(')');
  2758.                         if (this.match('=>')) {
  2759.                             if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
  2760.                                 arrow = true;
  2761.                                 expr = {
  2762.                                     type: ArrowParameterPlaceHolder,
  2763.                                     params: [expr],
  2764.                                     async: false
  2765.                                 };
  2766.                             }
  2767.                             if (!arrow) {
  2768.                                 if (!this.context.isBindingElement) {
  2769.                                     this.throwUnexpectedToken(this.lookahead);
  2770.                                 }
  2771.                                 if (expr.type === syntax_1.Syntax.SequenceExpression) {
  2772.                                     for (var i = 0; i < expr.expressions.length; i++) {
  2773.                                         this.reinterpretExpressionAsPattern(expr.expressions[i]);
  2774.                                     }
  2775.                                 }
  2776.                                 else {
  2777.                                     this.reinterpretExpressionAsPattern(expr);
  2778.                                 }
  2779.                                 var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);
  2780.                                 expr = {
  2781.                                     type: ArrowParameterPlaceHolder,
  2782.                                     params: parameters,
  2783.                                     async: false
  2784.                                 };
  2785.                             }
  2786.                         }
  2787.                         this.context.isBindingElement = false;
  2788.                     }
  2789.                 }
  2790.             }
  2791.             return expr;
  2792.         };
  2793.         // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
  2794.         Parser.prototype.parseArguments = function () {
  2795.             this.expect('(');
  2796.             var args = [];
  2797.             if (!this.match(')')) {
  2798.                 while (true) {
  2799.                     var expr = this.match('...') ? this.parseSpreadElement() :
  2800.                         this.isolateCoverGrammar(this.parseAssignmentExpression);
  2801.                     args.push(expr);
  2802.                     if (this.match(')')) {
  2803.                         break;
  2804.                     }
  2805.                     this.expectCommaSeparator();
  2806.                     if (this.match(')')) {
  2807.                         break;
  2808.                     }
  2809.                 }
  2810.             }
  2811.             this.expect(')');
  2812.             return args;
  2813.         };
  2814.         Parser.prototype.isIdentifierName = function (token) {
  2815.             return token.type === 3 /* Identifier */ ||
  2816.                 token.type === 4 /* Keyword */ ||
  2817.                 token.type === 1 /* BooleanLiteral */ ||
  2818.                 token.type === 5 /* NullLiteral */;
  2819.         };
  2820.         Parser.prototype.parseIdentifierName = function () {
  2821.             var node = this.createNode();
  2822.             var token = this.nextToken();
  2823.             if (!this.isIdentifierName(token)) {
  2824.                 this.throwUnexpectedToken(token);
  2825.             }
  2826.             return this.finalize(node, new Node.Identifier(token.value));
  2827.         };
  2828.         Parser.prototype.parseNewExpression = function () {
  2829.             var node = this.createNode();
  2830.             var id = this.parseIdentifierName();
  2831.             assert_1.assert(id.name === 'new', 'New expression must start with `new`');
  2832.             var expr;
  2833.             if (this.match('.')) {
  2834.                 this.nextToken();
  2835.                 if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {
  2836.                     var property = this.parseIdentifierName();
  2837.                     expr = new Node.MetaProperty(id, property);
  2838.                 }
  2839.                 else {
  2840.                     this.throwUnexpectedToken(this.lookahead);
  2841.                 }
  2842.             }
  2843.             else {
  2844.                 var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
  2845.                 var args = this.match('(') ? this.parseArguments() : [];
  2846.                 expr = new Node.NewExpression(callee, args);
  2847.                 this.context.isAssignmentTarget = false;
  2848.                 this.context.isBindingElement = false;
  2849.             }
  2850.             return this.finalize(node, expr);
  2851.         };
  2852.         Parser.prototype.parseAsyncArgument = function () {
  2853.             var arg = this.parseAssignmentExpression();
  2854.             this.context.firstCoverInitializedNameError = null;
  2855.             return arg;
  2856.         };
  2857.         Parser.prototype.parseAsyncArguments = function () {
  2858.             this.expect('(');
  2859.             var args = [];
  2860.             if (!this.match(')')) {
  2861.                 while (true) {
  2862.                     var expr = this.match('...') ? this.parseSpreadElement() :
  2863.                         this.isolateCoverGrammar(this.parseAsyncArgument);
  2864.                     args.push(expr);
  2865.                     if (this.match(')')) {
  2866.                         break;
  2867.                     }
  2868.                     this.expectCommaSeparator();
  2869.                     if (this.match(')')) {
  2870.                         break;
  2871.                     }
  2872.                 }
  2873.             }
  2874.             this.expect(')');
  2875.             return args;
  2876.         };
  2877.         Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
  2878.             var startToken = this.lookahead;
  2879.             var maybeAsync = this.matchContextualKeyword('async');
  2880.             var previousAllowIn = this.context.allowIn;
  2881.             this.context.allowIn = true;
  2882.             var expr;
  2883.             if (this.matchKeyword('super') && this.context.inFunctionBody) {
  2884.                 expr = this.createNode();
  2885.                 this.nextToken();
  2886.                 expr = this.finalize(expr, new Node.Super());
  2887.                 if (!this.match('(') && !this.match('.') && !this.match('[')) {
  2888.                     this.throwUnexpectedToken(this.lookahead);
  2889.                 }
  2890.             }
  2891.             else {
  2892.                 expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
  2893.             }
  2894.             while (true) {
  2895.                 if (this.match('.')) {
  2896.                     this.context.isBindingElement = false;
  2897.                     this.context.isAssignmentTarget = true;
  2898.                     this.expect('.');
  2899.                     var property = this.parseIdentifierName();
  2900.                     expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
  2901.                 }
  2902.                 else if (this.match('(')) {
  2903.                     var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);
  2904.                     this.context.isBindingElement = false;
  2905.                     this.context.isAssignmentTarget = false;
  2906.                     var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
  2907.                     expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
  2908.                     if (asyncArrow && this.match('=>')) {
  2909.                         for (var i = 0; i < args.length; ++i) {
  2910.                             this.reinterpretExpressionAsPattern(args[i]);
  2911.                         }
  2912.                         expr = {
  2913.                             type: ArrowParameterPlaceHolder,
  2914.                             params: args,
  2915.                             async: true
  2916.                         };
  2917.                     }
  2918.                 }
  2919.                 else if (this.match('[')) {
  2920.                     this.context.isBindingElement = false;
  2921.                     this.context.isAssignmentTarget = true;
  2922.                     this.expect('[');
  2923.                     var property = this.isolateCoverGrammar(this.parseExpression);
  2924.                     this.expect(']');
  2925.                     expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
  2926.                 }
  2927.                 else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
  2928.                     var quasi = this.parseTemplateLiteral();
  2929.                     expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
  2930.                 }
  2931.                 else {
  2932.                     break;
  2933.                 }
  2934.             }
  2935.             this.context.allowIn = previousAllowIn;
  2936.             return expr;
  2937.         };
  2938.         Parser.prototype.parseSuper = function () {
  2939.             var node = this.createNode();
  2940.             this.expectKeyword('super');
  2941.             if (!this.match('[') && !this.match('.')) {
  2942.                 this.throwUnexpectedToken(this.lookahead);
  2943.             }
  2944.             return this.finalize(node, new Node.Super());
  2945.         };
  2946.         Parser.prototype.parseLeftHandSideExpression = function () {
  2947.             assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
  2948.             var node = this.startNode(this.lookahead);
  2949.             var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
  2950.                 this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
  2951.             while (true) {
  2952.                 if (this.match('[')) {
  2953.                     this.context.isBindingElement = false;
  2954.                     this.context.isAssignmentTarget = true;
  2955.                     this.expect('[');
  2956.                     var property = this.isolateCoverGrammar(this.parseExpression);
  2957.                     this.expect(']');
  2958.                     expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
  2959.                 }
  2960.                 else if (this.match('.')) {
  2961.                     this.context.isBindingElement = false;
  2962.                     this.context.isAssignmentTarget = true;
  2963.                     this.expect('.');
  2964.                     var property = this.parseIdentifierName();
  2965.                     expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
  2966.                 }
  2967.                 else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
  2968.                     var quasi = this.parseTemplateLiteral();
  2969.                     expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
  2970.                 }
  2971.                 else {
  2972.                     break;
  2973.                 }
  2974.             }
  2975.             return expr;
  2976.         };
  2977.         // https://tc39.github.io/ecma262/#sec-update-expressions
  2978.         Parser.prototype.parseUpdateExpression = function () {
  2979.             var expr;
  2980.             var startToken = this.lookahead;
  2981.             if (this.match('++') || this.match('--')) {
  2982.                 var node = this.startNode(startToken);
  2983.                 var token = this.nextToken();
  2984.                 expr = this.inheritCoverGrammar(this.parseUnaryExpression);
  2985.                 if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
  2986.                     this.tolerateError(messages_1.Messages.StrictLHSPrefix);
  2987.                 }
  2988.                 if (!this.context.isAssignmentTarget) {
  2989.                     this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
  2990.                 }
  2991.                 var prefix = true;
  2992.                 expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
  2993.                 this.context.isAssignmentTarget = false;
  2994.                 this.context.isBindingElement = false;
  2995.             }
  2996.             else {
  2997.                 expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
  2998.                 if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {
  2999.                     if (this.match('++') || this.match('--')) {
  3000.                         if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
  3001.                             this.tolerateError(messages_1.Messages.StrictLHSPostfix);
  3002.                         }
  3003.                         if (!this.context.isAssignmentTarget) {
  3004.                             this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
  3005.                         }
  3006.                         this.context.isAssignmentTarget = false;
  3007.                         this.context.isBindingElement = false;
  3008.                         var operator = this.nextToken().value;
  3009.                         var prefix = false;
  3010.                         expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
  3011.                     }
  3012.                 }
  3013.             }
  3014.             return expr;
  3015.         };
  3016.         // https://tc39.github.io/ecma262/#sec-unary-operators
  3017.         Parser.prototype.parseAwaitExpression = function () {
  3018.             var node = this.createNode();
  3019.             this.nextToken();
  3020.             var argument = this.parseUnaryExpression();
  3021.             return this.finalize(node, new Node.AwaitExpression(argument));
  3022.         };
  3023.         Parser.prototype.parseUnaryExpression = function () {
  3024.             var expr;
  3025.             if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
  3026.                 this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
  3027.                 var node = this.startNode(this.lookahead);
  3028.                 var token = this.nextToken();
  3029.                 expr = this.inheritCoverGrammar(this.parseUnaryExpression);
  3030.                 expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));
  3031.                 if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
  3032.                     this.tolerateError(messages_1.Messages.StrictDelete);
  3033.                 }
  3034.                 this.context.isAssignmentTarget = false;
  3035.                 this.context.isBindingElement = false;
  3036.             }
  3037.             else if (this.context.await && this.matchContextualKeyword('await')) {
  3038.                 expr = this.parseAwaitExpression();
  3039.             }
  3040.             else {
  3041.                 expr = this.parseUpdateExpression();
  3042.             }
  3043.             return expr;
  3044.         };
  3045.         Parser.prototype.parseExponentiationExpression = function () {
  3046.             var startToken = this.lookahead;
  3047.             var expr = this.inheritCoverGrammar(this.parseUnaryExpression);
  3048.             if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
  3049.                 this.nextToken();
  3050.                 this.context.isAssignmentTarget = false;
  3051.                 this.context.isBindingElement = false;
  3052.                 var left = expr;
  3053.                 var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
  3054.                 expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
  3055.             }
  3056.             return expr;
  3057.         };
  3058.         // https://tc39.github.io/ecma262/#sec-exp-operator
  3059.         // https://tc39.github.io/ecma262/#sec-multiplicative-operators
  3060.         // https://tc39.github.io/ecma262/#sec-additive-operators
  3061.         // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
  3062.         // https://tc39.github.io/ecma262/#sec-relational-operators
  3063.         // https://tc39.github.io/ecma262/#sec-equality-operators
  3064.         // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
  3065.         // https://tc39.github.io/ecma262/#sec-binary-logical-operators
  3066.         Parser.prototype.binaryPrecedence = function (token) {
  3067.             var op = token.value;
  3068.             var precedence;
  3069.             if (token.type === 7 /* Punctuator */) {
  3070.                 precedence = this.operatorPrecedence[op] || 0;
  3071.             }
  3072.             else if (token.type === 4 /* Keyword */) {
  3073.                 precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
  3074.             }
  3075.             else {
  3076.                 precedence = 0;
  3077.             }
  3078.             return precedence;
  3079.         };
  3080.         Parser.prototype.parseBinaryExpression = function () {
  3081.             var startToken = this.lookahead;
  3082.             var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
  3083.             var token = this.lookahead;
  3084.             var prec = this.binaryPrecedence(token);
  3085.             if (prec > 0) {
  3086.                 this.nextToken();
  3087.                 this.context.isAssignmentTarget = false;
  3088.                 this.context.isBindingElement = false;
  3089.                 var markers = [startToken, this.lookahead];
  3090.                 var left = expr;
  3091.                 var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
  3092.                 var stack = [left, token.value, right];
  3093.                 var precedences = [prec];
  3094.                 while (true) {
  3095.                     prec = this.binaryPrecedence(this.lookahead);
  3096.                     if (prec <= 0) {
  3097.                         break;
  3098.                     }
  3099.                     // Reduce: make a binary expression from the three topmost entries.
  3100.                     while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {
  3101.                         right = stack.pop();
  3102.                         var operator = stack.pop();
  3103.                         precedences.pop();
  3104.                         left = stack.pop();
  3105.                         markers.pop();
  3106.                         var node = this.startNode(markers[markers.length - 1]);
  3107.                         stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
  3108.                     }
  3109.                     // Shift.
  3110.                     stack.push(this.nextToken().value);
  3111.                     precedences.push(prec);
  3112.                     markers.push(this.lookahead);
  3113.                     stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
  3114.                 }
  3115.                 // Final reduce to clean-up the stack.
  3116.                 var i = stack.length - 1;
  3117.                 expr = stack[i];
  3118.                 markers.pop();
  3119.                 while (i > 1) {
  3120.                     var node = this.startNode(markers.pop());
  3121.                     var operator = stack[i - 1];
  3122.                     expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
  3123.                     i -= 2;
  3124.                 }
  3125.             }
  3126.             return expr;
  3127.         };
  3128.         // https://tc39.github.io/ecma262/#sec-conditional-operator
  3129.         Parser.prototype.parseConditionalExpression = function () {
  3130.             var startToken = this.lookahead;
  3131.             var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
  3132.             if (this.match('?')) {
  3133.                 this.nextToken();
  3134.                 var previousAllowIn = this.context.allowIn;
  3135.                 this.context.allowIn = true;
  3136.                 var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3137.                 this.context.allowIn = previousAllowIn;
  3138.                 this.expect(':');
  3139.                 var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3140.                 expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
  3141.                 this.context.isAssignmentTarget = false;
  3142.                 this.context.isBindingElement = false;
  3143.             }
  3144.             return expr;
  3145.         };
  3146.         // https://tc39.github.io/ecma262/#sec-assignment-operators
  3147.         Parser.prototype.checkPatternParam = function (options, param) {
  3148.             switch (param.type) {
  3149.                 case syntax_1.Syntax.Identifier:
  3150.                     this.validateParam(options, param, param.name);
  3151.                     break;
  3152.                 case syntax_1.Syntax.RestElement:
  3153.                     this.checkPatternParam(options, param.argument);
  3154.                     break;
  3155.                 case syntax_1.Syntax.AssignmentPattern:
  3156.                     this.checkPatternParam(options, param.left);
  3157.                     break;
  3158.                 case syntax_1.Syntax.ArrayPattern:
  3159.                     for (var i = 0; i < param.elements.length; i++) {
  3160.                         if (param.elements[i] !== null) {
  3161.                             this.checkPatternParam(options, param.elements[i]);
  3162.                         }
  3163.                     }
  3164.                     break;
  3165.                 case syntax_1.Syntax.ObjectPattern:
  3166.                     for (var i = 0; i < param.properties.length; i++) {
  3167.                         this.checkPatternParam(options, param.properties[i].value);
  3168.                     }
  3169.                     break;
  3170.                 default:
  3171.                     break;
  3172.             }
  3173.             options.simple = options.simple && (param instanceof Node.Identifier);
  3174.         };
  3175.         Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
  3176.             var params = [expr];
  3177.             var options;
  3178.             var asyncArrow = false;
  3179.             switch (expr.type) {
  3180.                 case syntax_1.Syntax.Identifier:
  3181.                     break;
  3182.                 case ArrowParameterPlaceHolder:
  3183.                     params = expr.params;
  3184.                     asyncArrow = expr.async;
  3185.                     break;
  3186.                 default:
  3187.                     return null;
  3188.             }
  3189.             options = {
  3190.                 simple: true,
  3191.                 paramSet: {}
  3192.             };
  3193.             for (var i = 0; i < params.length; ++i) {
  3194.                 var param = params[i];
  3195.                 if (param.type === syntax_1.Syntax.AssignmentPattern) {
  3196.                     if (param.right.type === syntax_1.Syntax.YieldExpression) {
  3197.                         if (param.right.argument) {
  3198.                             this.throwUnexpectedToken(this.lookahead);
  3199.                         }
  3200.                         param.right.type = syntax_1.Syntax.Identifier;
  3201.                         param.right.name = 'yield';
  3202.                         delete param.right.argument;
  3203.                         delete param.right.delegate;
  3204.                     }
  3205.                 }
  3206.                 else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
  3207.                     this.throwUnexpectedToken(this.lookahead);
  3208.                 }
  3209.                 this.checkPatternParam(options, param);
  3210.                 params[i] = param;
  3211.             }
  3212.             if (this.context.strict || !this.context.allowYield) {
  3213.                 for (var i = 0; i < params.length; ++i) {
  3214.                     var param = params[i];
  3215.                     if (param.type === syntax_1.Syntax.YieldExpression) {
  3216.                         this.throwUnexpectedToken(this.lookahead);
  3217.                     }
  3218.                 }
  3219.             }
  3220.             if (options.message === messages_1.Messages.StrictParamDupe) {
  3221.                 var token = this.context.strict ? options.stricted : options.firstRestricted;
  3222.                 this.throwUnexpectedToken(token, options.message);
  3223.             }
  3224.             return {
  3225.                 simple: options.simple,
  3226.                 params: params,
  3227.                 stricted: options.stricted,
  3228.                 firstRestricted: options.firstRestricted,
  3229.                 message: options.message
  3230.             };
  3231.         };
  3232.         Parser.prototype.parseAssignmentExpression = function () {
  3233.             var expr;
  3234.             if (!this.context.allowYield && this.matchKeyword('yield')) {
  3235.                 expr = this.parseYieldExpression();
  3236.             }
  3237.             else {
  3238.                 var startToken = this.lookahead;
  3239.                 var token = startToken;
  3240.                 expr = this.parseConditionalExpression();
  3241.                 if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') {
  3242.                     if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) {
  3243.                         var arg = this.parsePrimaryExpression();
  3244.                         this.reinterpretExpressionAsPattern(arg);
  3245.                         expr = {
  3246.                             type: ArrowParameterPlaceHolder,
  3247.                             params: [arg],
  3248.                             async: true
  3249.                         };
  3250.                     }
  3251.                 }
  3252.                 if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
  3253.                     // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
  3254.                     this.context.isAssignmentTarget = false;
  3255.                     this.context.isBindingElement = false;
  3256.                     var isAsync = expr.async;
  3257.                     var list = this.reinterpretAsCoverFormalsList(expr);
  3258.                     if (list) {
  3259.                         if (this.hasLineTerminator) {
  3260.                             this.tolerateUnexpectedToken(this.lookahead);
  3261.                         }
  3262.                         this.context.firstCoverInitializedNameError = null;
  3263.                         var previousStrict = this.context.strict;
  3264.                         var previousAllowStrictDirective = this.context.allowStrictDirective;
  3265.                         this.context.allowStrictDirective = list.simple;
  3266.                         var previousAllowYield = this.context.allowYield;
  3267.                         var previousAwait = this.context.await;
  3268.                         this.context.allowYield = true;
  3269.                         this.context.await = isAsync;
  3270.                         var node = this.startNode(startToken);
  3271.                         this.expect('=>');
  3272.                         var body = void 0;
  3273.                         if (this.match('{')) {
  3274.                             var previousAllowIn = this.context.allowIn;
  3275.                             this.context.allowIn = true;
  3276.                             body = this.parseFunctionSourceElements();
  3277.                             this.context.allowIn = previousAllowIn;
  3278.                         }
  3279.                         else {
  3280.                             body = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3281.                         }
  3282.                         var expression = body.type !== syntax_1.Syntax.BlockStatement;
  3283.                         if (this.context.strict && list.firstRestricted) {
  3284.                             this.throwUnexpectedToken(list.firstRestricted, list.message);
  3285.                         }
  3286.                         if (this.context.strict && list.stricted) {
  3287.                             this.tolerateUnexpectedToken(list.stricted, list.message);
  3288.                         }
  3289.                         expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
  3290.                             this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
  3291.                         this.context.strict = previousStrict;
  3292.                         this.context.allowStrictDirective = previousAllowStrictDirective;
  3293.                         this.context.allowYield = previousAllowYield;
  3294.                         this.context.await = previousAwait;
  3295.                     }
  3296.                 }
  3297.                 else {
  3298.                     if (this.matchAssign()) {
  3299.                         if (!this.context.isAssignmentTarget) {
  3300.                             this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
  3301.                         }
  3302.                         if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
  3303.                             var id = expr;
  3304.                             if (this.scanner.isRestrictedWord(id.name)) {
  3305.                                 this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
  3306.                             }
  3307.                             if (this.scanner.isStrictModeReservedWord(id.name)) {
  3308.                                 this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
  3309.                             }
  3310.                         }
  3311.                         if (!this.match('=')) {
  3312.                             this.context.isAssignmentTarget = false;
  3313.                             this.context.isBindingElement = false;
  3314.                         }
  3315.                         else {
  3316.                             this.reinterpretExpressionAsPattern(expr);
  3317.                         }
  3318.                         token = this.nextToken();
  3319.                         var operator = token.value;
  3320.                         var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3321.                         expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
  3322.                         this.context.firstCoverInitializedNameError = null;
  3323.                     }
  3324.                 }
  3325.             }
  3326.             return expr;
  3327.         };
  3328.         // https://tc39.github.io/ecma262/#sec-comma-operator
  3329.         Parser.prototype.parseExpression = function () {
  3330.             var startToken = this.lookahead;
  3331.             var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3332.             if (this.match(',')) {
  3333.                 var expressions = [];
  3334.                 expressions.push(expr);
  3335.                 while (this.lookahead.type !== 2 /* EOF */) {
  3336.                     if (!this.match(',')) {
  3337.                         break;
  3338.                     }
  3339.                     this.nextToken();
  3340.                     expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
  3341.                 }
  3342.                 expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
  3343.             }
  3344.             return expr;
  3345.         };
  3346.         // https://tc39.github.io/ecma262/#sec-block
  3347.         Parser.prototype.parseStatementListItem = function () {
  3348.             var statement;
  3349.             this.context.isAssignmentTarget = true;
  3350.             this.context.isBindingElement = true;
  3351.             if (this.lookahead.type === 4 /* Keyword */) {
  3352.                 switch (this.lookahead.value) {
  3353.                     case 'export':
  3354.                         if (!this.context.isModule) {
  3355.                             this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
  3356.                         }
  3357.                         statement = this.parseExportDeclaration();
  3358.                         break;
  3359.                     case 'import':
  3360.                         if (!this.context.isModule) {
  3361.                             this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
  3362.                         }
  3363.                         statement = this.parseImportDeclaration();
  3364.                         break;
  3365.                     case 'const':
  3366.                         statement = this.parseLexicalDeclaration({ inFor: false });
  3367.                         break;
  3368.                     case 'function':
  3369.                         statement = this.parseFunctionDeclaration();
  3370.                         break;
  3371.                     case 'class':
  3372.                         statement = this.parseClassDeclaration();
  3373.                         break;
  3374.                     case 'let':
  3375.                         statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();
  3376.                         break;
  3377.                     default:
  3378.                         statement = this.parseStatement();
  3379.                         break;
  3380.                 }
  3381.             }
  3382.             else {
  3383.                 statement = this.parseStatement();
  3384.             }
  3385.             return statement;
  3386.         };
  3387.         Parser.prototype.parseBlock = function () {
  3388.             var node = this.createNode();
  3389.             this.expect('{');
  3390.             var block = [];
  3391.             while (true) {
  3392.                 if (this.match('}')) {
  3393.                     break;
  3394.                 }
  3395.                 block.push(this.parseStatementListItem());
  3396.             }
  3397.             this.expect('}');
  3398.             return this.finalize(node, new Node.BlockStatement(block));
  3399.         };
  3400.         // https://tc39.github.io/ecma262/#sec-let-and-const-declarations
  3401.         Parser.prototype.parseLexicalBinding = function (kind, options) {
  3402.             var node = this.createNode();
  3403.             var params = [];
  3404.             var id = this.parsePattern(params, kind);
  3405.             if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
  3406.                 if (this.scanner.isRestrictedWord(id.name)) {
  3407.                     this.tolerateError(messages_1.Messages.StrictVarName);
  3408.                 }
  3409.             }
  3410.             var init = null;
  3411.             if (kind === 'const') {
  3412.                 if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
  3413.                     if (this.match('=')) {
  3414.                         this.nextToken();
  3415.                         init = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3416.                     }
  3417.                     else {
  3418.                         this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
  3419.                     }
  3420.                 }
  3421.             }
  3422.             else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {
  3423.                 this.expect('=');
  3424.                 init = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3425.             }
  3426.             return this.finalize(node, new Node.VariableDeclarator(id, init));
  3427.         };
  3428.         Parser.prototype.parseBindingList = function (kind, options) {
  3429.             var list = [this.parseLexicalBinding(kind, options)];
  3430.             while (this.match(',')) {
  3431.                 this.nextToken();
  3432.                 list.push(this.parseLexicalBinding(kind, options));
  3433.             }
  3434.             return list;
  3435.         };
  3436.         Parser.prototype.isLexicalDeclaration = function () {
  3437.             var state = this.scanner.saveState();
  3438.             this.scanner.scanComments();
  3439.             var next = this.scanner.lex();
  3440.             this.scanner.restoreState(state);
  3441.             return (next.type === 3 /* Identifier */) ||
  3442.                 (next.type === 7 /* Punctuator */ && next.value === '[') ||
  3443.                 (next.type === 7 /* Punctuator */ && next.value === '{') ||
  3444.                 (next.type === 4 /* Keyword */ && next.value === 'let') ||
  3445.                 (next.type === 4 /* Keyword */ && next.value === 'yield');
  3446.         };
  3447.         Parser.prototype.parseLexicalDeclaration = function (options) {
  3448.             var node = this.createNode();
  3449.             var kind = this.nextToken().value;
  3450.             assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
  3451.             var declarations = this.parseBindingList(kind, options);
  3452.             this.consumeSemicolon();
  3453.             return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
  3454.         };
  3455.         // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
  3456.         Parser.prototype.parseBindingRestElement = function (params, kind) {
  3457.             var node = this.createNode();
  3458.             this.expect('...');
  3459.             var arg = this.parsePattern(params, kind);
  3460.             return this.finalize(node, new Node.RestElement(arg));
  3461.         };
  3462.         Parser.prototype.parseArrayPattern = function (params, kind) {
  3463.             var node = this.createNode();
  3464.             this.expect('[');
  3465.             var elements = [];
  3466.             while (!this.match(']')) {
  3467.                 if (this.match(',')) {
  3468.                     this.nextToken();
  3469.                     elements.push(null);
  3470.                 }
  3471.                 else {
  3472.                     if (this.match('...')) {
  3473.                         elements.push(this.parseBindingRestElement(params, kind));
  3474.                         break;
  3475.                     }
  3476.                     else {
  3477.                         elements.push(this.parsePatternWithDefault(params, kind));
  3478.                     }
  3479.                     if (!this.match(']')) {
  3480.                         this.expect(',');
  3481.                     }
  3482.                 }
  3483.             }
  3484.             this.expect(']');
  3485.             return this.finalize(node, new Node.ArrayPattern(elements));
  3486.         };
  3487.         Parser.prototype.parsePropertyPattern = function (params, kind) {
  3488.             var node = this.createNode();
  3489.             var computed = false;
  3490.             var shorthand = false;
  3491.             var method = false;
  3492.             var key;
  3493.             var value;
  3494.             if (this.lookahead.type === 3 /* Identifier */) {
  3495.                 var keyToken = this.lookahead;
  3496.                 key = this.parseVariableIdentifier();
  3497.                 var init = this.finalize(node, new Node.Identifier(keyToken.value));
  3498.                 if (this.match('=')) {
  3499.                     params.push(keyToken);
  3500.                     shorthand = true;
  3501.                     this.nextToken();
  3502.                     var expr = this.parseAssignmentExpression();
  3503.                     value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
  3504.                 }
  3505.                 else if (!this.match(':')) {
  3506.                     params.push(keyToken);
  3507.                     shorthand = true;
  3508.                     value = init;
  3509.                 }
  3510.                 else {
  3511.                     this.expect(':');
  3512.                     value = this.parsePatternWithDefault(params, kind);
  3513.                 }
  3514.             }
  3515.             else {
  3516.                 computed = this.match('[');
  3517.                 key = this.parseObjectPropertyKey();
  3518.                 this.expect(':');
  3519.                 value = this.parsePatternWithDefault(params, kind);
  3520.             }
  3521.             return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
  3522.         };
  3523.         Parser.prototype.parseObjectPattern = function (params, kind) {
  3524.             var node = this.createNode();
  3525.             var properties = [];
  3526.             this.expect('{');
  3527.             while (!this.match('}')) {
  3528.                 properties.push(this.parsePropertyPattern(params, kind));
  3529.                 if (!this.match('}')) {
  3530.                     this.expect(',');
  3531.                 }
  3532.             }
  3533.             this.expect('}');
  3534.             return this.finalize(node, new Node.ObjectPattern(properties));
  3535.         };
  3536.         Parser.prototype.parsePattern = function (params, kind) {
  3537.             var pattern;
  3538.             if (this.match('[')) {
  3539.                 pattern = this.parseArrayPattern(params, kind);
  3540.             }
  3541.             else if (this.match('{')) {
  3542.                 pattern = this.parseObjectPattern(params, kind);
  3543.             }
  3544.             else {
  3545.                 if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
  3546.                     this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
  3547.                 }
  3548.                 params.push(this.lookahead);
  3549.                 pattern = this.parseVariableIdentifier(kind);
  3550.             }
  3551.             return pattern;
  3552.         };
  3553.         Parser.prototype.parsePatternWithDefault = function (params, kind) {
  3554.             var startToken = this.lookahead;
  3555.             var pattern = this.parsePattern(params, kind);
  3556.             if (this.match('=')) {
  3557.                 this.nextToken();
  3558.                 var previousAllowYield = this.context.allowYield;
  3559.                 this.context.allowYield = true;
  3560.                 var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3561.                 this.context.allowYield = previousAllowYield;
  3562.                 pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
  3563.             }
  3564.             return pattern;
  3565.         };
  3566.         // https://tc39.github.io/ecma262/#sec-variable-statement
  3567.         Parser.prototype.parseVariableIdentifier = function (kind) {
  3568.             var node = this.createNode();
  3569.             var token = this.nextToken();
  3570.             if (token.type === 4 /* Keyword */ && token.value === 'yield') {
  3571.                 if (this.context.strict) {
  3572.                     this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
  3573.                 }
  3574.                 else if (!this.context.allowYield) {
  3575.                     this.throwUnexpectedToken(token);
  3576.                 }
  3577.             }
  3578.             else if (token.type !== 3 /* Identifier */) {
  3579.                 if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {
  3580.                     this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
  3581.                 }
  3582.                 else {
  3583.                     if (this.context.strict || token.value !== 'let' || kind !== 'var') {
  3584.                         this.throwUnexpectedToken(token);
  3585.                     }
  3586.                 }
  3587.             }
  3588.             else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {
  3589.                 this.tolerateUnexpectedToken(token);
  3590.             }
  3591.             return this.finalize(node, new Node.Identifier(token.value));
  3592.         };
  3593.         Parser.prototype.parseVariableDeclaration = function (options) {
  3594.             var node = this.createNode();
  3595.             var params = [];
  3596.             var id = this.parsePattern(params, 'var');
  3597.             if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
  3598.                 if (this.scanner.isRestrictedWord(id.name)) {
  3599.                     this.tolerateError(messages_1.Messages.StrictVarName);
  3600.                 }
  3601.             }
  3602.             var init = null;
  3603.             if (this.match('=')) {
  3604.                 this.nextToken();
  3605.                 init = this.isolateCoverGrammar(this.parseAssignmentExpression);
  3606.             }
  3607.             else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
  3608.                 this.expect('=');
  3609.             }
  3610.             return this.finalize(node, new Node.VariableDeclarator(id, init));
  3611.         };
  3612.         Parser.prototype.parseVariableDeclarationList = function (options) {
  3613.             var opt = { inFor: options.inFor };
  3614.             var list = [];
  3615.             list.push(this.parseVariableDeclaration(opt));
  3616.             while (this.match(',')) {
  3617.                 this.nextToken();
  3618.                 list.push(this.parseVariableDeclaration(opt));
  3619.             }
  3620.             return list;
  3621.         };
  3622.         Parser.prototype.parseVariableStatement = function () {
  3623.             var node = this.createNode();
  3624.             this.expectKeyword('var');
  3625.             var declarations = this.parseVariableDeclarationList({ inFor: false });
  3626.             this.consumeSemicolon();
  3627.             return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
  3628.         };
  3629.         // https://tc39.github.io/ecma262/#sec-empty-statement
  3630.         Parser.prototype.parseEmptyStatement = function () {
  3631.             var node = this.createNode();
  3632.             this.expect(';');
  3633.             return this.finalize(node, new Node.EmptyStatement());
  3634.         };
  3635.         // https://tc39.github.io/ecma262/#sec-expression-statement
  3636.         Parser.prototype.parseExpressionStatement = function () {
  3637.             var node = this.createNode();
  3638.             var expr = this.parseExpression();
  3639.             this.consumeSemicolon();
  3640.             return this.finalize(node, new Node.ExpressionStatement(expr));
  3641.         };
  3642.         // https://tc39.github.io/ecma262/#sec-if-statement
  3643.         Parser.prototype.parseIfClause = function () {
  3644.             if (this.context.strict && this.matchKeyword('function')) {
  3645.                 this.tolerateError(messages_1.Messages.StrictFunction);
  3646.             }
  3647.             return this.parseStatement();
  3648.         };
  3649.         Parser.prototype.parseIfStatement = function () {
  3650.             var node = this.createNode();
  3651.             var consequent;
  3652.             var alternate = null;
  3653.             this.expectKeyword('if');
  3654.             this.expect('(');
  3655.             var test = this.parseExpression();
  3656.             if (!this.match(')') && this.config.tolerant) {
  3657.                 this.tolerateUnexpectedToken(this.nextToken());
  3658.                 consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
  3659.             }
  3660.             else {
  3661.                 this.expect(')');
  3662.                 consequent = this.parseIfClause();
  3663.                 if (this.matchKeyword('else')) {
  3664.                     this.nextToken();
  3665.                     alternate = this.parseIfClause();
  3666.                 }
  3667.             }
  3668.             return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
  3669.         };
  3670.         // https://tc39.github.io/ecma262/#sec-do-while-statement
  3671.         Parser.prototype.parseDoWhileStatement = function () {
  3672.             var node = this.createNode();
  3673.             this.expectKeyword('do');
  3674.             var previousInIteration = this.context.inIteration;
  3675.             this.context.inIteration = true;
  3676.             var body = this.parseStatement();
  3677.             this.context.inIteration = previousInIteration;
  3678.             this.expectKeyword('while');
  3679.             this.expect('(');
  3680.             var test = this.parseExpression();
  3681.             if (!this.match(')') && this.config.tolerant) {
  3682.                 this.tolerateUnexpectedToken(this.nextToken());
  3683.             }
  3684.             else {
  3685.                 this.expect(')');
  3686.                 if (this.match(';')) {
  3687.                     this.nextToken();
  3688.                 }
  3689.             }
  3690.             return this.finalize(node, new Node.DoWhileStatement(body, test));
  3691.         };
  3692.         // https://tc39.github.io/ecma262/#sec-while-statement
  3693.         Parser.prototype.parseWhileStatement = function () {
  3694.             var node = this.createNode();
  3695.             var body;
  3696.             this.expectKeyword('while');
  3697.             this.expect('(');
  3698.             var test = this.parseExpression();
  3699.             if (!this.match(')') && this.config.tolerant) {
  3700.                 this.tolerateUnexpectedToken(this.nextToken());
  3701.                 body = this.finalize(this.createNode(), new Node.EmptyStatement());
  3702.             }
  3703.             else {
  3704.                 this.expect(')');
  3705.                 var previousInIteration = this.context.inIteration;
  3706.                 this.context.inIteration = true;
  3707.                 body = this.parseStatement();
  3708.                 this.context.inIteration = previousInIteration;
  3709.             }
  3710.             return this.finalize(node, new Node.WhileStatement(test, body));
  3711.         };
  3712.         // https://tc39.github.io/ecma262/#sec-for-statement
  3713.         // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
  3714.         Parser.prototype.parseForStatement = function () {
  3715.             var init = null;
  3716.             var test = null;
  3717.             var update = null;
  3718.             var forIn = true;
  3719.             var left, right;
  3720.             var node = this.createNode();
  3721.             this.expectKeyword('for');
  3722.             this.expect('(');
  3723.             if (this.match(';')) {
  3724.                 this.nextToken();
  3725.             }
  3726.             else {
  3727.                 if (this.matchKeyword('var')) {
  3728.                     init = this.createNode();
  3729.                     this.nextToken();
  3730.                     var previousAllowIn = this.context.allowIn;
  3731.                     this.context.allowIn = false;
  3732.                     var declarations = this.parseVariableDeclarationList({ inFor: true });
  3733.                     this.context.allowIn = previousAllowIn;
  3734.                     if (declarations.length === 1 && this.matchKeyword('in')) {
  3735.                         var decl = declarations[0];
  3736.                         if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
  3737.                             this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
  3738.                         }
  3739.                         init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
  3740.                         this.nextToken();
  3741.                         left = init;
  3742.                         right = this.parseExpression();
  3743.                         init = null;
  3744.                     }
  3745.                     else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
  3746.                         init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
  3747.                         this.nextToken();
  3748.                         left = init;
  3749.                         right = this.parseAssignmentExpression();
  3750.                         init = null;
  3751.                         forIn = false;
  3752.                     }
  3753.                     else {
  3754.                         init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
  3755.                         this.expect(';');
  3756.                     }
  3757.                 }
  3758.                 else if (this.matchKeyword('const') || this.matchKeyword('let')) {
  3759.                     init = this.createNode();
  3760.                     var kind = this.nextToken().value;
  3761.                     if (!this.context.strict && this.lookahead.value === 'in') {
  3762.                         init = this.finalize(init, new Node.Identifier(kind));
  3763.                         this.nextToken();
  3764.                         left = init;
  3765.                         right = this.parseExpression();
  3766.                         init = null;
  3767.                     }
  3768.                     else {
  3769.                         var previousAllowIn = this.context.allowIn;
  3770.                         this.context.allowIn = false;
  3771.                         var declarations = this.parseBindingList(kind, { inFor: true });
  3772.                         this.context.allowIn = previousAllowIn;
  3773.                         if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
  3774.                             init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
  3775.                             this.nextToken();
  3776.                             left = init;
  3777.                             right = this.parseExpression();
  3778.                             init = null;
  3779.                         }
  3780.                         else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
  3781.                             init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
  3782.                             this.nextToken();
  3783.                             left = init;
  3784.                             right = this.parseAssignmentExpression();
  3785.                             init = null;
  3786.                             forIn = false;
  3787.                         }
  3788.                         else {
  3789.                             this.consumeSemicolon();
  3790.                             init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
  3791.                         }
  3792.                     }
  3793.                 }
  3794.                 else {
  3795.                     var initStartToken = this.lookahead;
  3796.                     var previousAllowIn = this.context.allowIn;
  3797.                     this.context.allowIn = false;
  3798.                     init = this.inheritCoverGrammar(this.parseAssignmentExpression);
  3799.                     this.context.allowIn = previousAllowIn;
  3800.                     if (this.matchKeyword('in')) {
  3801.                         if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
  3802.                             this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
  3803.                         }
  3804.                         this.nextToken();
  3805.                         this.reinterpretExpressionAsPattern(init);
  3806.                         left = init;
  3807.                         right = this.parseExpression();
  3808.                         init = null;
  3809.                     }
  3810.                     else if (this.matchContextualKeyword('of')) {
  3811.                         if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
  3812.                             this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
  3813.                         }
  3814.                         this.nextToken();
  3815.                         this.reinterpretExpressionAsPattern(init);
  3816.                         left = init;
  3817.                         right = this.parseAssignmentExpression();
  3818.                         init = null;
  3819.                         forIn = false;
  3820.                     }
  3821.                     else {
  3822.                         if (this.match(',')) {
  3823.                             var initSeq = [init];
  3824.                             while (this.match(',')) {
  3825.                                 this.nextToken();
  3826.                                 initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
  3827.                             }
  3828.                             init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
  3829.                         }
  3830.                         this.expect(';');
  3831.                     }
  3832.                 }
  3833.             }
  3834.             if (typeof left === 'undefined') {
  3835.                 if (!this.match(';')) {
  3836.                     test = this.parseExpression();
  3837.                 }
  3838.                 this.expect(';');
  3839.                 if (!this.match(')')) {
  3840.                     update = this.parseExpression();
  3841.                 }
  3842.             }
  3843.             var body;
  3844.             if (!this.match(')') && this.config.tolerant) {
  3845.                 this.tolerateUnexpectedToken(this.nextToken());
  3846.                 body = this.finalize(this.createNode(), new Node.EmptyStatement());
  3847.             }
  3848.             else {
  3849.                 this.expect(')');
  3850.                 var previousInIteration = this.context.inIteration;
  3851.                 this.context.inIteration = true;
  3852.                 body = this.isolateCoverGrammar(this.parseStatement);
  3853.                 this.context.inIteration = previousInIteration;
  3854.             }
  3855.             return (typeof left === 'undefined') ?
  3856.                 this.finalize(node, new Node.ForStatement(init, test, update, body)) :
  3857.                 forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
  3858.                     this.finalize(node, new Node.ForOfStatement(left, right, body));
  3859.         };
  3860.         // https://tc39.github.io/ecma262/#sec-continue-statement
  3861.         Parser.prototype.parseContinueStatement = function () {
  3862.             var node = this.createNode();
  3863.             this.expectKeyword('continue');
  3864.             var label = null;
  3865.             if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
  3866.                 var id = this.parseVariableIdentifier();
  3867.                 label = id;
  3868.                 var key = '$' + id.name;
  3869.                 if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
  3870.                     this.throwError(messages_1.Messages.UnknownLabel, id.name);
  3871.                 }
  3872.             }
  3873.             this.consumeSemicolon();
  3874.             if (label === null && !this.context.inIteration) {
  3875.                 this.throwError(messages_1.Messages.IllegalContinue);
  3876.             }
  3877.             return this.finalize(node, new Node.ContinueStatement(label));
  3878.         };
  3879.         // https://tc39.github.io/ecma262/#sec-break-statement
  3880.         Parser.prototype.parseBreakStatement = function () {
  3881.             var node = this.createNode();
  3882.             this.expectKeyword('break');
  3883.             var label = null;
  3884.             if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
  3885.                 var id = this.parseVariableIdentifier();
  3886.                 var key = '$' + id.name;
  3887.                 if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
  3888.                     this.throwError(messages_1.Messages.UnknownLabel, id.name);
  3889.                 }
  3890.                 label = id;
  3891.             }
  3892.             this.consumeSemicolon();
  3893.             if (label === null && !this.context.inIteration && !this.context.inSwitch) {
  3894.                 this.throwError(messages_1.Messages.IllegalBreak);
  3895.             }
  3896.             return this.finalize(node, new Node.BreakStatement(label));
  3897.         };
  3898.         // https://tc39.github.io/ecma262/#sec-return-statement
  3899.         Parser.prototype.parseReturnStatement = function () {
  3900.             if (!this.context.inFunctionBody) {
  3901.                 this.tolerateError(messages_1.Messages.IllegalReturn);
  3902.             }
  3903.             var node = this.createNode();
  3904.             this.expectKeyword('return');
  3905.             var hasArgument = !this.match(';') && !this.match('}') &&
  3906.                 !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */;
  3907.             var argument = hasArgument ? this.parseExpression() : null;
  3908.             this.consumeSemicolon();
  3909.             return this.finalize(node, new Node.ReturnStatement(argument));
  3910.         };
  3911.         // https://tc39.github.io/ecma262/#sec-with-statement
  3912.         Parser.prototype.parseWithStatement = function () {
  3913.             if (this.context.strict) {
  3914.                 this.tolerateError(messages_1.Messages.StrictModeWith);
  3915.             }
  3916.             var node = this.createNode();
  3917.             var body;
  3918.             this.expectKeyword('with');
  3919.             this.expect('(');
  3920.             var object = this.parseExpression();
  3921.             if (!this.match(')') && this.config.tolerant) {
  3922.                 this.tolerateUnexpectedToken(this.nextToken());
  3923.                 body = this.finalize(this.createNode(), new Node.EmptyStatement());
  3924.             }
  3925.             else {
  3926.                 this.expect(')');
  3927.                 body = this.parseStatement();
  3928.             }
  3929.             return this.finalize(node, new Node.WithStatement(object, body));
  3930.         };
  3931.         // https://tc39.github.io/ecma262/#sec-switch-statement
  3932.         Parser.prototype.parseSwitchCase = function () {
  3933.             var node = this.createNode();
  3934.             var test;
  3935.             if (this.matchKeyword('default')) {
  3936.                 this.nextToken();
  3937.                 test = null;
  3938.             }
  3939.             else {
  3940.                 this.expectKeyword('case');
  3941.                 test = this.parseExpression();
  3942.             }
  3943.             this.expect(':');
  3944.             var consequent = [];
  3945.             while (true) {
  3946.                 if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
  3947.                     break;
  3948.                 }
  3949.                 consequent.push(this.parseStatementListItem());
  3950.             }
  3951.             return this.finalize(node, new Node.SwitchCase(test, consequent));
  3952.         };
  3953.         Parser.prototype.parseSwitchStatement = function () {
  3954.             var node = this.createNode();
  3955.             this.expectKeyword('switch');
  3956.             this.expect('(');
  3957.             var discriminant = this.parseExpression();
  3958.             this.expect(')');
  3959.             var previousInSwitch = this.context.inSwitch;
  3960.             this.context.inSwitch = true;
  3961.             var cases = [];
  3962.             var defaultFound = false;
  3963.             this.expect('{');
  3964.             while (true) {
  3965.                 if (this.match('}')) {
  3966.                     break;
  3967.                 }
  3968.                 var clause = this.parseSwitchCase();
  3969.                 if (clause.test === null) {
  3970.                     if (defaultFound) {
  3971.                         this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
  3972.                     }
  3973.                     defaultFound = true;
  3974.                 }
  3975.                 cases.push(clause);
  3976.             }
  3977.             this.expect('}');
  3978.             this.context.inSwitch = previousInSwitch;
  3979.             return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
  3980.         };
  3981.         // https://tc39.github.io/ecma262/#sec-labelled-statements
  3982.         Parser.prototype.parseLabelledStatement = function () {
  3983.             var node = this.createNode();
  3984.             var expr = this.parseExpression();
  3985.             var statement;
  3986.             if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
  3987.                 this.nextToken();
  3988.                 var id = expr;
  3989.                 var key = '$' + id.name;
  3990.                 if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
  3991.                     this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
  3992.                 }
  3993.                 this.context.labelSet[key] = true;
  3994.                 var body = void 0;
  3995.                 if (this.matchKeyword('class')) {
  3996.                     this.tolerateUnexpectedToken(this.lookahead);
  3997.                     body = this.parseClassDeclaration();
  3998.                 }
  3999.                 else if (this.matchKeyword('function')) {
  4000.                     var token = this.lookahead;
  4001.                     var declaration = this.parseFunctionDeclaration();
  4002.                     if (this.context.strict) {
  4003.                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
  4004.                     }
  4005.                     else if (declaration.generator) {
  4006.                         this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
  4007.                     }
  4008.                     body = declaration;
  4009.                 }
  4010.                 else {
  4011.                     body = this.parseStatement();
  4012.                 }
  4013.                 delete this.context.labelSet[key];
  4014.                 statement = new Node.LabeledStatement(id, body);
  4015.             }
  4016.             else {
  4017.                 this.consumeSemicolon();
  4018.                 statement = new Node.ExpressionStatement(expr);
  4019.             }
  4020.             return this.finalize(node, statement);
  4021.         };
  4022.         // https://tc39.github.io/ecma262/#sec-throw-statement
  4023.         Parser.prototype.parseThrowStatement = function () {
  4024.             var node = this.createNode();
  4025.             this.expectKeyword('throw');
  4026.             if (this.hasLineTerminator) {
  4027.                 this.throwError(messages_1.Messages.NewlineAfterThrow);
  4028.             }
  4029.             var argument = this.parseExpression();
  4030.             this.consumeSemicolon();
  4031.             return this.finalize(node, new Node.ThrowStatement(argument));
  4032.         };
  4033.         // https://tc39.github.io/ecma262/#sec-try-statement
  4034.         Parser.prototype.parseCatchClause = function () {
  4035.             var node = this.createNode();
  4036.             this.expectKeyword('catch');
  4037.             this.expect('(');
  4038.             if (this.match(')')) {
  4039.                 this.throwUnexpectedToken(this.lookahead);
  4040.             }
  4041.             var params = [];
  4042.             var param = this.parsePattern(params);
  4043.             var paramMap = {};
  4044.             for (var i = 0; i < params.length; i++) {
  4045.                 var key = '$' + params[i].value;
  4046.                 if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
  4047.                     this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
  4048.                 }
  4049.                 paramMap[key] = true;
  4050.             }
  4051.             if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
  4052.                 if (this.scanner.isRestrictedWord(param.name)) {
  4053.                     this.tolerateError(messages_1.Messages.StrictCatchVariable);
  4054.                 }
  4055.             }
  4056.             this.expect(')');
  4057.             var body = this.parseBlock();
  4058.             return this.finalize(node, new Node.CatchClause(param, body));
  4059.         };
  4060.         Parser.prototype.parseFinallyClause = function () {
  4061.             this.expectKeyword('finally');
  4062.             return this.parseBlock();
  4063.         };
  4064.         Parser.prototype.parseTryStatement = function () {
  4065.             var node = this.createNode();
  4066.             this.expectKeyword('try');
  4067.             var block = this.parseBlock();
  4068.             var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
  4069.             var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;
  4070.             if (!handler && !finalizer) {
  4071.                 this.throwError(messages_1.Messages.NoCatchOrFinally);
  4072.             }
  4073.             return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
  4074.         };
  4075.         // https://tc39.github.io/ecma262/#sec-debugger-statement
  4076.         Parser.prototype.parseDebuggerStatement = function () {
  4077.             var node = this.createNode();
  4078.             this.expectKeyword('debugger');
  4079.             this.consumeSemicolon();
  4080.             return this.finalize(node, new Node.DebuggerStatement());
  4081.         };
  4082.         // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
  4083.         Parser.prototype.parseStatement = function () {
  4084.             var statement;
  4085.             switch (this.lookahead.type) {
  4086.                 case 1 /* BooleanLiteral */:
  4087.                 case 5 /* NullLiteral */:
  4088.                 case 6 /* NumericLiteral */:
  4089.                 case 8 /* StringLiteral */:
  4090.                 case 10 /* Template */:
  4091.                 case 9 /* RegularExpression */:
  4092.                     statement = this.parseExpressionStatement();
  4093.                     break;
  4094.                 case 7 /* Punctuator */:
  4095.                     var value = this.lookahead.value;
  4096.                     if (value === '{') {
  4097.                         statement = this.parseBlock();
  4098.                     }
  4099.                     else if (value === '(') {
  4100.                         statement = this.parseExpressionStatement();
  4101.                     }
  4102.                     else if (value === ';') {
  4103.                         statement = this.parseEmptyStatement();
  4104.                     }
  4105.                     else {
  4106.                         statement = this.parseExpressionStatement();
  4107.                     }
  4108.                     break;
  4109.                 case 3 /* Identifier */:
  4110.                     statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
  4111.                     break;
  4112.                 case 4 /* Keyword */:
  4113.                     switch (this.lookahead.value) {
  4114.                         case 'break':
  4115.                             statement = this.parseBreakStatement();
  4116.                             break;
  4117.                         case 'continue':
  4118.                             statement = this.parseContinueStatement();
  4119.                             break;
  4120.                         case 'debugger':
  4121.                             statement = this.parseDebuggerStatement();
  4122.                             break;
  4123.                         case 'do':
  4124.                             statement = this.parseDoWhileStatement();
  4125.                             break;
  4126.                         case 'for':
  4127.                             statement = this.parseForStatement();
  4128.                             break;
  4129.                         case 'function':
  4130.                             statement = this.parseFunctionDeclaration();
  4131.                             break;
  4132.                         case 'if':
  4133.                             statement = this.parseIfStatement();
  4134.                             break;
  4135.                         case 'return':
  4136.                             statement = this.parseReturnStatement();
  4137.                             break;
  4138.                         case 'switch':
  4139.                             statement = this.parseSwitchStatement();
  4140.                             break;
  4141.                         case 'throw':
  4142.                             statement = this.parseThrowStatement();
  4143.                             break;
  4144.                         case 'try':
  4145.                             statement = this.parseTryStatement();
  4146.                             break;
  4147.                         case 'var':
  4148.                             statement = this.parseVariableStatement();
  4149.                             break;
  4150.                         case 'while':
  4151.                             statement = this.parseWhileStatement();
  4152.                             break;
  4153.                         case 'with':
  4154.                             statement = this.parseWithStatement();
  4155.                             break;
  4156.                         default:
  4157.                             statement = this.parseExpressionStatement();
  4158.                             break;
  4159.                     }
  4160.                     break;
  4161.                 default:
  4162.                     statement = this.throwUnexpectedToken(this.lookahead);
  4163.             }
  4164.             return statement;
  4165.         };
  4166.         // https://tc39.github.io/ecma262/#sec-function-definitions
  4167.         Parser.prototype.parseFunctionSourceElements = function () {
  4168.             var node = this.createNode();
  4169.             this.expect('{');
  4170.             var body = this.parseDirectivePrologues();
  4171.             var previousLabelSet = this.context.labelSet;
  4172.             var previousInIteration = this.context.inIteration;
  4173.             var previousInSwitch = this.context.inSwitch;
  4174.             var previousInFunctionBody = this.context.inFunctionBody;
  4175.             this.context.labelSet = {};
  4176.             this.context.inIteration = false;
  4177.             this.context.inSwitch = false;
  4178.             this.context.inFunctionBody = true;
  4179.             while (this.lookahead.type !== 2 /* EOF */) {
  4180.                 if (this.match('}')) {
  4181.                     break;
  4182.                 }
  4183.                 body.push(this.parseStatementListItem());
  4184.             }
  4185.             this.expect('}');
  4186.             this.context.labelSet = previousLabelSet;
  4187.             this.context.inIteration = previousInIteration;
  4188.             this.context.inSwitch = previousInSwitch;
  4189.             this.context.inFunctionBody = previousInFunctionBody;
  4190.             return this.finalize(node, new Node.BlockStatement(body));
  4191.         };
  4192.         Parser.prototype.validateParam = function (options, param, name) {
  4193.             var key = '$' + name;
  4194.             if (this.context.strict) {
  4195.                 if (this.scanner.isRestrictedWord(name)) {
  4196.                     options.stricted = param;
  4197.                     options.message = messages_1.Messages.StrictParamName;
  4198.                 }
  4199.                 if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
  4200.                     options.stricted = param;
  4201.                     options.message = messages_1.Messages.StrictParamDupe;
  4202.                 }
  4203.             }
  4204.             else if (!options.firstRestricted) {
  4205.                 if (this.scanner.isRestrictedWord(name)) {
  4206.                     options.firstRestricted = param;
  4207.                     options.message = messages_1.Messages.StrictParamName;
  4208.                 }
  4209.                 else if (this.scanner.isStrictModeReservedWord(name)) {
  4210.                     options.firstRestricted = param;
  4211.                     options.message = messages_1.Messages.StrictReservedWord;
  4212.                 }
  4213.                 else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
  4214.                     options.stricted = param;
  4215.                     options.message = messages_1.Messages.StrictParamDupe;
  4216.                 }
  4217.             }
  4218.             /* istanbul ignore next */
  4219.             if (typeof Object.defineProperty === 'function') {
  4220.                 Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });
  4221.             }
  4222.             else {
  4223.                 options.paramSet[key] = true;
  4224.             }
  4225.         };
  4226.         Parser.prototype.parseRestElement = function (params) {
  4227.             var node = this.createNode();
  4228.             this.expect('...');
  4229.             var arg = this.parsePattern(params);
  4230.             if (this.match('=')) {
  4231.                 this.throwError(messages_1.Messages.DefaultRestParameter);
  4232.             }
  4233.             if (!this.match(')')) {
  4234.                 this.throwError(messages_1.Messages.ParameterAfterRestParameter);
  4235.             }
  4236.             return this.finalize(node, new Node.RestElement(arg));
  4237.         };
  4238.         Parser.prototype.parseFormalParameter = function (options) {
  4239.             var params = [];
  4240.             var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);
  4241.             for (var i = 0; i < params.length; i++) {
  4242.                 this.validateParam(options, params[i], params[i].value);
  4243.             }
  4244.             options.simple = options.simple && (param instanceof Node.Identifier);
  4245.             options.params.push(param);
  4246.         };
  4247.         Parser.prototype.parseFormalParameters = function (firstRestricted) {
  4248.             var options;
  4249.             options = {
  4250.                 simple: true,
  4251.                 params: [],
  4252.                 firstRestricted: firstRestricted
  4253.             };
  4254.             this.expect('(');
  4255.             if (!this.match(')')) {
  4256.                 options.paramSet = {};
  4257.                 while (this.lookahead.type !== 2 /* EOF */) {
  4258.                     this.parseFormalParameter(options);
  4259.                     if (this.match(')')) {
  4260.                         break;
  4261.                     }
  4262.                     this.expect(',');
  4263.                     if (this.match(')')) {
  4264.                         break;
  4265.                     }
  4266.                 }
  4267.             }
  4268.             this.expect(')');
  4269.             return {
  4270.                 simple: options.simple,
  4271.                 params: options.params,
  4272.                 stricted: options.stricted,
  4273.                 firstRestricted: options.firstRestricted,
  4274.                 message: options.message
  4275.             };
  4276.         };
  4277.         Parser.prototype.matchAsyncFunction = function () {
  4278.             var match = this.matchContextualKeyword('async');
  4279.             if (match) {
  4280.                 var state = this.scanner.saveState();
  4281.                 this.scanner.scanComments();
  4282.                 var next = this.scanner.lex();
  4283.                 this.scanner.restoreState(state);
  4284.                 match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');
  4285.             }
  4286.             return match;
  4287.         };
  4288.         Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
  4289.             var node = this.createNode();
  4290.             var isAsync = this.matchContextualKeyword('async');
  4291.             if (isAsync) {
  4292.                 this.nextToken();
  4293.             }
  4294.             this.expectKeyword('function');
  4295.             var isGenerator = isAsync ? false : this.match('*');
  4296.             if (isGenerator) {
  4297.                 this.nextToken();
  4298.             }
  4299.             var message;
  4300.             var id = null;
  4301.             var firstRestricted = null;
  4302.             if (!identifierIsOptional || !this.match('(')) {
  4303.                 var token = this.lookahead;
  4304.                 id = this.parseVariableIdentifier();
  4305.                 if (this.context.strict) {
  4306.                     if (this.scanner.isRestrictedWord(token.value)) {
  4307.                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
  4308.                     }
  4309.                 }
  4310.                 else {
  4311.                     if (this.scanner.isRestrictedWord(token.value)) {
  4312.                         firstRestricted = token;
  4313.                         message = messages_1.Messages.StrictFunctionName;
  4314.                     }
  4315.                     else if (this.scanner.isStrictModeReservedWord(token.value)) {
  4316.                         firstRestricted = token;
  4317.                         message = messages_1.Messages.StrictReservedWord;
  4318.                     }
  4319.                 }
  4320.             }
  4321.             var previousAllowAwait = this.context.await;
  4322.             var previousAllowYield = this.context.allowYield;
  4323.             this.context.await = isAsync;
  4324.             this.context.allowYield = !isGenerator;
  4325.             var formalParameters = this.parseFormalParameters(firstRestricted);
  4326.             var params = formalParameters.params;
  4327.             var stricted = formalParameters.stricted;
  4328.             firstRestricted = formalParameters.firstRestricted;
  4329.             if (formalParameters.message) {
  4330.                 message = formalParameters.message;
  4331.             }
  4332.             var previousStrict = this.context.strict;
  4333.             var previousAllowStrictDirective = this.context.allowStrictDirective;
  4334.             this.context.allowStrictDirective = formalParameters.simple;
  4335.             var body = this.parseFunctionSourceElements();
  4336.             if (this.context.strict && firstRestricted) {
  4337.                 this.throwUnexpectedToken(firstRestricted, message);
  4338.             }
  4339.             if (this.context.strict && stricted) {
  4340.                 this.tolerateUnexpectedToken(stricted, message);
  4341.             }
  4342.             this.context.strict = previousStrict;
  4343.             this.context.allowStrictDirective = previousAllowStrictDirective;
  4344.             this.context.await = previousAllowAwait;
  4345.             this.context.allowYield = previousAllowYield;
  4346.             return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
  4347.                 this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
  4348.         };
  4349.         Parser.prototype.parseFunctionExpression = function () {
  4350.             var node = this.createNode();
  4351.             var isAsync = this.matchContextualKeyword('async');
  4352.             if (isAsync) {
  4353.                 this.nextToken();
  4354.             }
  4355.             this.expectKeyword('function');
  4356.             var isGenerator = isAsync ? false : this.match('*');
  4357.             if (isGenerator) {
  4358.                 this.nextToken();
  4359.             }
  4360.             var message;
  4361.             var id = null;
  4362.             var firstRestricted;
  4363.             var previousAllowAwait = this.context.await;
  4364.             var previousAllowYield = this.context.allowYield;
  4365.             this.context.await = isAsync;
  4366.             this.context.allowYield = !isGenerator;
  4367.             if (!this.match('(')) {
  4368.                 var token = this.lookahead;
  4369.                 id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();
  4370.                 if (this.context.strict) {
  4371.                     if (this.scanner.isRestrictedWord(token.value)) {
  4372.                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
  4373.                     }
  4374.                 }
  4375.                 else {
  4376.                     if (this.scanner.isRestrictedWord(token.value)) {
  4377.                         firstRestricted = token;
  4378.                         message = messages_1.Messages.StrictFunctionName;
  4379.                     }
  4380.                     else if (this.scanner.isStrictModeReservedWord(token.value)) {
  4381.                         firstRestricted = token;
  4382.                         message = messages_1.Messages.StrictReservedWord;
  4383.                     }
  4384.                 }
  4385.             }
  4386.             var formalParameters = this.parseFormalParameters(firstRestricted);
  4387.             var params = formalParameters.params;
  4388.             var stricted = formalParameters.stricted;
  4389.             firstRestricted = formalParameters.firstRestricted;
  4390.             if (formalParameters.message) {
  4391.                 message = formalParameters.message;
  4392.             }
  4393.             var previousStrict = this.context.strict;
  4394.             var previousAllowStrictDirective = this.context.allowStrictDirective;
  4395.             this.context.allowStrictDirective = formalParameters.simple;
  4396.             var body = this.parseFunctionSourceElements();
  4397.             if (this.context.strict && firstRestricted) {
  4398.                 this.throwUnexpectedToken(firstRestricted, message);
  4399.             }
  4400.             if (this.context.strict && stricted) {
  4401.                 this.tolerateUnexpectedToken(stricted, message);
  4402.             }
  4403.             this.context.strict = previousStrict;
  4404.             this.context.allowStrictDirective = previousAllowStrictDirective;
  4405.             this.context.await = previousAllowAwait;
  4406.             this.context.allowYield = previousAllowYield;
  4407.             return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
  4408.                 this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
  4409.         };
  4410.         // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
  4411.         Parser.prototype.parseDirective = function () {
  4412.             var token = this.lookahead;
  4413.             var node = this.createNode();
  4414.             var expr = this.parseExpression();
  4415.             var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;
  4416.             this.consumeSemicolon();
  4417.             return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
  4418.         };
  4419.         Parser.prototype.parseDirectivePrologues = function () {
  4420.             var firstRestricted = null;
  4421.             var body = [];
  4422.             while (true) {
  4423.                 var token = this.lookahead;
  4424.                 if (token.type !== 8 /* StringLiteral */) {
  4425.                     break;
  4426.                 }
  4427.                 var statement = this.parseDirective();
  4428.                 body.push(statement);
  4429.                 var directive = statement.directive;
  4430.                 if (typeof directive !== 'string') {
  4431.                     break;
  4432.                 }
  4433.                 if (directive === 'use strict') {
  4434.                     this.context.strict = true;
  4435.                     if (firstRestricted) {
  4436.                         this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
  4437.                     }
  4438.                     if (!this.context.allowStrictDirective) {
  4439.                         this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
  4440.                     }
  4441.                 }
  4442.                 else {
  4443.                     if (!firstRestricted && token.octal) {
  4444.                         firstRestricted = token;
  4445.                     }
  4446.                 }
  4447.             }
  4448.             return body;
  4449.         };
  4450.         // https://tc39.github.io/ecma262/#sec-method-definitions
  4451.         Parser.prototype.qualifiedPropertyName = function (token) {
  4452.             switch (token.type) {
  4453.                 case 3 /* Identifier */:
  4454.                 case 8 /* StringLiteral */:
  4455.                 case 1 /* BooleanLiteral */:
  4456.                 case 5 /* NullLiteral */:
  4457.                 case 6 /* NumericLiteral */:
  4458.                 case 4 /* Keyword */:
  4459.                     return true;
  4460.                 case 7 /* Punctuator */:
  4461.                     return token.value === '[';
  4462.                 default:
  4463.                     break;
  4464.             }
  4465.             return false;
  4466.         };
  4467.         Parser.prototype.parseGetterMethod = function () {
  4468.             var node = this.createNode();
  4469.             var isGenerator = false;
  4470.             var previousAllowYield = this.context.allowYield;
  4471.             this.context.allowYield = false;
  4472.             var formalParameters = this.parseFormalParameters();
  4473.             if (formalParameters.params.length > 0) {
  4474.                 this.tolerateError(messages_1.Messages.BadGetterArity);
  4475.             }
  4476.             var method = this.parsePropertyMethod(formalParameters);
  4477.             this.context.allowYield = previousAllowYield;
  4478.             return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
  4479.         };
  4480.         Parser.prototype.parseSetterMethod = function () {
  4481.             var node = this.createNode();
  4482.             var isGenerator = false;
  4483.             var previousAllowYield = this.context.allowYield;
  4484.             this.context.allowYield = false;
  4485.             var formalParameters = this.parseFormalParameters();
  4486.             if (formalParameters.params.length !== 1) {
  4487.                 this.tolerateError(messages_1.Messages.BadSetterArity);
  4488.             }
  4489.             else if (formalParameters.params[0] instanceof Node.RestElement) {
  4490.                 this.tolerateError(messages_1.Messages.BadSetterRestParameter);
  4491.             }
  4492.             var method = this.parsePropertyMethod(formalParameters);
  4493.             this.context.allowYield = previousAllowYield;
  4494.             return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
  4495.         };
  4496.         Parser.prototype.parseGeneratorMethod = function () {
  4497.             var node = this.createNode();
  4498.             var isGenerator = true;
  4499.             var previousAllowYield = this.context.allowYield;
  4500.             this.context.allowYield = true;
  4501.             var params = this.parseFormalParameters();
  4502.             this.context.allowYield = false;
  4503.             var method = this.parsePropertyMethod(params);
  4504.             this.context.allowYield = previousAllowYield;
  4505.             return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
  4506.         };
  4507.         // https://tc39.github.io/ecma262/#sec-generator-function-definitions
  4508.         Parser.prototype.isStartOfExpression = function () {
  4509.             var start = true;
  4510.             var value = this.lookahead.value;
  4511.             switch (this.lookahead.type) {
  4512.                 case 7 /* Punctuator */:
  4513.                     start = (value === '[') || (value === '(') || (value === '{') ||
  4514.                         (value === '+') || (value === '-') ||
  4515.                         (value === '!') || (value === '~') ||
  4516.                         (value === '++') || (value === '--') ||
  4517.                         (value === '/') || (value === '/='); // regular expression literal
  4518.                     break;
  4519.                 case 4 /* Keyword */:
  4520.                     start = (value === 'class') || (value === 'delete') ||
  4521.                         (value === 'function') || (value === 'let') || (value === 'new') ||
  4522.                         (value === 'super') || (value === 'this') || (value === 'typeof') ||
  4523.                         (value === 'void') || (value === 'yield');
  4524.                     break;
  4525.                 default:
  4526.                     break;
  4527.             }
  4528.             return start;
  4529.         };
  4530.         Parser.prototype.parseYieldExpression = function () {
  4531.             var node = this.createNode();
  4532.             this.expectKeyword('yield');
  4533.             var argument = null;
  4534.             var delegate = false;
  4535.             if (!this.hasLineTerminator) {
  4536.                 var previousAllowYield = this.context.allowYield;
  4537.                 this.context.allowYield = false;
  4538.                 delegate = this.match('*');
  4539.                 if (delegate) {
  4540.                     this.nextToken();
  4541.                     argument = this.parseAssignmentExpression();
  4542.                 }
  4543.                 else if (this.isStartOfExpression()) {
  4544.                     argument = this.parseAssignmentExpression();
  4545.                 }
  4546.                 this.context.allowYield = previousAllowYield;
  4547.             }
  4548.             return this.finalize(node, new Node.YieldExpression(argument, delegate));
  4549.         };
  4550.         // https://tc39.github.io/ecma262/#sec-class-definitions
  4551.         Parser.prototype.parseClassElement = function (hasConstructor) {
  4552.             var token = this.lookahead;
  4553.             var node = this.createNode();
  4554.             var kind = '';
  4555.             var key = null;
  4556.             var value = null;
  4557.             var computed = false;
  4558.             var method = false;
  4559.             var isStatic = false;
  4560.             var isAsync = false;
  4561.             if (this.match('*')) {
  4562.                 this.nextToken();
  4563.             }
  4564.             else {
  4565.                 computed = this.match('[');
  4566.                 key = this.parseObjectPropertyKey();
  4567.                 var id = key;
  4568.                 if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
  4569.                     token = this.lookahead;
  4570.                     isStatic = true;
  4571.                     computed = this.match('[');
  4572.                     if (this.match('*')) {
  4573.                         this.nextToken();
  4574.                     }
  4575.                     else {
  4576.                         key = this.parseObjectPropertyKey();
  4577.                     }
  4578.                 }
  4579.                 if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {
  4580.                     var punctuator = this.lookahead.value;
  4581.                     if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
  4582.                         isAsync = true;
  4583.                         token = this.lookahead;
  4584.                         key = this.parseObjectPropertyKey();
  4585.                         if (token.type === 3 /* Identifier */) {
  4586.                             if (token.value === 'get' || token.value === 'set') {
  4587.                                 this.tolerateUnexpectedToken(token);
  4588.                             }
  4589.                             else if (token.value === 'constructor') {
  4590.                                 this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
  4591.                             }
  4592.                         }
  4593.                     }
  4594.                 }
  4595.             }
  4596.             var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
  4597.             if (token.type === 3 /* Identifier */) {
  4598.                 if (token.value === 'get' && lookaheadPropertyKey) {
  4599.                     kind = 'get';
  4600.                     computed = this.match('[');
  4601.                     key = this.parseObjectPropertyKey();
  4602.                     this.context.allowYield = false;
  4603.                     value = this.parseGetterMethod();
  4604.                 }
  4605.                 else if (token.value === 'set' && lookaheadPropertyKey) {
  4606.                     kind = 'set';
  4607.                     computed = this.match('[');
  4608.                     key = this.parseObjectPropertyKey();
  4609.                     value = this.parseSetterMethod();
  4610.                 }
  4611.             }
  4612.             else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
  4613.                 kind = 'init';
  4614.                 computed = this.match('[');
  4615.                 key = this.parseObjectPropertyKey();
  4616.                 value = this.parseGeneratorMethod();
  4617.                 method = true;
  4618.             }
  4619.             if (!kind && key && this.match('(')) {
  4620.                 kind = 'init';
  4621.                 value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
  4622.                 method = true;
  4623.             }
  4624.             if (!kind) {
  4625.                 this.throwUnexpectedToken(this.lookahead);
  4626.             }
  4627.             if (kind === 'init') {
  4628.                 kind = 'method';
  4629.             }
  4630.             if (!computed) {
  4631.                 if (isStatic && this.isPropertyKey(key, 'prototype')) {
  4632.                     this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
  4633.                 }
  4634.                 if (!isStatic && this.isPropertyKey(key, 'constructor')) {
  4635.                     if (kind !== 'method' || !method || (value && value.generator)) {
  4636.                         this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
  4637.                     }
  4638.                     if (hasConstructor.value) {
  4639.                         this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
  4640.                     }
  4641.                     else {
  4642.                         hasConstructor.value = true;
  4643.                     }
  4644.                     kind = 'constructor';
  4645.                 }
  4646.             }
  4647.             return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
  4648.         };
  4649.         Parser.prototype.parseClassElementList = function () {
  4650.             var body = [];
  4651.             var hasConstructor = { value: false };
  4652.             this.expect('{');
  4653.             while (!this.match('}')) {
  4654.                 if (this.match(';')) {
  4655.                     this.nextToken();
  4656.                 }
  4657.                 else {
  4658.                     body.push(this.parseClassElement(hasConstructor));
  4659.                 }
  4660.             }
  4661.             this.expect('}');
  4662.             return body;
  4663.         };
  4664.         Parser.prototype.parseClassBody = function () {
  4665.             var node = this.createNode();
  4666.             var elementList = this.parseClassElementList();
  4667.             return this.finalize(node, new Node.ClassBody(elementList));
  4668.         };
  4669.         Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
  4670.             var node = this.createNode();
  4671.             var previousStrict = this.context.strict;
  4672.             this.context.strict = true;
  4673.             this.expectKeyword('class');
  4674.             var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();
  4675.             var superClass = null;
  4676.             if (this.matchKeyword('extends')) {
  4677.                 this.nextToken();
  4678.                 superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
  4679.             }
  4680.             var classBody = this.parseClassBody();
  4681.             this.context.strict = previousStrict;
  4682.             return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
  4683.         };
  4684.         Parser.prototype.parseClassExpression = function () {
  4685.             var node = this.createNode();
  4686.             var previousStrict = this.context.strict;
  4687.             this.context.strict = true;
  4688.             this.expectKeyword('class');
  4689.             var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;
  4690.             var superClass = null;
  4691.             if (this.matchKeyword('extends')) {
  4692.                 this.nextToken();
  4693.                 superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
  4694.             }
  4695.             var classBody = this.parseClassBody();
  4696.             this.context.strict = previousStrict;
  4697.             return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
  4698.         };
  4699.         // https://tc39.github.io/ecma262/#sec-scripts
  4700.         // https://tc39.github.io/ecma262/#sec-modules
  4701.         Parser.prototype.parseModule = function () {
  4702.             this.context.strict = true;
  4703.             this.context.isModule = true;
  4704.             var node = this.createNode();
  4705.             var body = this.parseDirectivePrologues();
  4706.             while (this.lookahead.type !== 2 /* EOF */) {
  4707.                 body.push(this.parseStatementListItem());
  4708.             }
  4709.             return this.finalize(node, new Node.Module(body));
  4710.         };
  4711.         Parser.prototype.parseScript = function () {
  4712.             var node = this.createNode();
  4713.             var body = this.parseDirectivePrologues();
  4714.             while (this.lookahead.type !== 2 /* EOF */) {
  4715.                 body.push(this.parseStatementListItem());
  4716.             }
  4717.             return this.finalize(node, new Node.Script(body));
  4718.         };
  4719.         // https://tc39.github.io/ecma262/#sec-imports
  4720.         Parser.prototype.parseModuleSpecifier = function () {
  4721.             var node = this.createNode();
  4722.             if (this.lookahead.type !== 8 /* StringLiteral */) {
  4723.                 this.throwError(messages_1.Messages.InvalidModuleSpecifier);
  4724.             }
  4725.             var token = this.nextToken();
  4726.             var raw = this.getTokenRaw(token);
  4727.             return this.finalize(node, new Node.Literal(token.value, raw));
  4728.         };
  4729.         // import {<foo as bar>} ...;
  4730.         Parser.prototype.parseImportSpecifier = function () {
  4731.             var node = this.createNode();
  4732.             var imported;
  4733.             var local;
  4734.             if (this.lookahead.type === 3 /* Identifier */) {
  4735.                 imported = this.parseVariableIdentifier();
  4736.                 local = imported;
  4737.                 if (this.matchContextualKeyword('as')) {
  4738.                     this.nextToken();
  4739.                     local = this.parseVariableIdentifier();
  4740.                 }
  4741.             }
  4742.             else {
  4743.                 imported = this.parseIdentifierName();
  4744.                 local = imported;
  4745.                 if (this.matchContextualKeyword('as')) {
  4746.                     this.nextToken();
  4747.                     local = this.parseVariableIdentifier();
  4748.                 }
  4749.                 else {
  4750.                     this.throwUnexpectedToken(this.nextToken());
  4751.                 }
  4752.             }
  4753.             return this.finalize(node, new Node.ImportSpecifier(local, imported));
  4754.         };
  4755.         // {foo, bar as bas}
  4756.         Parser.prototype.parseNamedImports = function () {
  4757.             this.expect('{');
  4758.             var specifiers = [];
  4759.             while (!this.match('}')) {
  4760.                 specifiers.push(this.parseImportSpecifier());
  4761.                 if (!this.match('}')) {
  4762.                     this.expect(',');
  4763.                 }
  4764.             }
  4765.             this.expect('}');
  4766.             return specifiers;
  4767.         };
  4768.         // import <foo> ...;
  4769.         Parser.prototype.parseImportDefaultSpecifier = function () {
  4770.             var node = this.createNode();
  4771.             var local = this.parseIdentifierName();
  4772.             return this.finalize(node, new Node.ImportDefaultSpecifier(local));
  4773.         };
  4774.         // import <* as foo> ...;
  4775.         Parser.prototype.parseImportNamespaceSpecifier = function () {
  4776.             var node = this.createNode();
  4777.             this.expect('*');
  4778.             if (!this.matchContextualKeyword('as')) {
  4779.                 this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
  4780.             }
  4781.             this.nextToken();
  4782.             var local = this.parseIdentifierName();
  4783.             return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
  4784.         };
  4785.         Parser.prototype.parseImportDeclaration = function () {
  4786.             if (this.context.inFunctionBody) {
  4787.                 this.throwError(messages_1.Messages.IllegalImportDeclaration);
  4788.             }
  4789.             var node = this.createNode();
  4790.             this.expectKeyword('import');
  4791.             var src;
  4792.             var specifiers = [];
  4793.             if (this.lookahead.type === 8 /* StringLiteral */) {
  4794.                 // import 'foo';
  4795.                 src = this.parseModuleSpecifier();
  4796.             }
  4797.             else {
  4798.                 if (this.match('{')) {
  4799.                     // import {bar}
  4800.                     specifiers = specifiers.concat(this.parseNamedImports());
  4801.                 }
  4802.                 else if (this.match('*')) {
  4803.                     // import * as foo
  4804.                     specifiers.push(this.parseImportNamespaceSpecifier());
  4805.                 }
  4806.                 else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
  4807.                     // import foo
  4808.                     specifiers.push(this.parseImportDefaultSpecifier());
  4809.                     if (this.match(',')) {
  4810.                         this.nextToken();
  4811.                         if (this.match('*')) {
  4812.                             // import foo, * as foo
  4813.                             specifiers.push(this.parseImportNamespaceSpecifier());
  4814.                         }
  4815.                         else if (this.match('{')) {
  4816.                             // import foo, {bar}
  4817.                             specifiers = specifiers.concat(this.parseNamedImports());
  4818.                         }
  4819.                         else {
  4820.                             this.throwUnexpectedToken(this.lookahead);
  4821.                         }
  4822.                     }
  4823.                 }
  4824.                 else {
  4825.                     this.throwUnexpectedToken(this.nextToken());
  4826.                 }
  4827.                 if (!this.matchContextualKeyword('from')) {
  4828.                     var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
  4829.                     this.throwError(message, this.lookahead.value);
  4830.                 }
  4831.                 this.nextToken();
  4832.                 src = this.parseModuleSpecifier();
  4833.             }
  4834.             this.consumeSemicolon();
  4835.             return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
  4836.         };
  4837.         // https://tc39.github.io/ecma262/#sec-exports
  4838.         Parser.prototype.parseExportSpecifier = function () {
  4839.             var node = this.createNode();
  4840.             var local = this.parseIdentifierName();
  4841.             var exported = local;
  4842.             if (this.matchContextualKeyword('as')) {
  4843.                 this.nextToken();
  4844.                 exported = this.parseIdentifierName();
  4845.             }
  4846.             return this.finalize(node, new Node.ExportSpecifier(local, exported));
  4847.         };
  4848.         Parser.prototype.parseExportDeclaration = function () {
  4849.             if (this.context.inFunctionBody) {
  4850.                 this.throwError(messages_1.Messages.IllegalExportDeclaration);
  4851.             }
  4852.             var node = this.createNode();
  4853.             this.expectKeyword('export');
  4854.             var exportDeclaration;
  4855.             if (this.matchKeyword('default')) {
  4856.                 // export default ...
  4857.                 this.nextToken();
  4858.                 if (this.matchKeyword('function')) {
  4859.                     // export default function foo () {}
  4860.                     // export default function () {}
  4861.                     var declaration = this.parseFunctionDeclaration(true);
  4862.                     exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
  4863.                 }
  4864.                 else if (this.matchKeyword('class')) {
  4865.                     // export default class foo {}
  4866.                     var declaration = this.parseClassDeclaration(true);
  4867.                     exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
  4868.                 }
  4869.                 else if (this.matchContextualKeyword('async')) {
  4870.                     // export default async function f () {}
  4871.                     // export default async function () {}
  4872.                     // export default async x => x
  4873.                     var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
  4874.                     exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
  4875.                 }
  4876.                 else {
  4877.                     if (this.matchContextualKeyword('from')) {
  4878.                         this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
  4879.                     }
  4880.                     // export default {};
  4881.                     // export default [];
  4882.                     // export default (1 + 2);
  4883.                     var declaration = this.match('{') ? this.parseObjectInitializer() :
  4884.                         this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
  4885.                     this.consumeSemicolon();
  4886.                     exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
  4887.                 }
  4888.             }
  4889.             else if (this.match('*')) {
  4890.                 // export * from 'foo';
  4891.                 this.nextToken();
  4892.                 if (!this.matchContextualKeyword('from')) {
  4893.                     var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
  4894.                     this.throwError(message, this.lookahead.value);
  4895.                 }
  4896.                 this.nextToken();
  4897.                 var src = this.parseModuleSpecifier();
  4898.                 this.consumeSemicolon();
  4899.                 exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
  4900.             }
  4901.             else if (this.lookahead.type === 4 /* Keyword */) {
  4902.                 // export var f = 1;
  4903.                 var declaration = void 0;
  4904.                 switch (this.lookahead.value) {
  4905.                     case 'let':
  4906.                     case 'const':
  4907.                         declaration = this.parseLexicalDeclaration({ inFor: false });
  4908.                         break;
  4909.                     case 'var':
  4910.                     case 'class':
  4911.                     case 'function':
  4912.                         declaration = this.parseStatementListItem();
  4913.                         break;
  4914.                     default:
  4915.                         this.throwUnexpectedToken(this.lookahead);
  4916.                 }
  4917.                 exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
  4918.             }
  4919.             else if (this.matchAsyncFunction()) {
  4920.                 var declaration = this.parseFunctionDeclaration();
  4921.                 exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
  4922.             }
  4923.             else {
  4924.                 var specifiers = [];
  4925.                 var source = null;
  4926.                 var isExportFromIdentifier = false;
  4927.                 this.expect('{');
  4928.                 while (!this.match('}')) {
  4929.                     isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
  4930.                     specifiers.push(this.parseExportSpecifier());
  4931.                     if (!this.match('}')) {
  4932.                         this.expect(',');
  4933.                     }
  4934.                 }
  4935.                 this.expect('}');
  4936.                 if (this.matchContextualKeyword('from')) {
  4937.                     // export {default} from 'foo';
  4938.                     // export {foo} from 'foo';
  4939.                     this.nextToken();
  4940.                     source = this.parseModuleSpecifier();
  4941.                     this.consumeSemicolon();
  4942.                 }
  4943.                 else if (isExportFromIdentifier) {
  4944.                     // export {default}; // missing fromClause
  4945.                     var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
  4946.                     this.throwError(message, this.lookahead.value);
  4947.                 }
  4948.                 else {
  4949.                     // export {foo};
  4950.                     this.consumeSemicolon();
  4951.                 }
  4952.                 exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
  4953.             }
  4954.             return exportDeclaration;
  4955.         };
  4956.         return Parser;
  4957.     }());
  4958.     exports.Parser = Parser;
  4959.  
  4960.  
  4961. /***/ },
  4962. /* 9 */
  4963. /***/ function(module, exports) {
  4964.  
  4965.     "use strict";
  4966.     // Ensure the condition is true, otherwise throw an error.
  4967.     // This is only to have a better contract semantic, i.e. another safety net
  4968.     // to catch a logic error. The condition shall be fulfilled in normal case.
  4969.     // Do NOT use this to enforce a certain condition on any user input.
  4970.     Object.defineProperty(exports, "__esModule", { value: true });
  4971.     function assert(condition, message) {
  4972.         /* istanbul ignore if */
  4973.         if (!condition) {
  4974.             throw new Error('ASSERT: ' + message);
  4975.         }
  4976.     }
  4977.     exports.assert = assert;
  4978.  
  4979.  
  4980. /***/ },
  4981. /* 10 */
  4982. /***/ function(module, exports) {
  4983.  
  4984.     "use strict";
  4985.     /* tslint:disable:max-classes-per-file */
  4986.     Object.defineProperty(exports, "__esModule", { value: true });
  4987.     var ErrorHandler = (function () {
  4988.         function ErrorHandler() {
  4989.             this.errors = [];
  4990.             this.tolerant = false;
  4991.         }
  4992.         ErrorHandler.prototype.recordError = function (error) {
  4993.             this.errors.push(error);
  4994.         };
  4995.         ErrorHandler.prototype.tolerate = function (error) {
  4996.             if (this.tolerant) {
  4997.                 this.recordError(error);
  4998.             }
  4999.             else {
  5000.                 throw error;
  5001.             }
  5002.         };
  5003.         ErrorHandler.prototype.constructError = function (msg, column) {
  5004.             var error = new Error(msg);
  5005.             try {
  5006.                 throw error;
  5007.             }
  5008.             catch (base) {
  5009.                 /* istanbul ignore else */
  5010.                 if (Object.create && Object.defineProperty) {
  5011.                     error = Object.create(base);
  5012.                     Object.defineProperty(error, 'column', { value: column });
  5013.                 }
  5014.             }
  5015.             /* istanbul ignore next */
  5016.             return error;
  5017.         };
  5018.         ErrorHandler.prototype.createError = function (index, line, col, description) {
  5019.             var msg = 'Line ' + line + ': ' + description;
  5020.             var error = this.constructError(msg, col);
  5021.             error.index = index;
  5022.             error.lineNumber = line;
  5023.             error.description = description;
  5024.             return error;
  5025.         };
  5026.         ErrorHandler.prototype.throwError = function (index, line, col, description) {
  5027.             throw this.createError(index, line, col, description);
  5028.         };
  5029.         ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
  5030.             var error = this.createError(index, line, col, description);
  5031.             if (this.tolerant) {
  5032.                 this.recordError(error);
  5033.             }
  5034.             else {
  5035.                 throw error;
  5036.             }
  5037.         };
  5038.         return ErrorHandler;
  5039.     }());
  5040.     exports.ErrorHandler = ErrorHandler;
  5041.  
  5042.  
  5043. /***/ },
  5044. /* 11 */
  5045. /***/ function(module, exports) {
  5046.  
  5047.     "use strict";
  5048.     Object.defineProperty(exports, "__esModule", { value: true });
  5049.     // Error messages should be identical to V8.
  5050.     exports.Messages = {
  5051.         BadGetterArity: 'Getter must not have any formal parameters',
  5052.         BadSetterArity: 'Setter must have exactly one formal parameter',
  5053.         BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
  5054.         ConstructorIsAsync: 'Class constructor may not be an async method',
  5055.         ConstructorSpecialMethod: 'Class constructor may not be an accessor',
  5056.         DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
  5057.         DefaultRestParameter: 'Unexpected token =',
  5058.         DuplicateBinding: 'Duplicate binding %0',
  5059.         DuplicateConstructor: 'A class may only have one constructor',
  5060.         DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
  5061.         ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
  5062.         GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
  5063.         IllegalBreak: 'Illegal break statement',
  5064.         IllegalContinue: 'Illegal continue statement',
  5065.         IllegalExportDeclaration: 'Unexpected token',
  5066.         IllegalImportDeclaration: 'Unexpected token',
  5067.         IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
  5068.         IllegalReturn: 'Illegal return statement',
  5069.         InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
  5070.         InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
  5071.         InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
  5072.         InvalidLHSInForIn: 'Invalid left-hand side in for-in',
  5073.         InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
  5074.         InvalidModuleSpecifier: 'Unexpected token',
  5075.         InvalidRegExp: 'Invalid regular expression',
  5076.         LetInLexicalBinding: 'let is disallowed as a lexically bound name',
  5077.         MissingFromClause: 'Unexpected token',
  5078.         MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
  5079.         NewlineAfterThrow: 'Illegal newline after throw',
  5080.         NoAsAfterImportNamespace: 'Unexpected token',
  5081.         NoCatchOrFinally: 'Missing catch or finally after try',
  5082.         ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
  5083.         Redeclaration: '%0 \'%1\' has already been declared',
  5084.         StaticPrototype: 'Classes may not have static property named prototype',
  5085.         StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
  5086.         StrictDelete: 'Delete of an unqualified identifier in strict mode.',
  5087.         StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
  5088.         StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
  5089.         StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
  5090.         StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
  5091.         StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
  5092.         StrictModeWith: 'Strict mode code may not include a with statement',
  5093.         StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
  5094.         StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
  5095.         StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
  5096.         StrictReservedWord: 'Use of future reserved word in strict mode',
  5097.         StrictVarName: 'Variable name may not be eval or arguments in strict mode',
  5098.         TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
  5099.         UnexpectedEOS: 'Unexpected end of input',
  5100.         UnexpectedIdentifier: 'Unexpected identifier',
  5101.         UnexpectedNumber: 'Unexpected number',
  5102.         UnexpectedReserved: 'Unexpected reserved word',
  5103.         UnexpectedString: 'Unexpected string',
  5104.         UnexpectedTemplate: 'Unexpected quasi %0',
  5105.         UnexpectedToken: 'Unexpected token %0',
  5106.         UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
  5107.         UnknownLabel: 'Undefined label \'%0\'',
  5108.         UnterminatedRegExp: 'Invalid regular expression: missing /'
  5109.     };
  5110.  
  5111.  
  5112. /***/ },
  5113. /* 12 */
  5114. /***/ function(module, exports, __webpack_require__) {
  5115.  
  5116.     "use strict";
  5117.     Object.defineProperty(exports, "__esModule", { value: true });
  5118.     var assert_1 = __webpack_require__(9);
  5119.     var character_1 = __webpack_require__(4);
  5120.     var messages_1 = __webpack_require__(11);
  5121.     function hexValue(ch) {
  5122.         return '0123456789abcdef'.indexOf(ch.toLowerCase());
  5123.     }
  5124.     function octalValue(ch) {
  5125.         return '01234567'.indexOf(ch);
  5126.     }
  5127.     var Scanner = (function () {
  5128.         function Scanner(code, handler) {
  5129.             this.source = code;
  5130.             this.errorHandler = handler;
  5131.             this.trackComment = false;
  5132.             this.length = code.length;
  5133.             this.index = 0;
  5134.             this.lineNumber = (code.length > 0) ? 1 : 0;
  5135.             this.lineStart = 0;
  5136.             this.curlyStack = [];
  5137.         }
  5138.         Scanner.prototype.saveState = function () {
  5139.             return {
  5140.                 index: this.index,
  5141.                 lineNumber: this.lineNumber,
  5142.                 lineStart: this.lineStart
  5143.             };
  5144.         };
  5145.         Scanner.prototype.restoreState = function (state) {
  5146.             this.index = state.index;
  5147.             this.lineNumber = state.lineNumber;
  5148.             this.lineStart = state.lineStart;
  5149.         };
  5150.         Scanner.prototype.eof = function () {
  5151.             return this.index >= this.length;
  5152.         };
  5153.         Scanner.prototype.throwUnexpectedToken = function (message) {
  5154.             if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
  5155.             return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
  5156.         };
  5157.         Scanner.prototype.tolerateUnexpectedToken = function (message) {
  5158.             if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
  5159.             this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
  5160.         };
  5161.         // https://tc39.github.io/ecma262/#sec-comments
  5162.         Scanner.prototype.skipSingleLineComment = function (offset) {
  5163.             var comments = [];
  5164.             var start, loc;
  5165.             if (this.trackComment) {
  5166.                 comments = [];
  5167.                 start = this.index - offset;
  5168.                 loc = {
  5169.                     start: {
  5170.                         line: this.lineNumber,
  5171.                         column: this.index - this.lineStart - offset
  5172.                     },
  5173.                     end: {}
  5174.                 };
  5175.             }
  5176.             while (!this.eof()) {
  5177.                 var ch = this.source.charCodeAt(this.index);
  5178.                 ++this.index;
  5179.                 if (character_1.Character.isLineTerminator(ch)) {
  5180.                     if (this.trackComment) {
  5181.                         loc.end = {
  5182.                             line: this.lineNumber,
  5183.                             column: this.index - this.lineStart - 1
  5184.                         };
  5185.                         var entry = {
  5186.                             multiLine: false,
  5187.                             slice: [start + offset, this.index - 1],
  5188.                             range: [start, this.index - 1],
  5189.                             loc: loc
  5190.                         };
  5191.                         comments.push(entry);
  5192.                     }
  5193.                     if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
  5194.                         ++this.index;
  5195.                     }
  5196.                     ++this.lineNumber;
  5197.                     this.lineStart = this.index;
  5198.                     return comments;
  5199.                 }
  5200.             }
  5201.             if (this.trackComment) {
  5202.                 loc.end = {
  5203.                     line: this.lineNumber,
  5204.                     column: this.index - this.lineStart
  5205.                 };
  5206.                 var entry = {
  5207.                     multiLine: false,
  5208.                     slice: [start + offset, this.index],
  5209.                     range: [start, this.index],
  5210.                     loc: loc
  5211.                 };
  5212.                 comments.push(entry);
  5213.             }
  5214.             return comments;
  5215.         };
  5216.         Scanner.prototype.skipMultiLineComment = function () {
  5217.             var comments = [];
  5218.             var start, loc;
  5219.             if (this.trackComment) {
  5220.                 comments = [];
  5221.                 start = this.index - 2;
  5222.                 loc = {
  5223.                     start: {
  5224.                         line: this.lineNumber,
  5225.                         column: this.index - this.lineStart - 2
  5226.                     },
  5227.                     end: {}
  5228.                 };
  5229.             }
  5230.             while (!this.eof()) {
  5231.                 var ch = this.source.charCodeAt(this.index);
  5232.                 if (character_1.Character.isLineTerminator(ch)) {
  5233.                     if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
  5234.                         ++this.index;
  5235.                     }
  5236.                     ++this.lineNumber;
  5237.                     ++this.index;
  5238.                     this.lineStart = this.index;
  5239.                 }
  5240.                 else if (ch === 0x2A) {
  5241.                     // Block comment ends with '*/'.
  5242.                     if (this.source.charCodeAt(this.index + 1) === 0x2F) {
  5243.                         this.index += 2;
  5244.                         if (this.trackComment) {
  5245.                             loc.end = {
  5246.                                 line: this.lineNumber,
  5247.                                 column: this.index - this.lineStart
  5248.                             };
  5249.                             var entry = {
  5250.                                 multiLine: true,
  5251.                                 slice: [start + 2, this.index - 2],
  5252.                                 range: [start, this.index],
  5253.                                 loc: loc
  5254.                             };
  5255.                             comments.push(entry);
  5256.                         }
  5257.                         return comments;
  5258.                     }
  5259.                     ++this.index;
  5260.                 }
  5261.                 else {
  5262.                     ++this.index;
  5263.                 }
  5264.             }
  5265.             // Ran off the end of the file - the whole thing is a comment
  5266.             if (this.trackComment) {
  5267.                 loc.end = {
  5268.                     line: this.lineNumber,
  5269.                     column: this.index - this.lineStart
  5270.                 };
  5271.                 var entry = {
  5272.                     multiLine: true,
  5273.                     slice: [start + 2, this.index],
  5274.                     range: [start, this.index],
  5275.                     loc: loc
  5276.                 };
  5277.                 comments.push(entry);
  5278.             }
  5279.             this.tolerateUnexpectedToken();
  5280.             return comments;
  5281.         };
  5282.         Scanner.prototype.scanComments = function () {
  5283.             var comments;
  5284.             if (this.trackComment) {
  5285.                 comments = [];
  5286.             }
  5287.             var start = (this.index === 0);
  5288.             while (!this.eof()) {
  5289.                 var ch = this.source.charCodeAt(this.index);
  5290.                 if (character_1.Character.isWhiteSpace(ch)) {
  5291.                     ++this.index;
  5292.                 }
  5293.                 else if (character_1.Character.isLineTerminator(ch)) {
  5294.                     ++this.index;
  5295.                     if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
  5296.                         ++this.index;
  5297.                     }
  5298.                     ++this.lineNumber;
  5299.                     this.lineStart = this.index;
  5300.                     start = true;
  5301.                 }
  5302.                 else if (ch === 0x2F) {
  5303.                     ch = this.source.charCodeAt(this.index + 1);
  5304.                     if (ch === 0x2F) {
  5305.                         this.index += 2;
  5306.                         var comment = this.skipSingleLineComment(2);
  5307.                         if (this.trackComment) {
  5308.                             comments = comments.concat(comment);
  5309.                         }
  5310.                         start = true;
  5311.                     }
  5312.                     else if (ch === 0x2A) {
  5313.                         this.index += 2;
  5314.                         var comment = this.skipMultiLineComment();
  5315.                         if (this.trackComment) {
  5316.                             comments = comments.concat(comment);
  5317.                         }
  5318.                     }
  5319.                     else {
  5320.                         break;
  5321.                     }
  5322.                 }
  5323.                 else if (start && ch === 0x2D) {
  5324.                     // U+003E is '>'
  5325.                     if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
  5326.                         // '-->' is a single-line comment
  5327.                         this.index += 3;
  5328.                         var comment = this.skipSingleLineComment(3);
  5329.                         if (this.trackComment) {
  5330.                             comments = comments.concat(comment);
  5331.                         }
  5332.                     }
  5333.                     else {
  5334.                         break;
  5335.                     }
  5336.                 }
  5337.                 else if (ch === 0x3C) {
  5338.                     if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
  5339.                         this.index += 4; // `<!--`
  5340.                         var comment = this.skipSingleLineComment(4);
  5341.                         if (this.trackComment) {
  5342.                             comments = comments.concat(comment);
  5343.                         }
  5344.                     }
  5345.                     else {
  5346.                         break;
  5347.                     }
  5348.                 }
  5349.                 else {
  5350.                     break;
  5351.                 }
  5352.             }
  5353.             return comments;
  5354.         };
  5355.         // https://tc39.github.io/ecma262/#sec-future-reserved-words
  5356.         Scanner.prototype.isFutureReservedWord = function (id) {
  5357.             switch (id) {
  5358.                 case 'enum':
  5359.                 case 'export':
  5360.                 case 'import':
  5361.                 case 'super':
  5362.                     return true;
  5363.                 default:
  5364.                     return false;
  5365.             }
  5366.         };
  5367.         Scanner.prototype.isStrictModeReservedWord = function (id) {
  5368.             switch (id) {
  5369.                 case 'implements':
  5370.                 case 'interface':
  5371.                 case 'package':
  5372.                 case 'private':
  5373.                 case 'protected':
  5374.                 case 'public':
  5375.                 case 'static':
  5376.                 case 'yield':
  5377.                 case 'let':
  5378.                     return true;
  5379.                 default:
  5380.                     return false;
  5381.             }
  5382.         };
  5383.         Scanner.prototype.isRestrictedWord = function (id) {
  5384.             return id === 'eval' || id === 'arguments';
  5385.         };
  5386.         // https://tc39.github.io/ecma262/#sec-keywords
  5387.         Scanner.prototype.isKeyword = function (id) {
  5388.             switch (id.length) {
  5389.                 case 2:
  5390.                     return (id === 'if') || (id === 'in') || (id === 'do');
  5391.                 case 3:
  5392.                     return (id === 'var') || (id === 'for') || (id === 'new') ||
  5393.                         (id === 'try') || (id === 'let');
  5394.                 case 4:
  5395.                     return (id === 'this') || (id === 'else') || (id === 'case') ||
  5396.                         (id === 'void') || (id === 'with') || (id === 'enum');
  5397.                 case 5:
  5398.                     return (id === 'while') || (id === 'break') || (id === 'catch') ||
  5399.                         (id === 'throw') || (id === 'const') || (id === 'yield') ||
  5400.                         (id === 'class') || (id === 'super');
  5401.                 case 6:
  5402.                     return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
  5403.                         (id === 'switch') || (id === 'export') || (id === 'import');
  5404.                 case 7:
  5405.                     return (id === 'default') || (id === 'finally') || (id === 'extends');
  5406.                 case 8:
  5407.                     return (id === 'function') || (id === 'continue') || (id === 'debugger');
  5408.                 case 10:
  5409.                     return (id === 'instanceof');
  5410.                 default:
  5411.                     return false;
  5412.             }
  5413.         };
  5414.         Scanner.prototype.codePointAt = function (i) {
  5415.             var cp = this.source.charCodeAt(i);
  5416.             if (cp >= 0xD800 && cp <= 0xDBFF) {
  5417.                 var second = this.source.charCodeAt(i + 1);
  5418.                 if (second >= 0xDC00 && second <= 0xDFFF) {
  5419.                     var first = cp;
  5420.                     cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
  5421.                 }
  5422.             }
  5423.             return cp;
  5424.         };
  5425.         Scanner.prototype.scanHexEscape = function (prefix) {
  5426.             var len = (prefix === 'u') ? 4 : 2;
  5427.             var code = 0;
  5428.             for (var i = 0; i < len; ++i) {
  5429.                 if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
  5430.                     code = code * 16 + hexValue(this.source[this.index++]);
  5431.                 }
  5432.                 else {
  5433.                     return null;
  5434.                 }
  5435.             }
  5436.             return String.fromCharCode(code);
  5437.         };
  5438.         Scanner.prototype.scanUnicodeCodePointEscape = function () {
  5439.             var ch = this.source[this.index];
  5440.             var code = 0;
  5441.             // At least, one hex digit is required.
  5442.             if (ch === '}') {
  5443.                 this.throwUnexpectedToken();
  5444.             }
  5445.             while (!this.eof()) {
  5446.                 ch = this.source[this.index++];
  5447.                 if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
  5448.                     break;
  5449.                 }
  5450.                 code = code * 16 + hexValue(ch);
  5451.             }
  5452.             if (code > 0x10FFFF || ch !== '}') {
  5453.                 this.throwUnexpectedToken();
  5454.             }
  5455.             return character_1.Character.fromCodePoint(code);
  5456.         };
  5457.         Scanner.prototype.getIdentifier = function () {
  5458.             var start = this.index++;
  5459.             while (!this.eof()) {
  5460.                 var ch = this.source.charCodeAt(this.index);
  5461.                 if (ch === 0x5C) {
  5462.                     // Blackslash (U+005C) marks Unicode escape sequence.
  5463.                     this.index = start;
  5464.                     return this.getComplexIdentifier();
  5465.                 }
  5466.                 else if (ch >= 0xD800 && ch < 0xDFFF) {
  5467.                     // Need to handle surrogate pairs.
  5468.                     this.index = start;
  5469.                     return this.getComplexIdentifier();
  5470.                 }
  5471.                 if (character_1.Character.isIdentifierPart(ch)) {
  5472.                     ++this.index;
  5473.                 }
  5474.                 else {
  5475.                     break;
  5476.                 }
  5477.             }
  5478.             return this.source.slice(start, this.index);
  5479.         };
  5480.         Scanner.prototype.getComplexIdentifier = function () {
  5481.             var cp = this.codePointAt(this.index);
  5482.             var id = character_1.Character.fromCodePoint(cp);
  5483.             this.index += id.length;
  5484.             // '\u' (U+005C, U+0075) denotes an escaped character.
  5485.             var ch;
  5486.             if (cp === 0x5C) {
  5487.                 if (this.source.charCodeAt(this.index) !== 0x75) {
  5488.                     this.throwUnexpectedToken();
  5489.                 }
  5490.                 ++this.index;
  5491.                 if (this.source[this.index] === '{') {
  5492.                     ++this.index;
  5493.                     ch = this.scanUnicodeCodePointEscape();
  5494.                 }
  5495.                 else {
  5496.                     ch = this.scanHexEscape('u');
  5497.                     if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
  5498.                         this.throwUnexpectedToken();
  5499.                     }
  5500.                 }
  5501.                 id = ch;
  5502.             }
  5503.             while (!this.eof()) {
  5504.                 cp = this.codePointAt(this.index);
  5505.                 if (!character_1.Character.isIdentifierPart(cp)) {
  5506.                     break;
  5507.                 }
  5508.                 ch = character_1.Character.fromCodePoint(cp);
  5509.                 id += ch;
  5510.                 this.index += ch.length;
  5511.                 // '\u' (U+005C, U+0075) denotes an escaped character.
  5512.                 if (cp === 0x5C) {
  5513.                     id = id.substr(0, id.length - 1);
  5514.                     if (this.source.charCodeAt(this.index) !== 0x75) {
  5515.                         this.throwUnexpectedToken();
  5516.                     }
  5517.                     ++this.index;
  5518.                     if (this.source[this.index] === '{') {
  5519.                         ++this.index;
  5520.                         ch = this.scanUnicodeCodePointEscape();
  5521.                     }
  5522.                     else {
  5523.                         ch = this.scanHexEscape('u');
  5524.                         if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
  5525.                             this.throwUnexpectedToken();
  5526.                         }
  5527.                     }
  5528.                     id += ch;
  5529.                 }
  5530.             }
  5531.             return id;
  5532.         };
  5533.         Scanner.prototype.octalToDecimal = function (ch) {
  5534.             // \0 is not octal escape sequence
  5535.             var octal = (ch !== '0');
  5536.             var code = octalValue(ch);
  5537.             if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
  5538.                 octal = true;
  5539.                 code = code * 8 + octalValue(this.source[this.index++]);
  5540.                 // 3 digits are only allowed when string starts
  5541.                 // with 0, 1, 2, 3
  5542.                 if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
  5543.                     code = code * 8 + octalValue(this.source[this.index++]);
  5544.                 }
  5545.             }
  5546.             return {
  5547.                 code: code,
  5548.                 octal: octal
  5549.             };
  5550.         };
  5551.         // https://tc39.github.io/ecma262/#sec-names-and-keywords
  5552.         Scanner.prototype.scanIdentifier = function () {
  5553.             var type;
  5554.             var start = this.index;
  5555.             // Backslash (U+005C) starts an escaped character.
  5556.             var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();
  5557.             // There is no keyword or literal with only one character.
  5558.             // Thus, it must be an identifier.
  5559.             if (id.length === 1) {
  5560.                 type = 3 /* Identifier */;
  5561.             }
  5562.             else if (this.isKeyword(id)) {
  5563.                 type = 4 /* Keyword */;
  5564.             }
  5565.             else if (id === 'null') {
  5566.                 type = 5 /* NullLiteral */;
  5567.             }
  5568.             else if (id === 'true' || id === 'false') {
  5569.                 type = 1 /* BooleanLiteral */;
  5570.             }
  5571.             else {
  5572.                 type = 3 /* Identifier */;
  5573.             }
  5574.             if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {
  5575.                 var restore = this.index;
  5576.                 this.index = start;
  5577.                 this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
  5578.                 this.index = restore;
  5579.             }
  5580.             return {
  5581.                 type: type,
  5582.                 value: id,
  5583.                 lineNumber: this.lineNumber,
  5584.                 lineStart: this.lineStart,
  5585.                 start: start,
  5586.                 end: this.index
  5587.             };
  5588.         };
  5589.         // https://tc39.github.io/ecma262/#sec-punctuators
  5590.         Scanner.prototype.scanPunctuator = function () {
  5591.             var start = this.index;
  5592.             // Check for most common single-character punctuators.
  5593.             var str = this.source[this.index];
  5594.             switch (str) {
  5595.                 case '(':
  5596.                 case '{':
  5597.                     if (str === '{') {
  5598.                         this.curlyStack.push('{');
  5599.                     }
  5600.                     ++this.index;
  5601.                     break;
  5602.                 case '.':
  5603.                     ++this.index;
  5604.                     if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
  5605.                         // Spread operator: ...
  5606.                         this.index += 2;
  5607.                         str = '...';
  5608.                     }
  5609.                     break;
  5610.                 case '}':
  5611.                     ++this.index;
  5612.                     this.curlyStack.pop();
  5613.                     break;
  5614.                 case ')':
  5615.                 case ';':
  5616.                 case ',':
  5617.                 case '[':
  5618.                 case ']':
  5619.                 case ':':
  5620.                 case '?':
  5621.                 case '~':
  5622.                     ++this.index;
  5623.                     break;
  5624.                 default:
  5625.                     // 4-character punctuator.
  5626.                     str = this.source.substr(this.index, 4);
  5627.                     if (str === '>>>=') {
  5628.                         this.index += 4;
  5629.                     }
  5630.                     else {
  5631.                         // 3-character punctuators.
  5632.                         str = str.substr(0, 3);
  5633.                         if (str === '===' || str === '!==' || str === '>>>' ||
  5634.                             str === '<<=' || str === '>>=' || str === '**=') {
  5635.                             this.index += 3;
  5636.                         }
  5637.                         else {
  5638.                             // 2-character punctuators.
  5639.                             str = str.substr(0, 2);
  5640.                             if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
  5641.                                 str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
  5642.                                 str === '++' || str === '--' || str === '<<' || str === '>>' ||
  5643.                                 str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
  5644.                                 str === '<=' || str === '>=' || str === '=>' || str === '**') {
  5645.                                 this.index += 2;
  5646.                             }
  5647.                             else {
  5648.                                 // 1-character punctuators.
  5649.                                 str = this.source[this.index];
  5650.                                 if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
  5651.                                     ++this.index;
  5652.                                 }
  5653.                             }
  5654.                         }
  5655.                     }
  5656.             }
  5657.             if (this.index === start) {
  5658.                 this.throwUnexpectedToken();
  5659.             }
  5660.             return {
  5661.                 type: 7 /* Punctuator */,
  5662.                 value: str,
  5663.                 lineNumber: this.lineNumber,
  5664.                 lineStart: this.lineStart,
  5665.                 start: start,
  5666.                 end: this.index
  5667.             };
  5668.         };
  5669.         // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
  5670.         Scanner.prototype.scanHexLiteral = function (start) {
  5671.             var num = '';
  5672.             while (!this.eof()) {
  5673.                 if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
  5674.                     break;
  5675.                 }
  5676.                 num += this.source[this.index++];
  5677.             }
  5678.             if (num.length === 0) {
  5679.                 this.throwUnexpectedToken();
  5680.             }
  5681.             if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
  5682.                 this.throwUnexpectedToken();
  5683.             }
  5684.             return {
  5685.                 type: 6 /* NumericLiteral */,
  5686.                 value: parseInt('0x' + num, 16),
  5687.                 lineNumber: this.lineNumber,
  5688.                 lineStart: this.lineStart,
  5689.                 start: start,
  5690.                 end: this.index
  5691.             };
  5692.         };
  5693.         Scanner.prototype.scanBinaryLiteral = function (start) {
  5694.             var num = '';
  5695.             var ch;
  5696.             while (!this.eof()) {
  5697.                 ch = this.source[this.index];
  5698.                 if (ch !== '0' && ch !== '1') {
  5699.                     break;
  5700.                 }
  5701.                 num += this.source[this.index++];
  5702.             }
  5703.             if (num.length === 0) {
  5704.                 // only 0b or 0B
  5705.                 this.throwUnexpectedToken();
  5706.             }
  5707.             if (!this.eof()) {
  5708.                 ch = this.source.charCodeAt(this.index);
  5709.                 /* istanbul ignore else */
  5710.                 if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
  5711.                     this.throwUnexpectedToken();
  5712.                 }
  5713.             }
  5714.             return {
  5715.                 type: 6 /* NumericLiteral */,
  5716.                 value: parseInt(num, 2),
  5717.                 lineNumber: this.lineNumber,
  5718.                 lineStart: this.lineStart,
  5719.                 start: start,
  5720.                 end: this.index
  5721.             };
  5722.         };
  5723.         Scanner.prototype.scanOctalLiteral = function (prefix, start) {
  5724.             var num = '';
  5725.             var octal = false;
  5726.             if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
  5727.                 octal = true;
  5728.                 num = '0' + this.source[this.index++];
  5729.             }
  5730.             else {
  5731.                 ++this.index;
  5732.             }
  5733.             while (!this.eof()) {
  5734.                 if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
  5735.                     break;
  5736.                 }
  5737.                 num += this.source[this.index++];
  5738.             }
  5739.             if (!octal && num.length === 0) {
  5740.                 // only 0o or 0O
  5741.                 this.throwUnexpectedToken();
  5742.             }
  5743.             if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  5744.                 this.throwUnexpectedToken();
  5745.             }
  5746.             return {
  5747.                 type: 6 /* NumericLiteral */,
  5748.                 value: parseInt(num, 8),
  5749.                 octal: octal,
  5750.                 lineNumber: this.lineNumber,
  5751.                 lineStart: this.lineStart,
  5752.                 start: start,
  5753.                 end: this.index
  5754.             };
  5755.         };
  5756.         Scanner.prototype.isImplicitOctalLiteral = function () {
  5757.             // Implicit octal, unless there is a non-octal digit.
  5758.             // (Annex B.1.1 on Numeric Literals)
  5759.             for (var i = this.index + 1; i < this.length; ++i) {
  5760.                 var ch = this.source[i];
  5761.                 if (ch === '8' || ch === '9') {
  5762.                     return false;
  5763.                 }
  5764.                 if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
  5765.                     return true;
  5766.                 }
  5767.             }
  5768.             return true;
  5769.         };
  5770.         Scanner.prototype.scanNumericLiteral = function () {
  5771.             var start = this.index;
  5772.             var ch = this.source[start];
  5773.             assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
  5774.             var num = '';
  5775.             if (ch !== '.') {
  5776.                 num = this.source[this.index++];
  5777.                 ch = this.source[this.index];
  5778.                 // Hex number starts with '0x'.
  5779.                 // Octal number starts with '0'.
  5780.                 // Octal number in ES6 starts with '0o'.
  5781.                 // Binary number in ES6 starts with '0b'.
  5782.                 if (num === '0') {
  5783.                     if (ch === 'x' || ch === 'X') {
  5784.                         ++this.index;
  5785.                         return this.scanHexLiteral(start);
  5786.                     }
  5787.                     if (ch === 'b' || ch === 'B') {
  5788.                         ++this.index;
  5789.                         return this.scanBinaryLiteral(start);
  5790.                     }
  5791.                     if (ch === 'o' || ch === 'O') {
  5792.                         return this.scanOctalLiteral(ch, start);
  5793.                     }
  5794.                     if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
  5795.                         if (this.isImplicitOctalLiteral()) {
  5796.                             return this.scanOctalLiteral(ch, start);
  5797.                         }
  5798.                     }
  5799.                 }
  5800.                 while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  5801.                     num += this.source[this.index++];
  5802.                 }
  5803.                 ch = this.source[this.index];
  5804.             }
  5805.             if (ch === '.') {
  5806.                 num += this.source[this.index++];
  5807.                 while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  5808.                     num += this.source[this.index++];
  5809.                 }
  5810.                 ch = this.source[this.index];
  5811.             }
  5812.             if (ch === 'e' || ch === 'E') {
  5813.                 num += this.source[this.index++];
  5814.                 ch = this.source[this.index];
  5815.                 if (ch === '+' || ch === '-') {
  5816.                     num += this.source[this.index++];
  5817.                 }
  5818.                 if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  5819.                     while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  5820.                         num += this.source[this.index++];
  5821.                     }
  5822.                 }
  5823.                 else {
  5824.                     this.throwUnexpectedToken();
  5825.                 }
  5826.             }
  5827.             if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
  5828.                 this.throwUnexpectedToken();
  5829.             }
  5830.             return {
  5831.                 type: 6 /* NumericLiteral */,
  5832.                 value: parseFloat(num),
  5833.                 lineNumber: this.lineNumber,
  5834.                 lineStart: this.lineStart,
  5835.                 start: start,
  5836.                 end: this.index
  5837.             };
  5838.         };
  5839.         // https://tc39.github.io/ecma262/#sec-literals-string-literals
  5840.         Scanner.prototype.scanStringLiteral = function () {
  5841.             var start = this.index;
  5842.             var quote = this.source[start];
  5843.             assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
  5844.             ++this.index;
  5845.             var octal = false;
  5846.             var str = '';
  5847.             while (!this.eof()) {
  5848.                 var ch = this.source[this.index++];
  5849.                 if (ch === quote) {
  5850.                     quote = '';
  5851.                     break;
  5852.                 }
  5853.                 else if (ch === '\\') {
  5854.                     ch = this.source[this.index++];
  5855.                     if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  5856.                         switch (ch) {
  5857.                             case 'u':
  5858.                                 if (this.source[this.index] === '{') {
  5859.                                     ++this.index;
  5860.                                     str += this.scanUnicodeCodePointEscape();
  5861.                                 }
  5862.                                 else {
  5863.                                     var unescaped_1 = this.scanHexEscape(ch);
  5864.                                     if (unescaped_1 === null) {
  5865.                                         this.throwUnexpectedToken();
  5866.                                     }
  5867.                                     str += unescaped_1;
  5868.                                 }
  5869.                                 break;
  5870.                             case 'x':
  5871.                                 var unescaped = this.scanHexEscape(ch);
  5872.                                 if (unescaped === null) {
  5873.                                     this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
  5874.                                 }
  5875.                                 str += unescaped;
  5876.                                 break;
  5877.                             case 'n':
  5878.                                 str += '\n';
  5879.                                 break;
  5880.                             case 'r':
  5881.                                 str += '\r';
  5882.                                 break;
  5883.                             case 't':
  5884.                                 str += '\t';
  5885.                                 break;
  5886.                             case 'b':
  5887.                                 str += '\b';
  5888.                                 break;
  5889.                             case 'f':
  5890.                                 str += '\f';
  5891.                                 break;
  5892.                             case 'v':
  5893.                                 str += '\x0B';
  5894.                                 break;
  5895.                             case '8':
  5896.                             case '9':
  5897.                                 str += ch;
  5898.                                 this.tolerateUnexpectedToken();
  5899.                                 break;
  5900.                             default:
  5901.                                 if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
  5902.                                     var octToDec = this.octalToDecimal(ch);
  5903.                                     octal = octToDec.octal || octal;
  5904.                                     str += String.fromCharCode(octToDec.code);
  5905.                                 }
  5906.                                 else {
  5907.                                     str += ch;
  5908.                                 }
  5909.                                 break;
  5910.                         }
  5911.                     }
  5912.                     else {
  5913.                         ++this.lineNumber;
  5914.                         if (ch === '\r' && this.source[this.index] === '\n') {
  5915.                             ++this.index;
  5916.                         }
  5917.                         this.lineStart = this.index;
  5918.                     }
  5919.                 }
  5920.                 else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  5921.                     break;
  5922.                 }
  5923.                 else {
  5924.                     str += ch;
  5925.                 }
  5926.             }
  5927.             if (quote !== '') {
  5928.                 this.index = start;
  5929.                 this.throwUnexpectedToken();
  5930.             }
  5931.             return {
  5932.                 type: 8 /* StringLiteral */,
  5933.                 value: str,
  5934.                 octal: octal,
  5935.                 lineNumber: this.lineNumber,
  5936.                 lineStart: this.lineStart,
  5937.                 start: start,
  5938.                 end: this.index
  5939.             };
  5940.         };
  5941.         // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
  5942.         Scanner.prototype.scanTemplate = function () {
  5943.             var cooked = '';
  5944.             var terminated = false;
  5945.             var start = this.index;
  5946.             var head = (this.source[start] === '`');
  5947.             var tail = false;
  5948.             var rawOffset = 2;
  5949.             ++this.index;
  5950.             while (!this.eof()) {
  5951.                 var ch = this.source[this.index++];
  5952.                 if (ch === '`') {
  5953.                     rawOffset = 1;
  5954.                     tail = true;
  5955.                     terminated = true;
  5956.                     break;
  5957.                 }
  5958.                 else if (ch === '$') {
  5959.                     if (this.source[this.index] === '{') {
  5960.                         this.curlyStack.push('${');
  5961.                         ++this.index;
  5962.                         terminated = true;
  5963.                         break;
  5964.                     }
  5965.                     cooked += ch;
  5966.                 }
  5967.                 else if (ch === '\\') {
  5968.                     ch = this.source[this.index++];
  5969.                     if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  5970.                         switch (ch) {
  5971.                             case 'n':
  5972.                                 cooked += '\n';
  5973.                                 break;
  5974.                             case 'r':
  5975.                                 cooked += '\r';
  5976.                                 break;
  5977.                             case 't':
  5978.                                 cooked += '\t';
  5979.                                 break;
  5980.                             case 'u':
  5981.                                 if (this.source[this.index] === '{') {
  5982.                                     ++this.index;
  5983.                                     cooked += this.scanUnicodeCodePointEscape();
  5984.                                 }
  5985.                                 else {
  5986.                                     var restore = this.index;
  5987.                                     var unescaped_2 = this.scanHexEscape(ch);
  5988.                                     if (unescaped_2 !== null) {
  5989.                                         cooked += unescaped_2;
  5990.                                     }
  5991.                                     else {
  5992.                                         this.index = restore;
  5993.                                         cooked += ch;
  5994.                                     }
  5995.                                 }
  5996.                                 break;
  5997.                             case 'x':
  5998.                                 var unescaped = this.scanHexEscape(ch);
  5999.                                 if (unescaped === null) {
  6000.                                     this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
  6001.                                 }
  6002.                                 cooked += unescaped;
  6003.                                 break;
  6004.                             case 'b':
  6005.                                 cooked += '\b';
  6006.                                 break;
  6007.                             case 'f':
  6008.                                 cooked += '\f';
  6009.                                 break;
  6010.                             case 'v':
  6011.                                 cooked += '\v';
  6012.                                 break;
  6013.                             default:
  6014.                                 if (ch === '0') {
  6015.                                     if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
  6016.                                         // Illegal: \01 \02 and so on
  6017.                                         this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
  6018.                                     }
  6019.                                     cooked += '\0';
  6020.                                 }
  6021.                                 else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
  6022.                                     // Illegal: \1 \2
  6023.                                     this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
  6024.                                 }
  6025.                                 else {
  6026.                                     cooked += ch;
  6027.                                 }
  6028.                                 break;
  6029.                         }
  6030.                     }
  6031.                     else {
  6032.                         ++this.lineNumber;
  6033.                         if (ch === '\r' && this.source[this.index] === '\n') {
  6034.                             ++this.index;
  6035.                         }
  6036.                         this.lineStart = this.index;
  6037.                     }
  6038.                 }
  6039.                 else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  6040.                     ++this.lineNumber;
  6041.                     if (ch === '\r' && this.source[this.index] === '\n') {
  6042.                         ++this.index;
  6043.                     }
  6044.                     this.lineStart = this.index;
  6045.                     cooked += '\n';
  6046.                 }
  6047.                 else {
  6048.                     cooked += ch;
  6049.                 }
  6050.             }
  6051.             if (!terminated) {
  6052.                 this.throwUnexpectedToken();
  6053.             }
  6054.             if (!head) {
  6055.                 this.curlyStack.pop();
  6056.             }
  6057.             return {
  6058.                 type: 10 /* Template */,
  6059.                 value: this.source.slice(start + 1, this.index - rawOffset),
  6060.                 cooked: cooked,
  6061.                 head: head,
  6062.                 tail: tail,
  6063.                 lineNumber: this.lineNumber,
  6064.                 lineStart: this.lineStart,
  6065.                 start: start,
  6066.                 end: this.index
  6067.             };
  6068.         };
  6069.         // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
  6070.         Scanner.prototype.testRegExp = function (pattern, flags) {
  6071.             // The BMP character to use as a replacement for astral symbols when
  6072.             // translating an ES6 "u"-flagged pattern to an ES5-compatible
  6073.             // approximation.
  6074.             // Note: replacing with '\uFFFF' enables false positives in unlikely
  6075.             // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
  6076.             // pattern that would not be detected by this substitution.
  6077.             var astralSubstitute = '\uFFFF';
  6078.             var tmp = pattern;
  6079.             var self = this;
  6080.             if (flags.indexOf('u') >= 0) {
  6081.                 tmp = tmp
  6082.                     .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
  6083.                     var codePoint = parseInt($1 || $2, 16);
  6084.                     if (codePoint > 0x10FFFF) {
  6085.                         self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
  6086.                     }
  6087.                     if (codePoint <= 0xFFFF) {
  6088.                         return String.fromCharCode(codePoint);
  6089.                     }
  6090.                     return astralSubstitute;
  6091.                 })
  6092.                     .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
  6093.             }
  6094.             // First, detect invalid regular expressions.
  6095.             try {
  6096.                 RegExp(tmp);
  6097.             }
  6098.             catch (e) {
  6099.                 this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
  6100.             }
  6101.             // Return a regular expression object for this pattern-flag pair, or
  6102.             // `null` in case the current environment doesn't support the flags it
  6103.             // uses.
  6104.             try {
  6105.                 return new RegExp(pattern, flags);
  6106.             }
  6107.             catch (exception) {
  6108.                 /* istanbul ignore next */
  6109.                 return null;
  6110.             }
  6111.         };
  6112.         Scanner.prototype.scanRegExpBody = function () {
  6113.             var ch = this.source[this.index];
  6114.             assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
  6115.             var str = this.source[this.index++];
  6116.             var classMarker = false;
  6117.             var terminated = false;
  6118.             while (!this.eof()) {
  6119.                 ch = this.source[this.index++];
  6120.                 str += ch;
  6121.                 if (ch === '\\') {
  6122.                     ch = this.source[this.index++];
  6123.                     // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
  6124.                     if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  6125.                         this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
  6126.                     }
  6127.                     str += ch;
  6128.                 }
  6129.                 else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
  6130.                     this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
  6131.                 }
  6132.                 else if (classMarker) {
  6133.                     if (ch === ']') {
  6134.                         classMarker = false;
  6135.                     }
  6136.                 }
  6137.                 else {
  6138.                     if (ch === '/') {
  6139.                         terminated = true;
  6140.                         break;
  6141.                     }
  6142.                     else if (ch === '[') {
  6143.                         classMarker = true;
  6144.                     }
  6145.                 }
  6146.             }
  6147.             if (!terminated) {
  6148.                 this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
  6149.             }
  6150.             // Exclude leading and trailing slash.
  6151.             return str.substr(1, str.length - 2);
  6152.         };
  6153.         Scanner.prototype.scanRegExpFlags = function () {
  6154.             var str = '';
  6155.             var flags = '';
  6156.             while (!this.eof()) {
  6157.                 var ch = this.source[this.index];
  6158.                 if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
  6159.                     break;
  6160.                 }
  6161.                 ++this.index;
  6162.                 if (ch === '\\' && !this.eof()) {
  6163.                     ch = this.source[this.index];
  6164.                     if (ch === 'u') {
  6165.                         ++this.index;
  6166.                         var restore = this.index;
  6167.                         var char = this.scanHexEscape('u');
  6168.                         if (char !== null) {
  6169.                             flags += char;
  6170.                             for (str += '\\u'; restore < this.index; ++restore) {
  6171.                                 str += this.source[restore];
  6172.                             }
  6173.                         }
  6174.                         else {
  6175.                             this.index = restore;
  6176.                             flags += 'u';
  6177.                             str += '\\u';
  6178.                         }
  6179.                         this.tolerateUnexpectedToken();
  6180.                     }
  6181.                     else {
  6182.                         str += '\\';
  6183.                         this.tolerateUnexpectedToken();
  6184.                     }
  6185.                 }
  6186.                 else {
  6187.                     flags += ch;
  6188.                     str += ch;
  6189.                 }
  6190.             }
  6191.             return flags;
  6192.         };
  6193.         Scanner.prototype.scanRegExp = function () {
  6194.             var start = this.index;
  6195.             var pattern = this.scanRegExpBody();
  6196.             var flags = this.scanRegExpFlags();
  6197.             var value = this.testRegExp(pattern, flags);
  6198.             return {
  6199.                 type: 9 /* RegularExpression */,
  6200.                 value: '',
  6201.                 pattern: pattern,
  6202.                 flags: flags,
  6203.                 regex: value,
  6204.                 lineNumber: this.lineNumber,
  6205.                 lineStart: this.lineStart,
  6206.                 start: start,
  6207.                 end: this.index
  6208.             };
  6209.         };
  6210.         Scanner.prototype.lex = function () {
  6211.             if (this.eof()) {
  6212.                 return {
  6213.                     type: 2 /* EOF */,
  6214.                     value: '',
  6215.                     lineNumber: this.lineNumber,
  6216.                     lineStart: this.lineStart,
  6217.                     start: this.index,
  6218.                     end: this.index
  6219.                 };
  6220.             }
  6221.             var cp = this.source.charCodeAt(this.index);
  6222.             if (character_1.Character.isIdentifierStart(cp)) {
  6223.                 return this.scanIdentifier();
  6224.             }
  6225.             // Very common: ( and ) and ;
  6226.             if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
  6227.                 return this.scanPunctuator();
  6228.             }
  6229.             // String literal starts with single quote (U+0027) or double quote (U+0022).
  6230.             if (cp === 0x27 || cp === 0x22) {
  6231.                 return this.scanStringLiteral();
  6232.             }
  6233.             // Dot (.) U+002E can also start a floating-point number, hence the need
  6234.             // to check the next character.
  6235.             if (cp === 0x2E) {
  6236.                 if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
  6237.                     return this.scanNumericLiteral();
  6238.                 }
  6239.                 return this.scanPunctuator();
  6240.             }
  6241.             if (character_1.Character.isDecimalDigit(cp)) {
  6242.                 return this.scanNumericLiteral();
  6243.             }
  6244.             // Template literals start with ` (U+0060) for template head
  6245.             // or } (U+007D) for template middle or template tail.
  6246.             if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {
  6247.                 return this.scanTemplate();
  6248.             }
  6249.             // Possible identifier start in a surrogate pair.
  6250.             if (cp >= 0xD800 && cp < 0xDFFF) {
  6251.                 if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
  6252.                     return this.scanIdentifier();
  6253.                 }
  6254.             }
  6255.             return this.scanPunctuator();
  6256.         };
  6257.         return Scanner;
  6258.     }());
  6259.     exports.Scanner = Scanner;
  6260.  
  6261.  
  6262. /***/ },
  6263. /* 13 */
  6264. /***/ function(module, exports) {
  6265.  
  6266.     "use strict";
  6267.     Object.defineProperty(exports, "__esModule", { value: true });
  6268.     exports.TokenName = {};
  6269.     exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';
  6270.     exports.TokenName[2 /* EOF */] = '<end>';
  6271.     exports.TokenName[3 /* Identifier */] = 'Identifier';
  6272.     exports.TokenName[4 /* Keyword */] = 'Keyword';
  6273.     exports.TokenName[5 /* NullLiteral */] = 'Null';
  6274.     exports.TokenName[6 /* NumericLiteral */] = 'Numeric';
  6275.     exports.TokenName[7 /* Punctuator */] = 'Punctuator';
  6276.     exports.TokenName[8 /* StringLiteral */] = 'String';
  6277.     exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';
  6278.     exports.TokenName[10 /* Template */] = 'Template';
  6279.  
  6280.  
  6281. /***/ },
  6282. /* 14 */
  6283. /***/ function(module, exports) {
  6284.  
  6285.     "use strict";
  6286.     // Generated by generate-xhtml-entities.js. DO NOT MODIFY!
  6287.     Object.defineProperty(exports, "__esModule", { value: true });
  6288.     exports.XHTMLEntities = {
  6289.         quot: '\u0022',
  6290.         amp: '\u0026',
  6291.         apos: '\u0027',
  6292.         gt: '\u003E',
  6293.         nbsp: '\u00A0',
  6294.         iexcl: '\u00A1',
  6295.         cent: '\u00A2',
  6296.         pound: '\u00A3',
  6297.         curren: '\u00A4',
  6298.         yen: '\u00A5',
  6299.         brvbar: '\u00A6',
  6300.         sect: '\u00A7',
  6301.         uml: '\u00A8',
  6302.         copy: '\u00A9',
  6303.         ordf: '\u00AA',
  6304.         laquo: '\u00AB',
  6305.         not: '\u00AC',
  6306.         shy: '\u00AD',
  6307.         reg: '\u00AE',
  6308.         macr: '\u00AF',
  6309.         deg: '\u00B0',
  6310.         plusmn: '\u00B1',
  6311.         sup2: '\u00B2',
  6312.         sup3: '\u00B3',
  6313.         acute: '\u00B4',
  6314.         micro: '\u00B5',
  6315.         para: '\u00B6',
  6316.         middot: '\u00B7',
  6317.         cedil: '\u00B8',
  6318.         sup1: '\u00B9',
  6319.         ordm: '\u00BA',
  6320.         raquo: '\u00BB',
  6321.         frac14: '\u00BC',
  6322.         frac12: '\u00BD',
  6323.         frac34: '\u00BE',
  6324.         iquest: '\u00BF',
  6325.         Agrave: '\u00C0',
  6326.         Aacute: '\u00C1',
  6327.         Acirc: '\u00C2',
  6328.         Atilde: '\u00C3',
  6329.         Auml: '\u00C4',
  6330.         Aring: '\u00C5',
  6331.         AElig: '\u00C6',
  6332.         Ccedil: '\u00C7',
  6333.         Egrave: '\u00C8',
  6334.         Eacute: '\u00C9',
  6335.         Ecirc: '\u00CA',
  6336.         Euml: '\u00CB',
  6337.         Igrave: '\u00CC',
  6338.         Iacute: '\u00CD',
  6339.         Icirc: '\u00CE',
  6340.         Iuml: '\u00CF',
  6341.         ETH: '\u00D0',
  6342.         Ntilde: '\u00D1',
  6343.         Ograve: '\u00D2',
  6344.         Oacute: '\u00D3',
  6345.         Ocirc: '\u00D4',
  6346.         Otilde: '\u00D5',
  6347.         Ouml: '\u00D6',
  6348.         times: '\u00D7',
  6349.         Oslash: '\u00D8',
  6350.         Ugrave: '\u00D9',
  6351.         Uacute: '\u00DA',
  6352.         Ucirc: '\u00DB',
  6353.         Uuml: '\u00DC',
  6354.         Yacute: '\u00DD',
  6355.         THORN: '\u00DE',
  6356.         szlig: '\u00DF',
  6357.         agrave: '\u00E0',
  6358.         aacute: '\u00E1',
  6359.         acirc: '\u00E2',
  6360.         atilde: '\u00E3',
  6361.         auml: '\u00E4',
  6362.         aring: '\u00E5',
  6363.         aelig: '\u00E6',
  6364.         ccedil: '\u00E7',
  6365.         egrave: '\u00E8',
  6366.         eacute: '\u00E9',
  6367.         ecirc: '\u00EA',
  6368.         euml: '\u00EB',
  6369.         igrave: '\u00EC',
  6370.         iacute: '\u00ED',
  6371.         icirc: '\u00EE',
  6372.         iuml: '\u00EF',
  6373.         eth: '\u00F0',
  6374.         ntilde: '\u00F1',
  6375.         ograve: '\u00F2',
  6376.         oacute: '\u00F3',
  6377.         ocirc: '\u00F4',
  6378.         otilde: '\u00F5',
  6379.         ouml: '\u00F6',
  6380.         divide: '\u00F7',
  6381.         oslash: '\u00F8',
  6382.         ugrave: '\u00F9',
  6383.         uacute: '\u00FA',
  6384.         ucirc: '\u00FB',
  6385.         uuml: '\u00FC',
  6386.         yacute: '\u00FD',
  6387.         thorn: '\u00FE',
  6388.         yuml: '\u00FF',
  6389.         OElig: '\u0152',
  6390.         oelig: '\u0153',
  6391.         Scaron: '\u0160',
  6392.         scaron: '\u0161',
  6393.         Yuml: '\u0178',
  6394.         fnof: '\u0192',
  6395.         circ: '\u02C6',
  6396.         tilde: '\u02DC',
  6397.         Alpha: '\u0391',
  6398.         Beta: '\u0392',
  6399.         Gamma: '\u0393',
  6400.         Delta: '\u0394',
  6401.         Epsilon: '\u0395',
  6402.         Zeta: '\u0396',
  6403.         Eta: '\u0397',
  6404.         Theta: '\u0398',
  6405.         Iota: '\u0399',
  6406.         Kappa: '\u039A',
  6407.         Lambda: '\u039B',
  6408.         Mu: '\u039C',
  6409.         Nu: '\u039D',
  6410.         Xi: '\u039E',
  6411.         Omicron: '\u039F',
  6412.         Pi: '\u03A0',
  6413.         Rho: '\u03A1',
  6414.         Sigma: '\u03A3',
  6415.         Tau: '\u03A4',
  6416.         Upsilon: '\u03A5',
  6417.         Phi: '\u03A6',
  6418.         Chi: '\u03A7',
  6419.         Psi: '\u03A8',
  6420.         Omega: '\u03A9',
  6421.         alpha: '\u03B1',
  6422.         beta: '\u03B2',
  6423.         gamma: '\u03B3',
  6424.         delta: '\u03B4',
  6425.         epsilon: '\u03B5',
  6426.         zeta: '\u03B6',
  6427.         eta: '\u03B7',
  6428.         theta: '\u03B8',
  6429.         iota: '\u03B9',
  6430.         kappa: '\u03BA',
  6431.         lambda: '\u03BB',
  6432.         mu: '\u03BC',
  6433.         nu: '\u03BD',
  6434.         xi: '\u03BE',
  6435.         omicron: '\u03BF',
  6436.         pi: '\u03C0',
  6437.         rho: '\u03C1',
  6438.         sigmaf: '\u03C2',
  6439.         sigma: '\u03C3',
  6440.         tau: '\u03C4',
  6441.         upsilon: '\u03C5',
  6442.         phi: '\u03C6',
  6443.         chi: '\u03C7',
  6444.         psi: '\u03C8',
  6445.         omega: '\u03C9',
  6446.         thetasym: '\u03D1',
  6447.         upsih: '\u03D2',
  6448.         piv: '\u03D6',
  6449.         ensp: '\u2002',
  6450.         emsp: '\u2003',
  6451.         thinsp: '\u2009',
  6452.         zwnj: '\u200C',
  6453.         zwj: '\u200D',
  6454.         lrm: '\u200E',
  6455.         rlm: '\u200F',
  6456.         ndash: '\u2013',
  6457.         mdash: '\u2014',
  6458.         lsquo: '\u2018',
  6459.         rsquo: '\u2019',
  6460.         sbquo: '\u201A',
  6461.         ldquo: '\u201C',
  6462.         rdquo: '\u201D',
  6463.         bdquo: '\u201E',
  6464.         dagger: '\u2020',
  6465.         Dagger: '\u2021',
  6466.         bull: '\u2022',
  6467.         hellip: '\u2026',
  6468.         permil: '\u2030',
  6469.         prime: '\u2032',
  6470.         Prime: '\u2033',
  6471.         lsaquo: '\u2039',
  6472.         rsaquo: '\u203A',
  6473.         oline: '\u203E',
  6474.         frasl: '\u2044',
  6475.         euro: '\u20AC',
  6476.         image: '\u2111',
  6477.         weierp: '\u2118',
  6478.         real: '\u211C',
  6479.         trade: '\u2122',
  6480.         alefsym: '\u2135',
  6481.         larr: '\u2190',
  6482.         uarr: '\u2191',
  6483.         rarr: '\u2192',
  6484.         darr: '\u2193',
  6485.         harr: '\u2194',
  6486.         crarr: '\u21B5',
  6487.         lArr: '\u21D0',
  6488.         uArr: '\u21D1',
  6489.         rArr: '\u21D2',
  6490.         dArr: '\u21D3',
  6491.         hArr: '\u21D4',
  6492.         forall: '\u2200',
  6493.         part: '\u2202',
  6494.         exist: '\u2203',
  6495.         empty: '\u2205',
  6496.         nabla: '\u2207',
  6497.         isin: '\u2208',
  6498.         notin: '\u2209',
  6499.         ni: '\u220B',
  6500.         prod: '\u220F',
  6501.         sum: '\u2211',
  6502.         minus: '\u2212',
  6503.         lowast: '\u2217',
  6504.         radic: '\u221A',
  6505.         prop: '\u221D',
  6506.         infin: '\u221E',
  6507.         ang: '\u2220',
  6508.         and: '\u2227',
  6509.         or: '\u2228',
  6510.         cap: '\u2229',
  6511.         cup: '\u222A',
  6512.         int: '\u222B',
  6513.         there4: '\u2234',
  6514.         sim: '\u223C',
  6515.         cong: '\u2245',
  6516.         asymp: '\u2248',
  6517.         ne: '\u2260',
  6518.         equiv: '\u2261',
  6519.         le: '\u2264',
  6520.         ge: '\u2265',
  6521.         sub: '\u2282',
  6522.         sup: '\u2283',
  6523.         nsub: '\u2284',
  6524.         sube: '\u2286',
  6525.         supe: '\u2287',
  6526.         oplus: '\u2295',
  6527.         otimes: '\u2297',
  6528.         perp: '\u22A5',
  6529.         sdot: '\u22C5',
  6530.         lceil: '\u2308',
  6531.         rceil: '\u2309',
  6532.         lfloor: '\u230A',
  6533.         rfloor: '\u230B',
  6534.         loz: '\u25CA',
  6535.         spades: '\u2660',
  6536.         clubs: '\u2663',
  6537.         hearts: '\u2665',
  6538.         diams: '\u2666',
  6539.         lang: '\u27E8',
  6540.         rang: '\u27E9'
  6541.     };
  6542.  
  6543.  
  6544. /***/ },
  6545. /* 15 */
  6546. /***/ function(module, exports, __webpack_require__) {
  6547.  
  6548.     "use strict";
  6549.     Object.defineProperty(exports, "__esModule", { value: true });
  6550.     var error_handler_1 = __webpack_require__(10);
  6551.     var scanner_1 = __webpack_require__(12);
  6552.     var token_1 = __webpack_require__(13);
  6553.     var Reader = (function () {
  6554.         function Reader() {
  6555.             this.values = [];
  6556.             this.curly = this.paren = -1;
  6557.         }
  6558.         // A function following one of those tokens is an expression.
  6559.         Reader.prototype.beforeFunctionExpression = function (t) {
  6560.             return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
  6561.                 'return', 'case', 'delete', 'throw', 'void',
  6562.                 // assignment operators
  6563.                 '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',
  6564.                 '&=', '|=', '^=', ',',
  6565.                 // binary/unary operators
  6566.                 '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
  6567.                 '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
  6568.                 '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
  6569.         };
  6570.         // Determine if forward slash (/) is an operator or part of a regular expression
  6571.         // https://github.com/mozilla/sweet.js/wiki/design
  6572.         Reader.prototype.isRegexStart = function () {
  6573.             var previous = this.values[this.values.length - 1];
  6574.             var regex = (previous !== null);
  6575.             switch (previous) {
  6576.                 case 'this':
  6577.                 case ']':
  6578.                     regex = false;
  6579.                     break;
  6580.                 case ')':
  6581.                     var keyword = this.values[this.paren - 1];
  6582.                     regex = (keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with');
  6583.                     break;
  6584.                 case '}':
  6585.                     // Dividing a function by anything makes little sense,
  6586.                     // but we have to check for that.
  6587.                     regex = false;
  6588.                     if (this.values[this.curly - 3] === 'function') {
  6589.                         // Anonymous function, e.g. function(){} /42
  6590.                         var check = this.values[this.curly - 4];
  6591.                         regex = check ? !this.beforeFunctionExpression(check) : false;
  6592.                     }
  6593.                     else if (this.values[this.curly - 4] === 'function') {
  6594.                         // Named function, e.g. function f(){} /42/
  6595.                         var check = this.values[this.curly - 5];
  6596.                         regex = check ? !this.beforeFunctionExpression(check) : true;
  6597.                     }
  6598.                     break;
  6599.                 default:
  6600.                     break;
  6601.             }
  6602.             return regex;
  6603.         };
  6604.         Reader.prototype.push = function (token) {
  6605.             if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {
  6606.                 if (token.value === '{') {
  6607.                     this.curly = this.values.length;
  6608.                 }
  6609.                 else if (token.value === '(') {
  6610.                     this.paren = this.values.length;
  6611.                 }
  6612.                 this.values.push(token.value);
  6613.             }
  6614.             else {
  6615.                 this.values.push(null);
  6616.             }
  6617.         };
  6618.         return Reader;
  6619.     }());
  6620.     var Tokenizer = (function () {
  6621.         function Tokenizer(code, config) {
  6622.             this.errorHandler = new error_handler_1.ErrorHandler();
  6623.             this.errorHandler.tolerant = config ? (typeof config.tolerant === 'boolean' && config.tolerant) : false;
  6624.             this.scanner = new scanner_1.Scanner(code, this.errorHandler);
  6625.             this.scanner.trackComment = config ? (typeof config.comment === 'boolean' && config.comment) : false;
  6626.             this.trackRange = config ? (typeof config.range === 'boolean' && config.range) : false;
  6627.             this.trackLoc = config ? (typeof config.loc === 'boolean' && config.loc) : false;
  6628.             this.buffer = [];
  6629.             this.reader = new Reader();
  6630.         }
  6631.         Tokenizer.prototype.errors = function () {
  6632.             return this.errorHandler.errors;
  6633.         };
  6634.         Tokenizer.prototype.getNextToken = function () {
  6635.             if (this.buffer.length === 0) {
  6636.                 var comments = this.scanner.scanComments();
  6637.                 if (this.scanner.trackComment) {
  6638.                     for (var i = 0; i < comments.length; ++i) {
  6639.                         var e = comments[i];
  6640.                         var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
  6641.                         var comment = {
  6642.                             type: e.multiLine ? 'BlockComment' : 'LineComment',
  6643.                             value: value
  6644.                         };
  6645.                         if (this.trackRange) {
  6646.                             comment.range = e.range;
  6647.                         }
  6648.                         if (this.trackLoc) {
  6649.                             comment.loc = e.loc;
  6650.                         }
  6651.                         this.buffer.push(comment);
  6652.                     }
  6653.                 }
  6654.                 if (!this.scanner.eof()) {
  6655.                     var loc = void 0;
  6656.                     if (this.trackLoc) {
  6657.                         loc = {
  6658.                             start: {
  6659.                                 line: this.scanner.lineNumber,
  6660.                                 column: this.scanner.index - this.scanner.lineStart
  6661.                             },
  6662.                             end: {}
  6663.                         };
  6664.                     }
  6665.                     var startRegex = (this.scanner.source[this.scanner.index] === '/') && this.reader.isRegexStart();
  6666.                     var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();
  6667.                     this.reader.push(token);
  6668.                     var entry = {
  6669.                         type: token_1.TokenName[token.type],
  6670.                         value: this.scanner.source.slice(token.start, token.end)
  6671.                     };
  6672.                     if (this.trackRange) {
  6673.                         entry.range = [token.start, token.end];
  6674.                     }
  6675.                     if (this.trackLoc) {
  6676.                         loc.end = {
  6677.                             line: this.scanner.lineNumber,
  6678.                             column: this.scanner.index - this.scanner.lineStart
  6679.                         };
  6680.                         entry.loc = loc;
  6681.                     }
  6682.                     if (token.type === 9 /* RegularExpression */) {
  6683.                         var pattern = token.pattern;
  6684.                         var flags = token.flags;
  6685.                         entry.regex = { pattern: pattern, flags: flags };
  6686.                     }
  6687.                     this.buffer.push(entry);
  6688.                 }
  6689.             }
  6690.             return this.buffer.shift();
  6691.         };
  6692.         return Tokenizer;
  6693.     }());
  6694.     exports.Tokenizer = Tokenizer;
  6695.  
  6696.  
  6697. /***/ }
  6698. /******/ ])
  6699. });
  6700. ;
  6701.  
  6702. // JSHINT has some GPL Compatability issues, so we are faking it out and using esprima for validation
  6703. // Based on https://github.com/jquery/esprima/blob/gh-pages/demo/validate.js which is MIT licensed
  6704.  
  6705. var fakeJSHINT = new function() {
  6706.     var syntax, errors;
  6707.     var that = this;
  6708.     this.data = [];
  6709.     this.convertError = function( error ){
  6710.         return {
  6711.             line: error.lineNumber,
  6712.             character: error.column,
  6713.             reason: error.description,
  6714.             code: 'E'
  6715.         };
  6716.     };
  6717.     this.parse = function( code ){
  6718.         try {
  6719.             syntax = window.esprima.parse(code, { tolerant: true, loc: true });
  6720.             errors = syntax.errors;
  6721.             if ( errors.length > 0 ) {
  6722.                 for ( var i = 0; i < errors.length; i++) {
  6723.                     var error = errors[i];
  6724.                     that.data.push( that.convertError( error ) );
  6725.                 }
  6726.             } else {
  6727.                 that.data = [];
  6728.             }
  6729.         } catch (e) {
  6730.             that.data.push( that.convertError( e ) );
  6731.         }
  6732.     };
  6733. };
  6734.  
  6735. window.JSHINT = function( text ){
  6736.     fakeJSHINT.parse( text );
  6737. };
  6738. window.JSHINT.data = function(){
  6739.     return {
  6740.         errors: fakeJSHINT.data
  6741.     };
  6742. };
  6743.  
  6744.  
  6745.