.config/coc/extensions/node_modules/coc-prettier/node_modules/esprima/dist/esprima.js

   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.1';
 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. '&#123;'
 519                                 numeric = (ch === '#');
 520                                 break;
 521                             case 3:
 522                                 if (numeric) {
 523                                     // e.g. '&#x41;'
 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. '&#x41;' 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, lastLineStart) {
2114                 if (lastLineStart === void 0) { lastLineStart = 0; }
2115                 var column = token.start - token.lineStart;
2116                 var line = token.lineNumber;
2117                 if (column < 0) {
2118                     column += lastLineStart;
2119                     line--;
2120                 }
2121                 return {
2122                     index: token.start,
2123                     line: line,
2124                     column: column
2125                 };
2126             };
2127             Parser.prototype.finalize = function (marker, node) {
2128                 if (this.config.range) {
2129                     node.range = [marker.index, this.lastMarker.index];
2130                 }
2131                 if (this.config.loc) {
2132                     node.loc = {
2133                         start: {
2134                             line: marker.line,
2135                             column: marker.column,
2136                         },
2137                         end: {
2138                             line: this.lastMarker.line,
2139                             column: this.lastMarker.column
2140                         }
2141                     };
2142                     if (this.config.source) {
2143                         node.loc.source = this.config.source;
2144                     }
2145                 }
2146                 if (this.delegate) {
2147                     var metadata = {
2148                         start: {
2149                             line: marker.line,
2150                             column: marker.column,
2151                             offset: marker.index
2152                         },
2153                         end: {
2154                             line: this.lastMarker.line,
2155                             column: this.lastMarker.column,
2156                             offset: this.lastMarker.index
2157                         }
2158                     };
2159                     this.delegate(node, metadata);
2160                 }
2161                 return node;
2162             };
2163             // Expect the next token to match the specified punctuator.
2164             // If not, an exception will be thrown.
2165             Parser.prototype.expect = function (value) {
2166                 var token = this.nextToken();
2167                 if (token.type !== 7 /* Punctuator */ || token.value !== value) {
2168                     this.throwUnexpectedToken(token);
2169                 }
2170             };
2171             // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
2172             Parser.prototype.expectCommaSeparator = function () {
2173                 if (this.config.tolerant) {
2174                     var token = this.lookahead;
2175                     if (token.type === 7 /* Punctuator */ && token.value === ',') {
2176                         this.nextToken();
2177                     }
2178                     else if (token.type === 7 /* Punctuator */ && token.value === ';') {
2179                         this.nextToken();
2180                         this.tolerateUnexpectedToken(token);
2181                     }
2182                     else {
2183                         this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
2184                     }
2185                 }
2186                 else {
2187                     this.expect(',');
2188                 }
2189             };
2190             // Expect the next token to match the specified keyword.
2191             // If not, an exception will be thrown.
2192             Parser.prototype.expectKeyword = function (keyword) {
2193                 var token = this.nextToken();
2194                 if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
2195                     this.throwUnexpectedToken(token);
2196                 }
2197             };
2198             // Return true if the next token matches the specified punctuator.
2199             Parser.prototype.match = function (value) {
2200                 return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
2201             };
2202             // Return true if the next token matches the specified keyword
2203             Parser.prototype.matchKeyword = function (keyword) {
2204                 return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
2205             };
2206             // Return true if the next token matches the specified contextual keyword
2207             // (where an identifier is sometimes a keyword depending on the context)
2208             Parser.prototype.matchContextualKeyword = function (keyword) {
2209                 return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
2210             };
2211             // Return true if the next token is an assignment operator
2212             Parser.prototype.matchAssign = function () {
2213                 if (this.lookahead.type !== 7 /* Punctuator */) {
2214                     return false;
2215                 }
2216                 var op = this.lookahead.value;
2217                 return op === '=' ||
2218                     op === '*=' ||
2219                     op === '**=' ||
2220                     op === '/=' ||
2221                     op === '%=' ||
2222                     op === '+=' ||
2223                     op === '-=' ||
2224                     op === '<<=' ||
2225                     op === '>>=' ||
2226                     op === '>>>=' ||
2227                     op === '&=' ||
2228                     op === '^=' ||
2229                     op === '|=';
2230             };
2231             // Cover grammar support.
2232             //
2233             // When an assignment expression position starts with an left parenthesis, the determination of the type
2234             // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
2235             // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
2236             //
2237             // There are three productions that can be parsed in a parentheses pair that needs to be determined
2238             // after the outermost pair is closed. They are:
2239             //
2240             //   1. AssignmentExpression
2241             //   2. BindingElements
2242             //   3. AssignmentTargets
2243             //
2244             // In order to avoid exponential backtracking, we use two flags to denote if the production can be
2245             // binding element or assignment target.
2246             //
2247             // The three productions have the relationship:
2248             //
2249             //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
2250             //
2251             // with a single exception that CoverInitializedName when used directly in an Expression, generates
2252             // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
2253             // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
2254             //
2255             // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
2256             // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
2257             // the CoverInitializedName check is conducted.
2258             //
2259             // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
2260             // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
2261             // pattern. The CoverInitializedName check is deferred.
2262             Parser.prototype.isolateCoverGrammar = function (parseFunction) {
2263                 var previousIsBindingElement = this.context.isBindingElement;
2264                 var previousIsAssignmentTarget = this.context.isAssignmentTarget;
2265                 var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
2266                 this.context.isBindingElement = true;
2267                 this.context.isAssignmentTarget = true;
2268                 this.context.firstCoverInitializedNameError = null;
2269                 var result = parseFunction.call(this);
2270                 if (this.context.firstCoverInitializedNameError !== null) {
2271                     this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
2272                 }
2273                 this.context.isBindingElement = previousIsBindingElement;
2274                 this.context.isAssignmentTarget = previousIsAssignmentTarget;
2275                 this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
2276                 return result;
2277             };
2278             Parser.prototype.inheritCoverGrammar = function (parseFunction) {
2279                 var previousIsBindingElement = this.context.isBindingElement;
2280                 var previousIsAssignmentTarget = this.context.isAssignmentTarget;
2281                 var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
2282                 this.context.isBindingElement = true;
2283                 this.context.isAssignmentTarget = true;
2284                 this.context.firstCoverInitializedNameError = null;
2285                 var result = parseFunction.call(this);
2286                 this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
2287                 this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
2288                 this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
2289                 return result;
2290             };
2291             Parser.prototype.consumeSemicolon = function () {
2292                 if (this.match(';')) {
2293                     this.nextToken();
2294                 }
2295                 else if (!this.hasLineTerminator) {
2296                     if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
2297                         this.throwUnexpectedToken(this.lookahead);
2298                     }
2299                     this.lastMarker.index = this.startMarker.index;
2300                     this.lastMarker.line = this.startMarker.line;
2301                     this.lastMarker.column = this.startMarker.column;
2302                 }
2303             };
2304             // https://tc39.github.io/ecma262/#sec-primary-expression
2305             Parser.prototype.parsePrimaryExpression = function () {
2306                 var node = this.createNode();
2307                 var expr;
2308                 var token, raw;
2309                 switch (this.lookahead.type) {
2310                     case 3 /* Identifier */:
2311                         if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
2312                             this.tolerateUnexpectedToken(this.lookahead);
2313                         }
2314                         expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
2315                         break;
2316                     case 6 /* NumericLiteral */:
2317                     case 8 /* StringLiteral */:
2318                         if (this.context.strict && this.lookahead.octal) {
2319                             this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
2320                         }
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, raw));
2326                         break;
2327                     case 1 /* BooleanLiteral */:
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(token.value === 'true', raw));
2333                         break;
2334                     case 5 /* NullLiteral */:
2335                         this.context.isAssignmentTarget = false;
2336                         this.context.isBindingElement = false;
2337                         token = this.nextToken();
2338                         raw = this.getTokenRaw(token);
2339                         expr = this.finalize(node, new Node.Literal(null, raw));
2340                         break;
2341                     case 10 /* Template */:
2342                         expr = this.parseTemplateLiteral();
2343                         break;
2344                     case 7 /* Punctuator */:
2345                         switch (this.lookahead.value) {
2346                             case '(':
2347                                 this.context.isBindingElement = false;
2348                                 expr = this.inheritCoverGrammar(this.parseGroupExpression);
2349                                 break;
2350                             case '[':
2351                                 expr = this.inheritCoverGrammar(this.parseArrayInitializer);
2352                                 break;
2353                             case '{':
2354                                 expr = this.inheritCoverGrammar(this.parseObjectInitializer);
2355                                 break;
2356                             case '/':
2357                             case '/=':
2358                                 this.context.isAssignmentTarget = false;
2359                                 this.context.isBindingElement = false;
2360                                 this.scanner.index = this.startMarker.index;
2361                                 token = this.nextRegexToken();
2362                                 raw = this.getTokenRaw(token);
2363                                 expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
2364                                 break;
2365                             default:
2366                                 expr = this.throwUnexpectedToken(this.nextToken());
2367                         }
2368                         break;
2369                     case 4 /* Keyword */:
2370                         if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
2371                             expr = this.parseIdentifierName();
2372                         }
2373                         else if (!this.context.strict && this.matchKeyword('let')) {
2374                             expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
2375                         }
2376                         else {
2377                             this.context.isAssignmentTarget = false;
2378                             this.context.isBindingElement = false;
2379                             if (this.matchKeyword('function')) {
2380                                 expr = this.parseFunctionExpression();
2381                             }
2382                             else if (this.matchKeyword('this')) {
2383                                 this.nextToken();
2384                                 expr = this.finalize(node, new Node.ThisExpression());
2385                             }
2386                             else if (this.matchKeyword('class')) {
2387                                 expr = this.parseClassExpression();
2388                             }
2389                             else {
2390                                 expr = this.throwUnexpectedToken(this.nextToken());
2391                             }
2392                         }
2393                         break;
2394                     default:
2395                         expr = this.throwUnexpectedToken(this.nextToken());
2396                 }
2397                 return expr;
2398             };
2399             // https://tc39.github.io/ecma262/#sec-array-initializer
2400             Parser.prototype.parseSpreadElement = function () {
2401                 var node = this.createNode();
2402                 this.expect('...');
2403                 var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
2404                 return this.finalize(node, new Node.SpreadElement(arg));
2405             };
2406             Parser.prototype.parseArrayInitializer = function () {
2407                 var node = this.createNode();
2408                 var elements = [];
2409                 this.expect('[');
2410                 while (!this.match(']')) {
2411                     if (this.match(',')) {
2412                         this.nextToken();
2413                         elements.push(null);
2414                     }
2415                     else if (this.match('...')) {
2416                         var element = this.parseSpreadElement();
2417                         if (!this.match(']')) {
2418                             this.context.isAssignmentTarget = false;
2419                             this.context.isBindingElement = false;
2420                             this.expect(',');
2421                         }
2422                         elements.push(element);
2423                     }
2424                     else {
2425                         elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
2426                         if (!this.match(']')) {
2427                             this.expect(',');
2428                         }
2429                     }
2430                 }
2431                 this.expect(']');
2432                 return this.finalize(node, new Node.ArrayExpression(elements));
2433             };
2434             // https://tc39.github.io/ecma262/#sec-object-initializer
2435             Parser.prototype.parsePropertyMethod = function (params) {
2436                 this.context.isAssignmentTarget = false;
2437                 this.context.isBindingElement = false;
2438                 var previousStrict = this.context.strict;
2439                 var previousAllowStrictDirective = this.context.allowStrictDirective;
2440                 this.context.allowStrictDirective = params.simple;
2441                 var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
2442                 if (this.context.strict && params.firstRestricted) {
2443                     this.tolerateUnexpectedToken(params.firstRestricted, params.message);
2444                 }
2445                 if (this.context.strict && params.stricted) {
2446                     this.tolerateUnexpectedToken(params.stricted, params.message);
2447                 }
2448                 this.context.strict = previousStrict;
2449                 this.context.allowStrictDirective = previousAllowStrictDirective;
2450                 return body;
2451             };
2452             Parser.prototype.parsePropertyMethodFunction = function () {
2453                 var isGenerator = false;
2454                 var node = this.createNode();
2455                 var previousAllowYield = this.context.allowYield;
2456                 this.context.allowYield = true;
2457                 var params = this.parseFormalParameters();
2458                 var method = this.parsePropertyMethod(params);
2459                 this.context.allowYield = previousAllowYield;
2460                 return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
2461             };
2462             Parser.prototype.parsePropertyMethodAsyncFunction = function () {
2463                 var node = this.createNode();
2464                 var previousAllowYield = this.context.allowYield;
2465                 var previousAwait = this.context.await;
2466                 this.context.allowYield = false;
2467                 this.context.await = true;
2468                 var params = this.parseFormalParameters();
2469                 var method = this.parsePropertyMethod(params);
2470                 this.context.allowYield = previousAllowYield;
2471                 this.context.await = previousAwait;
2472                 return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
2473             };
2474             Parser.prototype.parseObjectPropertyKey = function () {
2475                 var node = this.createNode();
2476                 var token = this.nextToken();
2477                 var key;
2478                 switch (token.type) {
2479                     case 8 /* StringLiteral */:
2480                     case 6 /* NumericLiteral */:
2481                         if (this.context.strict && token.octal) {
2482                             this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
2483                         }
2484                         var raw = this.getTokenRaw(token);
2485                         key = this.finalize(node, new Node.Literal(token.value, raw));
2486                         break;
2487                     case 3 /* Identifier */:
2488                     case 1 /* BooleanLiteral */:
2489                     case 5 /* NullLiteral */:
2490                     case 4 /* Keyword */:
2491                         key = this.finalize(node, new Node.Identifier(token.value));
2492                         break;
2493                     case 7 /* Punctuator */:
2494                         if (token.value === '[') {
2495                             key = this.isolateCoverGrammar(this.parseAssignmentExpression);
2496                             this.expect(']');
2497                         }
2498                         else {
2499                             key = this.throwUnexpectedToken(token);
2500                         }
2501                         break;
2502                     default:
2503                         key = this.throwUnexpectedToken(token);
2504                 }
2505                 return key;
2506             };
2507             Parser.prototype.isPropertyKey = function (key, value) {
2508                 return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
2509                     (key.type === syntax_1.Syntax.Literal && key.value === value);
2510             };
2511             Parser.prototype.parseObjectProperty = function (hasProto) {
2512                 var node = this.createNode();
2513                 var token = this.lookahead;
2514                 var kind;
2515                 var key = null;
2516                 var value = null;
2517                 var computed = false;
2518                 var method = false;
2519                 var shorthand = false;
2520                 var isAsync = false;
2521                 if (token.type === 3 /* Identifier */) {
2522                     var id = token.value;
2523                     this.nextToken();
2524                     computed = this.match('[');
2525                     isAsync = !this.hasLineTerminator && (id === 'async') &&
2526                         !this.match(':') && !this.match('(') && !this.match('*') && !this.match(',');
2527                     key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));
2528                 }
2529                 else if (this.match('*')) {
2530                     this.nextToken();
2531                 }
2532                 else {
2533                     computed = this.match('[');
2534                     key = this.parseObjectPropertyKey();
2535                 }
2536                 var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
2537                 if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
2538                     kind = 'get';
2539                     computed = this.match('[');
2540                     key = this.parseObjectPropertyKey();
2541                     this.context.allowYield = false;
2542                     value = this.parseGetterMethod();
2543                 }
2544                 else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
2545                     kind = 'set';
2546                     computed = this.match('[');
2547                     key = this.parseObjectPropertyKey();
2548                     value = this.parseSetterMethod();
2549                 }
2550                 else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
2551                     kind = 'init';
2552                     computed = this.match('[');
2553                     key = this.parseObjectPropertyKey();
2554                     value = this.parseGeneratorMethod();
2555                     method = true;
2556                 }
2557                 else {
2558                     if (!key) {
2559                         this.throwUnexpectedToken(this.lookahead);
2560                     }
2561                     kind = 'init';
2562                     if (this.match(':') && !isAsync) {
2563                         if (!computed && this.isPropertyKey(key, '__proto__')) {
2564                             if (hasProto.value) {
2565                                 this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
2566                             }
2567                             hasProto.value = true;
2568                         }
2569                         this.nextToken();
2570                         value = this.inheritCoverGrammar(this.parseAssignmentExpression);
2571                     }
2572                     else if (this.match('(')) {
2573                         value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
2574                         method = true;
2575                     }
2576                     else if (token.type === 3 /* Identifier */) {
2577                         var id = this.finalize(node, new Node.Identifier(token.value));
2578                         if (this.match('=')) {
2579                             this.context.firstCoverInitializedNameError = this.lookahead;
2580                             this.nextToken();
2581                             shorthand = true;
2582                             var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
2583                             value = this.finalize(node, new Node.AssignmentPattern(id, init));
2584                         }
2585                         else {
2586                             shorthand = true;
2587                             value = id;
2588                         }
2589                     }
2590                     else {
2591                         this.throwUnexpectedToken(this.nextToken());
2592                     }
2593                 }
2594                 return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
2595             };
2596             Parser.prototype.parseObjectInitializer = function () {
2597                 var node = this.createNode();
2598                 this.expect('{');
2599                 var properties = [];
2600                 var hasProto = { value: false };
2601                 while (!this.match('}')) {
2602                     properties.push(this.parseObjectProperty(hasProto));
2603                     if (!this.match('}')) {
2604                         this.expectCommaSeparator();
2605                     }
2606                 }
2607                 this.expect('}');
2608                 return this.finalize(node, new Node.ObjectExpression(properties));
2609             };
2610             // https://tc39.github.io/ecma262/#sec-template-literals
2611             Parser.prototype.parseTemplateHead = function () {
2612                 assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
2613                 var node = this.createNode();
2614                 var token = this.nextToken();
2615                 var raw = token.value;
2616                 var cooked = token.cooked;
2617                 return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
2618             };
2619             Parser.prototype.parseTemplateElement = function () {
2620                 if (this.lookahead.type !== 10 /* Template */) {
2621                     this.throwUnexpectedToken();
2622                 }
2623                 var node = this.createNode();
2624                 var token = this.nextToken();
2625                 var raw = token.value;
2626                 var cooked = token.cooked;
2627                 return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
2628             };
2629             Parser.prototype.parseTemplateLiteral = function () {
2630                 var node = this.createNode();
2631                 var expressions = [];
2632                 var quasis = [];
2633                 var quasi = this.parseTemplateHead();
2634                 quasis.push(quasi);
2635                 while (!quasi.tail) {
2636                     expressions.push(this.parseExpression());
2637                     quasi = this.parseTemplateElement();
2638                     quasis.push(quasi);
2639                 }
2640                 return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
2641             };
2642             // https://tc39.github.io/ecma262/#sec-grouping-operator
2643             Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
2644                 switch (expr.type) {
2645                     case syntax_1.Syntax.Identifier:
2646                     case syntax_1.Syntax.MemberExpression:
2647                     case syntax_1.Syntax.RestElement:
2648                     case syntax_1.Syntax.AssignmentPattern:
2649                         break;
2650                     case syntax_1.Syntax.SpreadElement:
2651                         expr.type = syntax_1.Syntax.RestElement;
2652                         this.reinterpretExpressionAsPattern(expr.argument);
2653                         break;
2654                     case syntax_1.Syntax.ArrayExpression:
2655                         expr.type = syntax_1.Syntax.ArrayPattern;
2656                         for (var i = 0; i < expr.elements.length; i++) {
2657                             if (expr.elements[i] !== null) {
2658                                 this.reinterpretExpressionAsPattern(expr.elements[i]);
2659                             }
2660                         }
2661                         break;
2662                     case syntax_1.Syntax.ObjectExpression:
2663                         expr.type = syntax_1.Syntax.ObjectPattern;
2664                         for (var i = 0; i < expr.properties.length; i++) {
2665                             this.reinterpretExpressionAsPattern(expr.properties[i].value);
2666                         }
2667                         break;
2668                     case syntax_1.Syntax.AssignmentExpression:
2669                         expr.type = syntax_1.Syntax.AssignmentPattern;
2670                         delete expr.operator;
2671                         this.reinterpretExpressionAsPattern(expr.left);
2672                         break;
2673                     default:
2674                         // Allow other node type for tolerant parsing.
2675                         break;
2676                 }
2677             };
2678             Parser.prototype.parseGroupExpression = function () {
2679                 var expr;
2680                 this.expect('(');
2681                 if (this.match(')')) {
2682                     this.nextToken();
2683                     if (!this.match('=>')) {
2684                         this.expect('=>');
2685                     }
2686                     expr = {
2687                         type: ArrowParameterPlaceHolder,
2688                         params: [],
2689                         async: false
2690                     };
2691                 }
2692                 else {
2693                     var startToken = this.lookahead;
2694                     var params = [];
2695                     if (this.match('...')) {
2696                         expr = this.parseRestElement(params);
2697                         this.expect(')');
2698                         if (!this.match('=>')) {
2699                             this.expect('=>');
2700                         }
2701                         expr = {
2702                             type: ArrowParameterPlaceHolder,
2703                             params: [expr],
2704                             async: false
2705                         };
2706                     }
2707                     else {
2708                         var arrow = false;
2709                         this.context.isBindingElement = true;
2710                         expr = this.inheritCoverGrammar(this.parseAssignmentExpression);
2711                         if (this.match(',')) {
2712                             var expressions = [];
2713                             this.context.isAssignmentTarget = false;
2714                             expressions.push(expr);
2715                             while (this.lookahead.type !== 2 /* EOF */) {
2716                                 if (!this.match(',')) {
2717                                     break;
2718                                 }
2719                                 this.nextToken();
2720                                 if (this.match(')')) {
2721                                     this.nextToken();
2722                                     for (var i = 0; i < expressions.length; i++) {
2723                                         this.reinterpretExpressionAsPattern(expressions[i]);
2724                                     }
2725                                     arrow = true;
2726                                     expr = {
2727                                         type: ArrowParameterPlaceHolder,
2728                                         params: expressions,
2729                                         async: false
2730                                     };
2731                                 }
2732                                 else if (this.match('...')) {
2733                                     if (!this.context.isBindingElement) {
2734                                         this.throwUnexpectedToken(this.lookahead);
2735                                     }
2736                                     expressions.push(this.parseRestElement(params));
2737                                     this.expect(')');
2738                                     if (!this.match('=>')) {
2739                                         this.expect('=>');
2740                                     }
2741                                     this.context.isBindingElement = false;
2742                                     for (var i = 0; i < expressions.length; i++) {
2743                                         this.reinterpretExpressionAsPattern(expressions[i]);
2744                                     }
2745                                     arrow = true;
2746                                     expr = {
2747                                         type: ArrowParameterPlaceHolder,
2748                                         params: expressions,
2749                                         async: false
2750                                     };
2751                                 }
2752                                 else {
2753                                     expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
2754                                 }
2755                                 if (arrow) {
2756                                     break;
2757                                 }
2758                             }
2759                             if (!arrow) {
2760                                 expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
2761                             }
2762                         }
2763                         if (!arrow) {
2764                             this.expect(')');
2765                             if (this.match('=>')) {
2766                                 if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
2767                                     arrow = true;
2768                                     expr = {
2769                                         type: ArrowParameterPlaceHolder,
2770                                         params: [expr],
2771                                         async: false
2772                                     };
2773                                 }
2774                                 if (!arrow) {
2775                                     if (!this.context.isBindingElement) {
2776                                         this.throwUnexpectedToken(this.lookahead);
2777                                     }
2778                                     if (expr.type === syntax_1.Syntax.SequenceExpression) {
2779                                         for (var i = 0; i < expr.expressions.length; i++) {
2780                                             this.reinterpretExpressionAsPattern(expr.expressions[i]);
2781                                         }
2782                                     }
2783                                     else {
2784                                         this.reinterpretExpressionAsPattern(expr);
2785                                     }
2786                                     var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);
2787                                     expr = {
2788                                         type: ArrowParameterPlaceHolder,
2789                                         params: parameters,
2790                                         async: false
2791                                     };
2792                                 }
2793                             }
2794                             this.context.isBindingElement = false;
2795                         }
2796                     }
2797                 }
2798                 return expr;
2799             };
2800             // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
2801             Parser.prototype.parseArguments = function () {
2802                 this.expect('(');
2803                 var args = [];
2804                 if (!this.match(')')) {
2805                     while (true) {
2806                         var expr = this.match('...') ? this.parseSpreadElement() :
2807                             this.isolateCoverGrammar(this.parseAssignmentExpression);
2808                         args.push(expr);
2809                         if (this.match(')')) {
2810                             break;
2811                         }
2812                         this.expectCommaSeparator();
2813                         if (this.match(')')) {
2814                             break;
2815                         }
2816                     }
2817                 }
2818                 this.expect(')');
2819                 return args;
2820             };
2821             Parser.prototype.isIdentifierName = function (token) {
2822                 return token.type === 3 /* Identifier */ ||
2823                     token.type === 4 /* Keyword */ ||
2824                     token.type === 1 /* BooleanLiteral */ ||
2825                     token.type === 5 /* NullLiteral */;
2826             };
2827             Parser.prototype.parseIdentifierName = function () {
2828                 var node = this.createNode();
2829                 var token = this.nextToken();
2830                 if (!this.isIdentifierName(token)) {
2831                     this.throwUnexpectedToken(token);
2832                 }
2833                 return this.finalize(node, new Node.Identifier(token.value));
2834             };
2835             Parser.prototype.parseNewExpression = function () {
2836                 var node = this.createNode();
2837                 var id = this.parseIdentifierName();
2838                 assert_1.assert(id.name === 'new', 'New expression must start with `new`');
2839                 var expr;
2840                 if (this.match('.')) {
2841                     this.nextToken();
2842                     if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {
2843                         var property = this.parseIdentifierName();
2844                         expr = new Node.MetaProperty(id, property);
2845                     }
2846                     else {
2847                         this.throwUnexpectedToken(this.lookahead);
2848                     }
2849                 }
2850                 else {
2851                     var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
2852                     var args = this.match('(') ? this.parseArguments() : [];
2853                     expr = new Node.NewExpression(callee, args);
2854                     this.context.isAssignmentTarget = false;
2855                     this.context.isBindingElement = false;
2856                 }
2857                 return this.finalize(node, expr);
2858             };
2859             Parser.prototype.parseAsyncArgument = function () {
2860                 var arg = this.parseAssignmentExpression();
2861                 this.context.firstCoverInitializedNameError = null;
2862                 return arg;
2863             };
2864             Parser.prototype.parseAsyncArguments = function () {
2865                 this.expect('(');
2866                 var args = [];
2867                 if (!this.match(')')) {
2868                     while (true) {
2869                         var expr = this.match('...') ? this.parseSpreadElement() :
2870                             this.isolateCoverGrammar(this.parseAsyncArgument);
2871                         args.push(expr);
2872                         if (this.match(')')) {
2873                             break;
2874                         }
2875                         this.expectCommaSeparator();
2876                         if (this.match(')')) {
2877                             break;
2878                         }
2879                     }
2880                 }
2881                 this.expect(')');
2882                 return args;
2883             };
2884             Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
2885                 var startToken = this.lookahead;
2886                 var maybeAsync = this.matchContextualKeyword('async');
2887                 var previousAllowIn = this.context.allowIn;
2888                 this.context.allowIn = true;
2889                 var expr;
2890                 if (this.matchKeyword('super') && this.context.inFunctionBody) {
2891                     expr = this.createNode();
2892                     this.nextToken();
2893                     expr = this.finalize(expr, new Node.Super());
2894                     if (!this.match('(') && !this.match('.') && !this.match('[')) {
2895                         this.throwUnexpectedToken(this.lookahead);
2896                     }
2897                 }
2898                 else {
2899                     expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
2900                 }
2901                 while (true) {
2902                     if (this.match('.')) {
2903                         this.context.isBindingElement = false;
2904                         this.context.isAssignmentTarget = true;
2905                         this.expect('.');
2906                         var property = this.parseIdentifierName();
2907                         expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
2908                     }
2909                     else if (this.match('(')) {
2910                         var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);
2911                         this.context.isBindingElement = false;
2912                         this.context.isAssignmentTarget = false;
2913                         var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
2914                         expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
2915                         if (asyncArrow && this.match('=>')) {
2916                             for (var i = 0; i < args.length; ++i) {
2917                                 this.reinterpretExpressionAsPattern(args[i]);
2918                             }
2919                             expr = {
2920                                 type: ArrowParameterPlaceHolder,
2921                                 params: args,
2922                                 async: true
2923                             };
2924                         }
2925                     }
2926                     else if (this.match('[')) {
2927                         this.context.isBindingElement = false;
2928                         this.context.isAssignmentTarget = true;
2929                         this.expect('[');
2930                         var property = this.isolateCoverGrammar(this.parseExpression);
2931                         this.expect(']');
2932                         expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
2933                     }
2934                     else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
2935                         var quasi = this.parseTemplateLiteral();
2936                         expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
2937                     }
2938                     else {
2939                         break;
2940                     }
2941                 }
2942                 this.context.allowIn = previousAllowIn;
2943                 return expr;
2944             };
2945             Parser.prototype.parseSuper = function () {
2946                 var node = this.createNode();
2947                 this.expectKeyword('super');
2948                 if (!this.match('[') && !this.match('.')) {
2949                     this.throwUnexpectedToken(this.lookahead);
2950                 }
2951                 return this.finalize(node, new Node.Super());
2952             };
2953             Parser.prototype.parseLeftHandSideExpression = function () {
2954                 assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
2955                 var node = this.startNode(this.lookahead);
2956                 var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
2957                     this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
2958                 while (true) {
2959                     if (this.match('[')) {
2960                         this.context.isBindingElement = false;
2961                         this.context.isAssignmentTarget = true;
2962                         this.expect('[');
2963                         var property = this.isolateCoverGrammar(this.parseExpression);
2964                         this.expect(']');
2965                         expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
2966                     }
2967                     else if (this.match('.')) {
2968                         this.context.isBindingElement = false;
2969                         this.context.isAssignmentTarget = true;
2970                         this.expect('.');
2971                         var property = this.parseIdentifierName();
2972                         expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
2973                     }
2974                     else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
2975                         var quasi = this.parseTemplateLiteral();
2976                         expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
2977                     }
2978                     else {
2979                         break;
2980                     }
2981                 }
2982                 return expr;
2983             };
2984             // https://tc39.github.io/ecma262/#sec-update-expressions
2985             Parser.prototype.parseUpdateExpression = function () {
2986                 var expr;
2987                 var startToken = this.lookahead;
2988                 if (this.match('++') || this.match('--')) {
2989                     var node = this.startNode(startToken);
2990                     var token = this.nextToken();
2991                     expr = this.inheritCoverGrammar(this.parseUnaryExpression);
2992                     if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
2993                         this.tolerateError(messages_1.Messages.StrictLHSPrefix);
2994                     }
2995                     if (!this.context.isAssignmentTarget) {
2996                         this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
2997                     }
2998                     var prefix = true;
2999                     expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
3000                     this.context.isAssignmentTarget = false;
3001                     this.context.isBindingElement = false;
3002                 }
3003                 else {
3004                     expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
3005                     if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {
3006                         if (this.match('++') || this.match('--')) {
3007                             if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
3008                                 this.tolerateError(messages_1.Messages.StrictLHSPostfix);
3009                             }
3010                             if (!this.context.isAssignmentTarget) {
3011                                 this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
3012                             }
3013                             this.context.isAssignmentTarget = false;
3014                             this.context.isBindingElement = false;
3015                             var operator = this.nextToken().value;
3016                             var prefix = false;
3017                             expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
3018                         }
3019                     }
3020                 }
3021                 return expr;
3022             };
3023             // https://tc39.github.io/ecma262/#sec-unary-operators
3024             Parser.prototype.parseAwaitExpression = function () {
3025                 var node = this.createNode();
3026                 this.nextToken();
3027                 var argument = this.parseUnaryExpression();
3028                 return this.finalize(node, new Node.AwaitExpression(argument));
3029             };
3030             Parser.prototype.parseUnaryExpression = function () {
3031                 var expr;
3032                 if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
3033                     this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
3034                     var node = this.startNode(this.lookahead);
3035                     var token = this.nextToken();
3036                     expr = this.inheritCoverGrammar(this.parseUnaryExpression);
3037                     expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));
3038                     if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
3039                         this.tolerateError(messages_1.Messages.StrictDelete);
3040                     }
3041                     this.context.isAssignmentTarget = false;
3042                     this.context.isBindingElement = false;
3043                 }
3044                 else if (this.context.await && this.matchContextualKeyword('await')) {
3045                     expr = this.parseAwaitExpression();
3046                 }
3047                 else {
3048                     expr = this.parseUpdateExpression();
3049                 }
3050                 return expr;
3051             };
3052             Parser.prototype.parseExponentiationExpression = function () {
3053                 var startToken = this.lookahead;
3054                 var expr = this.inheritCoverGrammar(this.parseUnaryExpression);
3055                 if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
3056                     this.nextToken();
3057                     this.context.isAssignmentTarget = false;
3058                     this.context.isBindingElement = false;
3059                     var left = expr;
3060                     var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
3061                     expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
3062                 }
3063                 return expr;
3064             };
3065             // https://tc39.github.io/ecma262/#sec-exp-operator
3066             // https://tc39.github.io/ecma262/#sec-multiplicative-operators
3067             // https://tc39.github.io/ecma262/#sec-additive-operators
3068             // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
3069             // https://tc39.github.io/ecma262/#sec-relational-operators
3070             // https://tc39.github.io/ecma262/#sec-equality-operators
3071             // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
3072             // https://tc39.github.io/ecma262/#sec-binary-logical-operators
3073             Parser.prototype.binaryPrecedence = function (token) {
3074                 var op = token.value;
3075                 var precedence;
3076                 if (token.type === 7 /* Punctuator */) {
3077                     precedence = this.operatorPrecedence[op] || 0;
3078                 }
3079                 else if (token.type === 4 /* Keyword */) {
3080                     precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
3081                 }
3082                 else {
3083                     precedence = 0;
3084                 }
3085                 return precedence;
3086             };
3087             Parser.prototype.parseBinaryExpression = function () {
3088                 var startToken = this.lookahead;
3089                 var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
3090                 var token = this.lookahead;
3091                 var prec = this.binaryPrecedence(token);
3092                 if (prec > 0) {
3093                     this.nextToken();
3094                     this.context.isAssignmentTarget = false;
3095                     this.context.isBindingElement = false;
3096                     var markers = [startToken, this.lookahead];
3097                     var left = expr;
3098                     var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
3099                     var stack = [left, token.value, right];
3100                     var precedences = [prec];
3101                     while (true) {
3102                         prec = this.binaryPrecedence(this.lookahead);
3103                         if (prec <= 0) {
3104                             break;
3105                         }
3106                         // Reduce: make a binary expression from the three topmost entries.
3107                         while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {
3108                             right = stack.pop();
3109                             var operator = stack.pop();
3110                             precedences.pop();
3111                             left = stack.pop();
3112                             markers.pop();
3113                             var node = this.startNode(markers[markers.length - 1]);
3114                             stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
3115                         }
3116                         // Shift.
3117                         stack.push(this.nextToken().value);
3118                         precedences.push(prec);
3119                         markers.push(this.lookahead);
3120                         stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
3121                     }
3122                     // Final reduce to clean-up the stack.
3123                     var i = stack.length - 1;
3124                     expr = stack[i];
3125                     var lastMarker = markers.pop();
3126                     while (i > 1) {
3127                         var marker = markers.pop();
3128                         var lastLineStart = lastMarker && lastMarker.lineStart;
3129                         var node = this.startNode(marker, lastLineStart);
3130                         var operator = stack[i - 1];
3131                         expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
3132                         i -= 2;
3133                         lastMarker = marker;
3134                     }
3135                 }
3136                 return expr;
3137             };
3138             // https://tc39.github.io/ecma262/#sec-conditional-operator
3139             Parser.prototype.parseConditionalExpression = function () {
3140                 var startToken = this.lookahead;
3141                 var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
3142                 if (this.match('?')) {
3143                     this.nextToken();
3144                     var previousAllowIn = this.context.allowIn;
3145                     this.context.allowIn = true;
3146                     var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
3147                     this.context.allowIn = previousAllowIn;
3148                     this.expect(':');
3149                     var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
3150                     expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
3151                     this.context.isAssignmentTarget = false;
3152                     this.context.isBindingElement = false;
3153                 }
3154                 return expr;
3155             };
3156             // https://tc39.github.io/ecma262/#sec-assignment-operators
3157             Parser.prototype.checkPatternParam = function (options, param) {
3158                 switch (param.type) {
3159                     case syntax_1.Syntax.Identifier:
3160                         this.validateParam(options, param, param.name);
3161                         break;
3162                     case syntax_1.Syntax.RestElement:
3163                         this.checkPatternParam(options, param.argument);
3164                         break;
3165                     case syntax_1.Syntax.AssignmentPattern:
3166                         this.checkPatternParam(options, param.left);
3167                         break;
3168                     case syntax_1.Syntax.ArrayPattern:
3169                         for (var i = 0; i < param.elements.length; i++) {
3170                             if (param.elements[i] !== null) {
3171                                 this.checkPatternParam(options, param.elements[i]);
3172                             }
3173                         }
3174                         break;
3175                     case syntax_1.Syntax.ObjectPattern:
3176                         for (var i = 0; i < param.properties.length; i++) {
3177                             this.checkPatternParam(options, param.properties[i].value);
3178                         }
3179                         break;
3180                     default:
3181                         break;
3182                 }
3183                 options.simple = options.simple && (param instanceof Node.Identifier);
3184             };
3185             Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
3186                 var params = [expr];
3187                 var options;
3188                 var asyncArrow = false;
3189                 switch (expr.type) {
3190                     case syntax_1.Syntax.Identifier:
3191                         break;
3192                     case ArrowParameterPlaceHolder:
3193                         params = expr.params;
3194                         asyncArrow = expr.async;
3195                         break;
3196                     default:
3197                         return null;
3198                 }
3199                 options = {
3200                     simple: true,
3201                     paramSet: {}
3202                 };
3203                 for (var i = 0; i < params.length; ++i) {
3204                     var param = params[i];
3205                     if (param.type === syntax_1.Syntax.AssignmentPattern) {
3206                         if (param.right.type === syntax_1.Syntax.YieldExpression) {
3207                             if (param.right.argument) {
3208                                 this.throwUnexpectedToken(this.lookahead);
3209                             }
3210                             param.right.type = syntax_1.Syntax.Identifier;
3211                             param.right.name = 'yield';
3212                             delete param.right.argument;
3213                             delete param.right.delegate;
3214                         }
3215                     }
3216                     else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
3217                         this.throwUnexpectedToken(this.lookahead);
3218                     }
3219                     this.checkPatternParam(options, param);
3220                     params[i] = param;
3221                 }
3222                 if (this.context.strict || !this.context.allowYield) {
3223                     for (var i = 0; i < params.length; ++i) {
3224                         var param = params[i];
3225                         if (param.type === syntax_1.Syntax.YieldExpression) {
3226                             this.throwUnexpectedToken(this.lookahead);
3227                         }
3228                     }
3229                 }
3230                 if (options.message === messages_1.Messages.StrictParamDupe) {
3231                     var token = this.context.strict ? options.stricted : options.firstRestricted;
3232                     this.throwUnexpectedToken(token, options.message);
3233                 }
3234                 return {
3235                     simple: options.simple,
3236                     params: params,
3237                     stricted: options.stricted,
3238                     firstRestricted: options.firstRestricted,
3239                     message: options.message
3240                 };
3241             };
3242             Parser.prototype.parseAssignmentExpression = function () {
3243                 var expr;
3244                 if (!this.context.allowYield && this.matchKeyword('yield')) {
3245                     expr = this.parseYieldExpression();
3246                 }
3247                 else {
3248                     var startToken = this.lookahead;
3249                     var token = startToken;
3250                     expr = this.parseConditionalExpression();
3251                     if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') {
3252                         if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) {
3253                             var arg = this.parsePrimaryExpression();
3254                             this.reinterpretExpressionAsPattern(arg);
3255                             expr = {
3256                                 type: ArrowParameterPlaceHolder,
3257                                 params: [arg],
3258                                 async: true
3259                             };
3260                         }
3261                     }
3262                     if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
3263                         // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
3264                         this.context.isAssignmentTarget = false;
3265                         this.context.isBindingElement = false;
3266                         var isAsync = expr.async;
3267                         var list = this.reinterpretAsCoverFormalsList(expr);
3268                         if (list) {
3269                             if (this.hasLineTerminator) {
3270                                 this.tolerateUnexpectedToken(this.lookahead);
3271                             }
3272                             this.context.firstCoverInitializedNameError = null;
3273                             var previousStrict = this.context.strict;
3274                             var previousAllowStrictDirective = this.context.allowStrictDirective;
3275                             this.context.allowStrictDirective = list.simple;
3276                             var previousAllowYield = this.context.allowYield;
3277                             var previousAwait = this.context.await;
3278                             this.context.allowYield = true;
3279                             this.context.await = isAsync;
3280                             var node = this.startNode(startToken);
3281                             this.expect('=>');
3282                             var body = void 0;
3283                             if (this.match('{')) {
3284                                 var previousAllowIn = this.context.allowIn;
3285                                 this.context.allowIn = true;
3286                                 body = this.parseFunctionSourceElements();
3287                                 this.context.allowIn = previousAllowIn;
3288                             }
3289                             else {
3290                                 body = this.isolateCoverGrammar(this.parseAssignmentExpression);
3291                             }
3292                             var expression = body.type !== syntax_1.Syntax.BlockStatement;
3293                             if (this.context.strict && list.firstRestricted) {
3294                                 this.throwUnexpectedToken(list.firstRestricted, list.message);
3295                             }
3296                             if (this.context.strict && list.stricted) {
3297                                 this.tolerateUnexpectedToken(list.stricted, list.message);
3298                             }
3299                             expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
3300                                 this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
3301                             this.context.strict = previousStrict;
3302                             this.context.allowStrictDirective = previousAllowStrictDirective;
3303                             this.context.allowYield = previousAllowYield;
3304                             this.context.await = previousAwait;
3305                         }
3306                     }
3307                     else {
3308                         if (this.matchAssign()) {
3309                             if (!this.context.isAssignmentTarget) {
3310                                 this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
3311                             }
3312                             if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
3313                                 var id = expr;
3314                                 if (this.scanner.isRestrictedWord(id.name)) {
3315                                     this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
3316                                 }
3317                                 if (this.scanner.isStrictModeReservedWord(id.name)) {
3318                                     this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
3319                                 }
3320                             }
3321                             if (!this.match('=')) {
3322                                 this.context.isAssignmentTarget = false;
3323                                 this.context.isBindingElement = false;
3324                             }
3325                             else {
3326                                 this.reinterpretExpressionAsPattern(expr);
3327                             }
3328                             token = this.nextToken();
3329                             var operator = token.value;
3330                             var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
3331                             expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
3332                             this.context.firstCoverInitializedNameError = null;
3333                         }
3334                     }
3335                 }
3336                 return expr;
3337             };
3338             // https://tc39.github.io/ecma262/#sec-comma-operator
3339             Parser.prototype.parseExpression = function () {
3340                 var startToken = this.lookahead;
3341                 var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
3342                 if (this.match(',')) {
3343                     var expressions = [];
3344                     expressions.push(expr);
3345                     while (this.lookahead.type !== 2 /* EOF */) {
3346                         if (!this.match(',')) {
3347                             break;
3348                         }
3349                         this.nextToken();
3350                         expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
3351                     }
3352                     expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
3353                 }
3354                 return expr;
3355             };
3356             // https://tc39.github.io/ecma262/#sec-block
3357             Parser.prototype.parseStatementListItem = function () {
3358                 var statement;
3359                 this.context.isAssignmentTarget = true;
3360                 this.context.isBindingElement = true;
3361                 if (this.lookahead.type === 4 /* Keyword */) {
3362                     switch (this.lookahead.value) {
3363                         case 'export':
3364                             if (!this.context.isModule) {
3365                                 this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
3366                             }
3367                             statement = this.parseExportDeclaration();
3368                             break;
3369                         case 'import':
3370                             if (!this.context.isModule) {
3371                                 this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
3372                             }
3373                             statement = this.parseImportDeclaration();
3374                             break;
3375                         case 'const':
3376                             statement = this.parseLexicalDeclaration({ inFor: false });
3377                             break;
3378                         case 'function':
3379                             statement = this.parseFunctionDeclaration();
3380                             break;
3381                         case 'class':
3382                             statement = this.parseClassDeclaration();
3383                             break;
3384                         case 'let':
3385                             statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();
3386                             break;
3387                         default:
3388                             statement = this.parseStatement();
3389                             break;
3390                     }
3391                 }
3392                 else {
3393                     statement = this.parseStatement();
3394                 }
3395                 return statement;
3396             };
3397             Parser.prototype.parseBlock = function () {
3398                 var node = this.createNode();
3399                 this.expect('{');
3400                 var block = [];
3401                 while (true) {
3402                     if (this.match('}')) {
3403                         break;
3404                     }
3405                     block.push(this.parseStatementListItem());
3406                 }
3407                 this.expect('}');
3408                 return this.finalize(node, new Node.BlockStatement(block));
3409             };
3410             // https://tc39.github.io/ecma262/#sec-let-and-const-declarations
3411             Parser.prototype.parseLexicalBinding = function (kind, options) {
3412                 var node = this.createNode();
3413                 var params = [];
3414                 var id = this.parsePattern(params, kind);
3415                 if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
3416                     if (this.scanner.isRestrictedWord(id.name)) {
3417                         this.tolerateError(messages_1.Messages.StrictVarName);
3418                     }
3419                 }
3420                 var init = null;
3421                 if (kind === 'const') {
3422                     if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
3423                         if (this.match('=')) {
3424                             this.nextToken();
3425                             init = this.isolateCoverGrammar(this.parseAssignmentExpression);
3426                         }
3427                         else {
3428                             this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
3429                         }
3430                     }
3431                 }
3432                 else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {
3433                     this.expect('=');
3434                     init = this.isolateCoverGrammar(this.parseAssignmentExpression);
3435                 }
3436                 return this.finalize(node, new Node.VariableDeclarator(id, init));
3437             };
3438             Parser.prototype.parseBindingList = function (kind, options) {
3439                 var list = [this.parseLexicalBinding(kind, options)];
3440                 while (this.match(',')) {
3441                     this.nextToken();
3442                     list.push(this.parseLexicalBinding(kind, options));
3443                 }
3444                 return list;
3445             };
3446             Parser.prototype.isLexicalDeclaration = function () {
3447                 var state = this.scanner.saveState();
3448                 this.scanner.scanComments();
3449                 var next = this.scanner.lex();
3450                 this.scanner.restoreState(state);
3451                 return (next.type === 3 /* Identifier */) ||
3452                     (next.type === 7 /* Punctuator */ && next.value === '[') ||
3453                     (next.type === 7 /* Punctuator */ && next.value === '{') ||
3454                     (next.type === 4 /* Keyword */ && next.value === 'let') ||
3455                     (next.type === 4 /* Keyword */ && next.value === 'yield');
3456             };
3457             Parser.prototype.parseLexicalDeclaration = function (options) {
3458                 var node = this.createNode();
3459                 var kind = this.nextToken().value;
3460                 assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
3461                 var declarations = this.parseBindingList(kind, options);
3462                 this.consumeSemicolon();
3463                 return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
3464             };
3465             // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
3466             Parser.prototype.parseBindingRestElement = function (params, kind) {
3467                 var node = this.createNode();
3468                 this.expect('...');
3469                 var arg = this.parsePattern(params, kind);
3470                 return this.finalize(node, new Node.RestElement(arg));
3471             };
3472             Parser.prototype.parseArrayPattern = function (params, kind) {
3473                 var node = this.createNode();
3474                 this.expect('[');
3475                 var elements = [];
3476                 while (!this.match(']')) {
3477                     if (this.match(',')) {
3478                         this.nextToken();
3479                         elements.push(null);
3480                     }
3481                     else {
3482                         if (this.match('...')) {
3483                             elements.push(this.parseBindingRestElement(params, kind));
3484                             break;
3485                         }
3486                         else {
3487                             elements.push(this.parsePatternWithDefault(params, kind));
3488                         }
3489                         if (!this.match(']')) {
3490                             this.expect(',');
3491                         }
3492                     }
3493                 }
3494                 this.expect(']');
3495                 return this.finalize(node, new Node.ArrayPattern(elements));
3496             };
3497             Parser.prototype.parsePropertyPattern = function (params, kind) {
3498                 var node = this.createNode();
3499                 var computed = false;
3500                 var shorthand = false;
3501                 var method = false;
3502                 var key;
3503                 var value;
3504                 if (this.lookahead.type === 3 /* Identifier */) {
3505                     var keyToken = this.lookahead;
3506                     key = this.parseVariableIdentifier();
3507                     var init = this.finalize(node, new Node.Identifier(keyToken.value));
3508                     if (this.match('=')) {
3509                         params.push(keyToken);
3510                         shorthand = true;
3511                         this.nextToken();
3512                         var expr = this.parseAssignmentExpression();
3513                         value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
3514                     }
3515                     else if (!this.match(':')) {
3516                         params.push(keyToken);
3517                         shorthand = true;
3518                         value = init;
3519                     }
3520                     else {
3521                         this.expect(':');
3522                         value = this.parsePatternWithDefault(params, kind);
3523                     }
3524                 }
3525                 else {
3526                     computed = this.match('[');
3527                     key = this.parseObjectPropertyKey();
3528                     this.expect(':');
3529                     value = this.parsePatternWithDefault(params, kind);
3530                 }
3531                 return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
3532             };
3533             Parser.prototype.parseObjectPattern = function (params, kind) {
3534                 var node = this.createNode();
3535                 var properties = [];
3536                 this.expect('{');
3537                 while (!this.match('}')) {
3538                     properties.push(this.parsePropertyPattern(params, kind));
3539                     if (!this.match('}')) {
3540                         this.expect(',');
3541                     }
3542                 }
3543                 this.expect('}');
3544                 return this.finalize(node, new Node.ObjectPattern(properties));
3545             };
3546             Parser.prototype.parsePattern = function (params, kind) {
3547                 var pattern;
3548                 if (this.match('[')) {
3549                     pattern = this.parseArrayPattern(params, kind);
3550                 }
3551                 else if (this.match('{')) {
3552                     pattern = this.parseObjectPattern(params, kind);
3553                 }
3554                 else {
3555                     if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
3556                         this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
3557                     }
3558                     params.push(this.lookahead);
3559                     pattern = this.parseVariableIdentifier(kind);
3560                 }
3561                 return pattern;
3562             };
3563             Parser.prototype.parsePatternWithDefault = function (params, kind) {
3564                 var startToken = this.lookahead;
3565                 var pattern = this.parsePattern(params, kind);
3566                 if (this.match('=')) {
3567                     this.nextToken();
3568                     var previousAllowYield = this.context.allowYield;
3569                     this.context.allowYield = true;
3570                     var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
3571                     this.context.allowYield = previousAllowYield;
3572                     pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
3573                 }
3574                 return pattern;
3575             };
3576             // https://tc39.github.io/ecma262/#sec-variable-statement
3577             Parser.prototype.parseVariableIdentifier = function (kind) {
3578                 var node = this.createNode();
3579                 var token = this.nextToken();
3580                 if (token.type === 4 /* Keyword */ && token.value === 'yield') {
3581                     if (this.context.strict) {
3582                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
3583                     }
3584                     else if (!this.context.allowYield) {
3585                         this.throwUnexpectedToken(token);
3586                     }
3587                 }
3588                 else if (token.type !== 3 /* Identifier */) {
3589                     if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {
3590                         this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
3591                     }
3592                     else {
3593                         if (this.context.strict || token.value !== 'let' || kind !== 'var') {
3594                             this.throwUnexpectedToken(token);
3595                         }
3596                     }
3597                 }
3598                 else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {
3599                     this.tolerateUnexpectedToken(token);
3600                 }
3601                 return this.finalize(node, new Node.Identifier(token.value));
3602             };
3603             Parser.prototype.parseVariableDeclaration = function (options) {
3604                 var node = this.createNode();
3605                 var params = [];
3606                 var id = this.parsePattern(params, 'var');
3607                 if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
3608                     if (this.scanner.isRestrictedWord(id.name)) {
3609                         this.tolerateError(messages_1.Messages.StrictVarName);
3610                     }
3611                 }
3612                 var init = null;
3613                 if (this.match('=')) {
3614                     this.nextToken();
3615                     init = this.isolateCoverGrammar(this.parseAssignmentExpression);
3616                 }
3617                 else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
3618                     this.expect('=');
3619                 }
3620                 return this.finalize(node, new Node.VariableDeclarator(id, init));
3621             };
3622             Parser.prototype.parseVariableDeclarationList = function (options) {
3623                 var opt = { inFor: options.inFor };
3624                 var list = [];
3625                 list.push(this.parseVariableDeclaration(opt));
3626                 while (this.match(',')) {
3627                     this.nextToken();
3628                     list.push(this.parseVariableDeclaration(opt));
3629                 }
3630                 return list;
3631             };
3632             Parser.prototype.parseVariableStatement = function () {
3633                 var node = this.createNode();
3634                 this.expectKeyword('var');
3635                 var declarations = this.parseVariableDeclarationList({ inFor: false });
3636                 this.consumeSemicolon();
3637                 return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
3638             };
3639             // https://tc39.github.io/ecma262/#sec-empty-statement
3640             Parser.prototype.parseEmptyStatement = function () {
3641                 var node = this.createNode();
3642                 this.expect(';');
3643                 return this.finalize(node, new Node.EmptyStatement());
3644             };
3645             // https://tc39.github.io/ecma262/#sec-expression-statement
3646             Parser.prototype.parseExpressionStatement = function () {
3647                 var node = this.createNode();
3648                 var expr = this.parseExpression();
3649                 this.consumeSemicolon();
3650                 return this.finalize(node, new Node.ExpressionStatement(expr));
3651             };
3652             // https://tc39.github.io/ecma262/#sec-if-statement
3653             Parser.prototype.parseIfClause = function () {
3654                 if (this.context.strict && this.matchKeyword('function')) {
3655                     this.tolerateError(messages_1.Messages.StrictFunction);
3656                 }
3657                 return this.parseStatement();
3658             };
3659             Parser.prototype.parseIfStatement = function () {
3660                 var node = this.createNode();
3661                 var consequent;
3662                 var alternate = null;
3663                 this.expectKeyword('if');
3664                 this.expect('(');
3665                 var test = this.parseExpression();
3666                 if (!this.match(')') && this.config.tolerant) {
3667                     this.tolerateUnexpectedToken(this.nextToken());
3668                     consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
3669                 }
3670                 else {
3671                     this.expect(')');
3672                     consequent = this.parseIfClause();
3673                     if (this.matchKeyword('else')) {
3674                         this.nextToken();
3675                         alternate = this.parseIfClause();
3676                     }
3677                 }
3678                 return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
3679             };
3680             // https://tc39.github.io/ecma262/#sec-do-while-statement
3681             Parser.prototype.parseDoWhileStatement = function () {
3682                 var node = this.createNode();
3683                 this.expectKeyword('do');
3684                 var previousInIteration = this.context.inIteration;
3685                 this.context.inIteration = true;
3686                 var body = this.parseStatement();
3687                 this.context.inIteration = previousInIteration;
3688                 this.expectKeyword('while');
3689                 this.expect('(');
3690                 var test = this.parseExpression();
3691                 if (!this.match(')') && this.config.tolerant) {
3692                     this.tolerateUnexpectedToken(this.nextToken());
3693                 }
3694                 else {
3695                     this.expect(')');
3696                     if (this.match(';')) {
3697                         this.nextToken();
3698                     }
3699                 }
3700                 return this.finalize(node, new Node.DoWhileStatement(body, test));
3701             };
3702             // https://tc39.github.io/ecma262/#sec-while-statement
3703             Parser.prototype.parseWhileStatement = function () {
3704                 var node = this.createNode();
3705                 var body;
3706                 this.expectKeyword('while');
3707                 this.expect('(');
3708                 var test = this.parseExpression();
3709                 if (!this.match(')') && this.config.tolerant) {
3710                     this.tolerateUnexpectedToken(this.nextToken());
3711                     body = this.finalize(this.createNode(), new Node.EmptyStatement());
3712                 }
3713                 else {
3714                     this.expect(')');
3715                     var previousInIteration = this.context.inIteration;
3716                     this.context.inIteration = true;
3717                     body = this.parseStatement();
3718                     this.context.inIteration = previousInIteration;
3719                 }
3720                 return this.finalize(node, new Node.WhileStatement(test, body));
3721             };
3722             // https://tc39.github.io/ecma262/#sec-for-statement
3723             // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
3724             Parser.prototype.parseForStatement = function () {
3725                 var init = null;
3726                 var test = null;
3727                 var update = null;
3728                 var forIn = true;
3729                 var left, right;
3730                 var node = this.createNode();
3731                 this.expectKeyword('for');
3732                 this.expect('(');
3733                 if (this.match(';')) {
3734                     this.nextToken();
3735                 }
3736                 else {
3737                     if (this.matchKeyword('var')) {
3738                         init = this.createNode();
3739                         this.nextToken();
3740                         var previousAllowIn = this.context.allowIn;
3741                         this.context.allowIn = false;
3742                         var declarations = this.parseVariableDeclarationList({ inFor: true });
3743                         this.context.allowIn = previousAllowIn;
3744                         if (declarations.length === 1 && this.matchKeyword('in')) {
3745                             var decl = declarations[0];
3746                             if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
3747                                 this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
3748                             }
3749                             init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
3750                             this.nextToken();
3751                             left = init;
3752                             right = this.parseExpression();
3753                             init = null;
3754                         }
3755                         else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
3756                             init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
3757                             this.nextToken();
3758                             left = init;
3759                             right = this.parseAssignmentExpression();
3760                             init = null;
3761                             forIn = false;
3762                         }
3763                         else {
3764                             init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
3765                             this.expect(';');
3766                         }
3767                     }
3768                     else if (this.matchKeyword('const') || this.matchKeyword('let')) {
3769                         init = this.createNode();
3770                         var kind = this.nextToken().value;
3771                         if (!this.context.strict && this.lookahead.value === 'in') {
3772                             init = this.finalize(init, new Node.Identifier(kind));
3773                             this.nextToken();
3774                             left = init;
3775                             right = this.parseExpression();
3776                             init = null;
3777                         }
3778                         else {
3779                             var previousAllowIn = this.context.allowIn;
3780                             this.context.allowIn = false;
3781                             var declarations = this.parseBindingList(kind, { inFor: true });
3782                             this.context.allowIn = previousAllowIn;
3783                             if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
3784                                 init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
3785                                 this.nextToken();
3786                                 left = init;
3787                                 right = this.parseExpression();
3788                                 init = null;
3789                             }
3790                             else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
3791                                 init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
3792                                 this.nextToken();
3793                                 left = init;
3794                                 right = this.parseAssignmentExpression();
3795                                 init = null;
3796                                 forIn = false;
3797                             }
3798                             else {
3799                                 this.consumeSemicolon();
3800                                 init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
3801                             }
3802                         }
3803                     }
3804                     else {
3805                         var initStartToken = this.lookahead;
3806                         var previousAllowIn = this.context.allowIn;
3807                         this.context.allowIn = false;
3808                         init = this.inheritCoverGrammar(this.parseAssignmentExpression);
3809                         this.context.allowIn = previousAllowIn;
3810                         if (this.matchKeyword('in')) {
3811                             if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
3812                                 this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
3813                             }
3814                             this.nextToken();
3815                             this.reinterpretExpressionAsPattern(init);
3816                             left = init;
3817                             right = this.parseExpression();
3818                             init = null;
3819                         }
3820                         else if (this.matchContextualKeyword('of')) {
3821                             if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
3822                                 this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
3823                             }
3824                             this.nextToken();
3825                             this.reinterpretExpressionAsPattern(init);
3826                             left = init;
3827                             right = this.parseAssignmentExpression();
3828                             init = null;
3829                             forIn = false;
3830                         }
3831                         else {
3832                             if (this.match(',')) {
3833                                 var initSeq = [init];
3834                                 while (this.match(',')) {
3835                                     this.nextToken();
3836                                     initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
3837                                 }
3838                                 init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
3839                             }
3840                             this.expect(';');
3841                         }
3842                     }
3843                 }
3844                 if (typeof left === 'undefined') {
3845                     if (!this.match(';')) {
3846                         test = this.parseExpression();
3847                     }
3848                     this.expect(';');
3849                     if (!this.match(')')) {
3850                         update = this.parseExpression();
3851                     }
3852                 }
3853                 var body;
3854                 if (!this.match(')') && this.config.tolerant) {
3855                     this.tolerateUnexpectedToken(this.nextToken());
3856                     body = this.finalize(this.createNode(), new Node.EmptyStatement());
3857                 }
3858                 else {
3859                     this.expect(')');
3860                     var previousInIteration = this.context.inIteration;
3861                     this.context.inIteration = true;
3862                     body = this.isolateCoverGrammar(this.parseStatement);
3863                     this.context.inIteration = previousInIteration;
3864                 }
3865                 return (typeof left === 'undefined') ?
3866                     this.finalize(node, new Node.ForStatement(init, test, update, body)) :
3867                     forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
3868                         this.finalize(node, new Node.ForOfStatement(left, right, body));
3869             };
3870             // https://tc39.github.io/ecma262/#sec-continue-statement
3871             Parser.prototype.parseContinueStatement = function () {
3872                 var node = this.createNode();
3873                 this.expectKeyword('continue');
3874                 var label = null;
3875                 if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
3876                     var id = this.parseVariableIdentifier();
3877                     label = id;
3878                     var key = '$' + id.name;
3879                     if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
3880                         this.throwError(messages_1.Messages.UnknownLabel, id.name);
3881                     }
3882                 }
3883                 this.consumeSemicolon();
3884                 if (label === null && !this.context.inIteration) {
3885                     this.throwError(messages_1.Messages.IllegalContinue);
3886                 }
3887                 return this.finalize(node, new Node.ContinueStatement(label));
3888             };
3889             // https://tc39.github.io/ecma262/#sec-break-statement
3890             Parser.prototype.parseBreakStatement = function () {
3891                 var node = this.createNode();
3892                 this.expectKeyword('break');
3893                 var label = null;
3894                 if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
3895                     var id = this.parseVariableIdentifier();
3896                     var key = '$' + id.name;
3897                     if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
3898                         this.throwError(messages_1.Messages.UnknownLabel, id.name);
3899                     }
3900                     label = id;
3901                 }
3902                 this.consumeSemicolon();
3903                 if (label === null && !this.context.inIteration && !this.context.inSwitch) {
3904                     this.throwError(messages_1.Messages.IllegalBreak);
3905                 }
3906                 return this.finalize(node, new Node.BreakStatement(label));
3907             };
3908             // https://tc39.github.io/ecma262/#sec-return-statement
3909             Parser.prototype.parseReturnStatement = function () {
3910                 if (!this.context.inFunctionBody) {
3911                     this.tolerateError(messages_1.Messages.IllegalReturn);
3912                 }
3913                 var node = this.createNode();
3914                 this.expectKeyword('return');
3915                 var hasArgument = (!this.match(';') && !this.match('}') &&
3916                     !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */) ||
3917                     this.lookahead.type === 8 /* StringLiteral */ ||
3918                     this.lookahead.type === 10 /* Template */;
3919                 var argument = hasArgument ? this.parseExpression() : null;
3920                 this.consumeSemicolon();
3921                 return this.finalize(node, new Node.ReturnStatement(argument));
3922             };
3923             // https://tc39.github.io/ecma262/#sec-with-statement
3924             Parser.prototype.parseWithStatement = function () {
3925                 if (this.context.strict) {
3926                     this.tolerateError(messages_1.Messages.StrictModeWith);
3927                 }
3928                 var node = this.createNode();
3929                 var body;
3930                 this.expectKeyword('with');
3931                 this.expect('(');
3932                 var object = this.parseExpression();
3933                 if (!this.match(')') && this.config.tolerant) {
3934                     this.tolerateUnexpectedToken(this.nextToken());
3935                     body = this.finalize(this.createNode(), new Node.EmptyStatement());
3936                 }
3937                 else {
3938                     this.expect(')');
3939                     body = this.parseStatement();
3940                 }
3941                 return this.finalize(node, new Node.WithStatement(object, body));
3942             };
3943             // https://tc39.github.io/ecma262/#sec-switch-statement
3944             Parser.prototype.parseSwitchCase = function () {
3945                 var node = this.createNode();
3946                 var test;
3947                 if (this.matchKeyword('default')) {
3948                     this.nextToken();
3949                     test = null;
3950                 }
3951                 else {
3952                     this.expectKeyword('case');
3953                     test = this.parseExpression();
3954                 }
3955                 this.expect(':');
3956                 var consequent = [];
3957                 while (true) {
3958                     if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
3959                         break;
3960                     }
3961                     consequent.push(this.parseStatementListItem());
3962                 }
3963                 return this.finalize(node, new Node.SwitchCase(test, consequent));
3964             };
3965             Parser.prototype.parseSwitchStatement = function () {
3966                 var node = this.createNode();
3967                 this.expectKeyword('switch');
3968                 this.expect('(');
3969                 var discriminant = this.parseExpression();
3970                 this.expect(')');
3971                 var previousInSwitch = this.context.inSwitch;
3972                 this.context.inSwitch = true;
3973                 var cases = [];
3974                 var defaultFound = false;
3975                 this.expect('{');
3976                 while (true) {
3977                     if (this.match('}')) {
3978                         break;
3979                     }
3980                     var clause = this.parseSwitchCase();
3981                     if (clause.test === null) {
3982                         if (defaultFound) {
3983                             this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
3984                         }
3985                         defaultFound = true;
3986                     }
3987                     cases.push(clause);
3988                 }
3989                 this.expect('}');
3990                 this.context.inSwitch = previousInSwitch;
3991                 return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
3992             };
3993             // https://tc39.github.io/ecma262/#sec-labelled-statements
3994             Parser.prototype.parseLabelledStatement = function () {
3995                 var node = this.createNode();
3996                 var expr = this.parseExpression();
3997                 var statement;
3998                 if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
3999                     this.nextToken();
4000                     var id = expr;
4001                     var key = '$' + id.name;
4002                     if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
4003                         this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
4004                     }
4005                     this.context.labelSet[key] = true;
4006                     var body = void 0;
4007                     if (this.matchKeyword('class')) {
4008                         this.tolerateUnexpectedToken(this.lookahead);
4009                         body = this.parseClassDeclaration();
4010                     }
4011                     else if (this.matchKeyword('function')) {
4012                         var token = this.lookahead;
4013                         var declaration = this.parseFunctionDeclaration();
4014                         if (this.context.strict) {
4015                             this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
4016                         }
4017                         else if (declaration.generator) {
4018                             this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
4019                         }
4020                         body = declaration;
4021                     }
4022                     else {
4023                         body = this.parseStatement();
4024                     }
4025                     delete this.context.labelSet[key];
4026                     statement = new Node.LabeledStatement(id, body);
4027                 }
4028                 else {
4029                     this.consumeSemicolon();
4030                     statement = new Node.ExpressionStatement(expr);
4031                 }
4032                 return this.finalize(node, statement);
4033             };
4034             // https://tc39.github.io/ecma262/#sec-throw-statement
4035             Parser.prototype.parseThrowStatement = function () {
4036                 var node = this.createNode();
4037                 this.expectKeyword('throw');
4038                 if (this.hasLineTerminator) {
4039                     this.throwError(messages_1.Messages.NewlineAfterThrow);
4040                 }
4041                 var argument = this.parseExpression();
4042                 this.consumeSemicolon();
4043                 return this.finalize(node, new Node.ThrowStatement(argument));
4044             };
4045             // https://tc39.github.io/ecma262/#sec-try-statement
4046             Parser.prototype.parseCatchClause = function () {
4047                 var node = this.createNode();
4048                 this.expectKeyword('catch');
4049                 this.expect('(');
4050                 if (this.match(')')) {
4051                     this.throwUnexpectedToken(this.lookahead);
4052                 }
4053                 var params = [];
4054                 var param = this.parsePattern(params);
4055                 var paramMap = {};
4056                 for (var i = 0; i < params.length; i++) {
4057                     var key = '$' + params[i].value;
4058                     if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
4059                         this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
4060                     }
4061                     paramMap[key] = true;
4062                 }
4063                 if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
4064                     if (this.scanner.isRestrictedWord(param.name)) {
4065                         this.tolerateError(messages_1.Messages.StrictCatchVariable);
4066                     }
4067                 }
4068                 this.expect(')');
4069                 var body = this.parseBlock();
4070                 return this.finalize(node, new Node.CatchClause(param, body));
4071             };
4072             Parser.prototype.parseFinallyClause = function () {
4073                 this.expectKeyword('finally');
4074                 return this.parseBlock();
4075             };
4076             Parser.prototype.parseTryStatement = function () {
4077                 var node = this.createNode();
4078                 this.expectKeyword('try');
4079                 var block = this.parseBlock();
4080                 var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
4081                 var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;
4082                 if (!handler && !finalizer) {
4083                     this.throwError(messages_1.Messages.NoCatchOrFinally);
4084                 }
4085                 return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
4086             };
4087             // https://tc39.github.io/ecma262/#sec-debugger-statement
4088             Parser.prototype.parseDebuggerStatement = function () {
4089                 var node = this.createNode();
4090                 this.expectKeyword('debugger');
4091                 this.consumeSemicolon();
4092                 return this.finalize(node, new Node.DebuggerStatement());
4093             };
4094             // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
4095             Parser.prototype.parseStatement = function () {
4096                 var statement;
4097                 switch (this.lookahead.type) {
4098                     case 1 /* BooleanLiteral */:
4099                     case 5 /* NullLiteral */:
4100                     case 6 /* NumericLiteral */:
4101                     case 8 /* StringLiteral */:
4102                     case 10 /* Template */:
4103                     case 9 /* RegularExpression */:
4104                         statement = this.parseExpressionStatement();
4105                         break;
4106                     case 7 /* Punctuator */:
4107                         var value = this.lookahead.value;
4108                         if (value === '{') {
4109                             statement = this.parseBlock();
4110                         }
4111                         else if (value === '(') {
4112                             statement = this.parseExpressionStatement();
4113                         }
4114                         else if (value === ';') {
4115                             statement = this.parseEmptyStatement();
4116                         }
4117                         else {
4118                             statement = this.parseExpressionStatement();
4119                         }
4120                         break;
4121                     case 3 /* Identifier */:
4122                         statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
4123                         break;
4124                     case 4 /* Keyword */:
4125                         switch (this.lookahead.value) {
4126                             case 'break':
4127                                 statement = this.parseBreakStatement();
4128                                 break;
4129                             case 'continue':
4130                                 statement = this.parseContinueStatement();
4131                                 break;
4132                             case 'debugger':
4133                                 statement = this.parseDebuggerStatement();
4134                                 break;
4135                             case 'do':
4136                                 statement = this.parseDoWhileStatement();
4137                                 break;
4138                             case 'for':
4139                                 statement = this.parseForStatement();
4140                                 break;
4141                             case 'function':
4142                                 statement = this.parseFunctionDeclaration();
4143                                 break;
4144                             case 'if':
4145                                 statement = this.parseIfStatement();
4146                                 break;
4147                             case 'return':
4148                                 statement = this.parseReturnStatement();
4149                                 break;
4150                             case 'switch':
4151                                 statement = this.parseSwitchStatement();
4152                                 break;
4153                             case 'throw':
4154                                 statement = this.parseThrowStatement();
4155                                 break;
4156                             case 'try':
4157                                 statement = this.parseTryStatement();
4158                                 break;
4159                             case 'var':
4160                                 statement = this.parseVariableStatement();
4161                                 break;
4162                             case 'while':
4163                                 statement = this.parseWhileStatement();
4164                                 break;
4165                             case 'with':
4166                                 statement = this.parseWithStatement();
4167                                 break;
4168                             default:
4169                                 statement = this.parseExpressionStatement();
4170                                 break;
4171                         }
4172                         break;
4173                     default:
4174                         statement = this.throwUnexpectedToken(this.lookahead);
4175                 }
4176                 return statement;
4177             };
4178             // https://tc39.github.io/ecma262/#sec-function-definitions
4179             Parser.prototype.parseFunctionSourceElements = function () {
4180                 var node = this.createNode();
4181                 this.expect('{');
4182                 var body = this.parseDirectivePrologues();
4183                 var previousLabelSet = this.context.labelSet;
4184                 var previousInIteration = this.context.inIteration;
4185                 var previousInSwitch = this.context.inSwitch;
4186                 var previousInFunctionBody = this.context.inFunctionBody;
4187                 this.context.labelSet = {};
4188                 this.context.inIteration = false;
4189                 this.context.inSwitch = false;
4190                 this.context.inFunctionBody = true;
4191                 while (this.lookahead.type !== 2 /* EOF */) {
4192                     if (this.match('}')) {
4193                         break;
4194                     }
4195                     body.push(this.parseStatementListItem());
4196                 }
4197                 this.expect('}');
4198                 this.context.labelSet = previousLabelSet;
4199                 this.context.inIteration = previousInIteration;
4200                 this.context.inSwitch = previousInSwitch;
4201                 this.context.inFunctionBody = previousInFunctionBody;
4202                 return this.finalize(node, new Node.BlockStatement(body));
4203             };
4204             Parser.prototype.validateParam = function (options, param, name) {
4205                 var key = '$' + name;
4206                 if (this.context.strict) {
4207                     if (this.scanner.isRestrictedWord(name)) {
4208                         options.stricted = param;
4209                         options.message = messages_1.Messages.StrictParamName;
4210                     }
4211                     if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
4212                         options.stricted = param;
4213                         options.message = messages_1.Messages.StrictParamDupe;
4214                     }
4215                 }
4216                 else if (!options.firstRestricted) {
4217                     if (this.scanner.isRestrictedWord(name)) {
4218                         options.firstRestricted = param;
4219                         options.message = messages_1.Messages.StrictParamName;
4220                     }
4221                     else if (this.scanner.isStrictModeReservedWord(name)) {
4222                         options.firstRestricted = param;
4223                         options.message = messages_1.Messages.StrictReservedWord;
4224                     }
4225                     else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
4226                         options.stricted = param;
4227                         options.message = messages_1.Messages.StrictParamDupe;
4228                     }
4229                 }
4230                 /* istanbul ignore next */
4231                 if (typeof Object.defineProperty === 'function') {
4232                     Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });
4233                 }
4234                 else {
4235                     options.paramSet[key] = true;
4236                 }
4237             };
4238             Parser.prototype.parseRestElement = function (params) {
4239                 var node = this.createNode();
4240                 this.expect('...');
4241                 var arg = this.parsePattern(params);
4242                 if (this.match('=')) {
4243                     this.throwError(messages_1.Messages.DefaultRestParameter);
4244                 }
4245                 if (!this.match(')')) {
4246                     this.throwError(messages_1.Messages.ParameterAfterRestParameter);
4247                 }
4248                 return this.finalize(node, new Node.RestElement(arg));
4249             };
4250             Parser.prototype.parseFormalParameter = function (options) {
4251                 var params = [];
4252                 var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);
4253                 for (var i = 0; i < params.length; i++) {
4254                     this.validateParam(options, params[i], params[i].value);
4255                 }
4256                 options.simple = options.simple && (param instanceof Node.Identifier);
4257                 options.params.push(param);
4258             };
4259             Parser.prototype.parseFormalParameters = function (firstRestricted) {
4260                 var options;
4261                 options = {
4262                     simple: true,
4263                     params: [],
4264                     firstRestricted: firstRestricted
4265                 };
4266                 this.expect('(');
4267                 if (!this.match(')')) {
4268                     options.paramSet = {};
4269                     while (this.lookahead.type !== 2 /* EOF */) {
4270                         this.parseFormalParameter(options);
4271                         if (this.match(')')) {
4272                             break;
4273                         }
4274                         this.expect(',');
4275                         if (this.match(')')) {
4276                             break;
4277                         }
4278                     }
4279                 }
4280                 this.expect(')');
4281                 return {
4282                     simple: options.simple,
4283                     params: options.params,
4284                     stricted: options.stricted,
4285                     firstRestricted: options.firstRestricted,
4286                     message: options.message
4287                 };
4288             };
4289             Parser.prototype.matchAsyncFunction = function () {
4290                 var match = this.matchContextualKeyword('async');
4291                 if (match) {
4292                     var state = this.scanner.saveState();
4293                     this.scanner.scanComments();
4294                     var next = this.scanner.lex();
4295                     this.scanner.restoreState(state);
4296                     match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');
4297                 }
4298                 return match;
4299             };
4300             Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
4301                 var node = this.createNode();
4302                 var isAsync = this.matchContextualKeyword('async');
4303                 if (isAsync) {
4304                     this.nextToken();
4305                 }
4306                 this.expectKeyword('function');
4307                 var isGenerator = isAsync ? false : this.match('*');
4308                 if (isGenerator) {
4309                     this.nextToken();
4310                 }
4311                 var message;
4312                 var id = null;
4313                 var firstRestricted = null;
4314                 if (!identifierIsOptional || !this.match('(')) {
4315                     var token = this.lookahead;
4316                     id = this.parseVariableIdentifier();
4317                     if (this.context.strict) {
4318                         if (this.scanner.isRestrictedWord(token.value)) {
4319                             this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
4320                         }
4321                     }
4322                     else {
4323                         if (this.scanner.isRestrictedWord(token.value)) {
4324                             firstRestricted = token;
4325                             message = messages_1.Messages.StrictFunctionName;
4326                         }
4327                         else if (this.scanner.isStrictModeReservedWord(token.value)) {
4328                             firstRestricted = token;
4329                             message = messages_1.Messages.StrictReservedWord;
4330                         }
4331                     }
4332                 }
4333                 var previousAllowAwait = this.context.await;
4334                 var previousAllowYield = this.context.allowYield;
4335                 this.context.await = isAsync;
4336                 this.context.allowYield = !isGenerator;
4337                 var formalParameters = this.parseFormalParameters(firstRestricted);
4338                 var params = formalParameters.params;
4339                 var stricted = formalParameters.stricted;
4340                 firstRestricted = formalParameters.firstRestricted;
4341                 if (formalParameters.message) {
4342                     message = formalParameters.message;
4343                 }
4344                 var previousStrict = this.context.strict;
4345                 var previousAllowStrictDirective = this.context.allowStrictDirective;
4346                 this.context.allowStrictDirective = formalParameters.simple;
4347                 var body = this.parseFunctionSourceElements();
4348                 if (this.context.strict && firstRestricted) {
4349                     this.throwUnexpectedToken(firstRestricted, message);
4350                 }
4351                 if (this.context.strict && stricted) {
4352                     this.tolerateUnexpectedToken(stricted, message);
4353                 }
4354                 this.context.strict = previousStrict;
4355                 this.context.allowStrictDirective = previousAllowStrictDirective;
4356                 this.context.await = previousAllowAwait;
4357                 this.context.allowYield = previousAllowYield;
4358                 return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
4359                     this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
4360             };
4361             Parser.prototype.parseFunctionExpression = function () {
4362                 var node = this.createNode();
4363                 var isAsync = this.matchContextualKeyword('async');
4364                 if (isAsync) {
4365                     this.nextToken();
4366                 }
4367                 this.expectKeyword('function');
4368                 var isGenerator = isAsync ? false : this.match('*');
4369                 if (isGenerator) {
4370                     this.nextToken();
4371                 }
4372                 var message;
4373                 var id = null;
4374                 var firstRestricted;
4375                 var previousAllowAwait = this.context.await;
4376                 var previousAllowYield = this.context.allowYield;
4377                 this.context.await = isAsync;
4378                 this.context.allowYield = !isGenerator;
4379                 if (!this.match('(')) {
4380                     var token = this.lookahead;
4381                     id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();
4382                     if (this.context.strict) {
4383                         if (this.scanner.isRestrictedWord(token.value)) {
4384                             this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
4385                         }
4386                     }
4387                     else {
4388                         if (this.scanner.isRestrictedWord(token.value)) {
4389                             firstRestricted = token;
4390                             message = messages_1.Messages.StrictFunctionName;
4391                         }
4392                         else if (this.scanner.isStrictModeReservedWord(token.value)) {
4393                             firstRestricted = token;
4394                             message = messages_1.Messages.StrictReservedWord;
4395                         }
4396                     }
4397                 }
4398                 var formalParameters = this.parseFormalParameters(firstRestricted);
4399                 var params = formalParameters.params;
4400                 var stricted = formalParameters.stricted;
4401                 firstRestricted = formalParameters.firstRestricted;
4402                 if (formalParameters.message) {
4403                     message = formalParameters.message;
4404                 }
4405                 var previousStrict = this.context.strict;
4406                 var previousAllowStrictDirective = this.context.allowStrictDirective;
4407                 this.context.allowStrictDirective = formalParameters.simple;
4408                 var body = this.parseFunctionSourceElements();
4409                 if (this.context.strict && firstRestricted) {
4410                     this.throwUnexpectedToken(firstRestricted, message);
4411                 }
4412                 if (this.context.strict && stricted) {
4413                     this.tolerateUnexpectedToken(stricted, message);
4414                 }
4415                 this.context.strict = previousStrict;
4416                 this.context.allowStrictDirective = previousAllowStrictDirective;
4417                 this.context.await = previousAllowAwait;
4418                 this.context.allowYield = previousAllowYield;
4419                 return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
4420                     this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
4421             };
4422             // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
4423             Parser.prototype.parseDirective = function () {
4424                 var token = this.lookahead;
4425                 var node = this.createNode();
4426                 var expr = this.parseExpression();
4427                 var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;
4428                 this.consumeSemicolon();
4429                 return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
4430             };
4431             Parser.prototype.parseDirectivePrologues = function () {
4432                 var firstRestricted = null;
4433                 var body = [];
4434                 while (true) {
4435                     var token = this.lookahead;
4436                     if (token.type !== 8 /* StringLiteral */) {
4437                         break;
4438                     }
4439                     var statement = this.parseDirective();
4440                     body.push(statement);
4441                     var directive = statement.directive;
4442                     if (typeof directive !== 'string') {
4443                         break;
4444                     }
4445                     if (directive === 'use strict') {
4446                         this.context.strict = true;
4447                         if (firstRestricted) {
4448                             this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
4449                         }
4450                         if (!this.context.allowStrictDirective) {
4451                             this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
4452                         }
4453                     }
4454                     else {
4455                         if (!firstRestricted && token.octal) {
4456                             firstRestricted = token;
4457                         }
4458                     }
4459                 }
4460                 return body;
4461             };
4462             // https://tc39.github.io/ecma262/#sec-method-definitions
4463             Parser.prototype.qualifiedPropertyName = function (token) {
4464                 switch (token.type) {
4465                     case 3 /* Identifier */:
4466                     case 8 /* StringLiteral */:
4467                     case 1 /* BooleanLiteral */:
4468                     case 5 /* NullLiteral */:
4469                     case 6 /* NumericLiteral */:
4470                     case 4 /* Keyword */:
4471                         return true;
4472                     case 7 /* Punctuator */:
4473                         return token.value === '[';
4474                     default:
4475                         break;
4476                 }
4477                 return false;
4478             };
4479             Parser.prototype.parseGetterMethod = function () {
4480                 var node = this.createNode();
4481                 var isGenerator = false;
4482                 var previousAllowYield = this.context.allowYield;
4483                 this.context.allowYield = !isGenerator;
4484                 var formalParameters = this.parseFormalParameters();
4485                 if (formalParameters.params.length > 0) {
4486                     this.tolerateError(messages_1.Messages.BadGetterArity);
4487                 }
4488                 var method = this.parsePropertyMethod(formalParameters);
4489                 this.context.allowYield = previousAllowYield;
4490                 return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
4491             };
4492             Parser.prototype.parseSetterMethod = function () {
4493                 var node = this.createNode();
4494                 var isGenerator = false;
4495                 var previousAllowYield = this.context.allowYield;
4496                 this.context.allowYield = !isGenerator;
4497                 var formalParameters = this.parseFormalParameters();
4498                 if (formalParameters.params.length !== 1) {
4499                     this.tolerateError(messages_1.Messages.BadSetterArity);
4500                 }
4501                 else if (formalParameters.params[0] instanceof Node.RestElement) {
4502                     this.tolerateError(messages_1.Messages.BadSetterRestParameter);
4503                 }
4504                 var method = this.parsePropertyMethod(formalParameters);
4505                 this.context.allowYield = previousAllowYield;
4506                 return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
4507             };
4508             Parser.prototype.parseGeneratorMethod = function () {
4509                 var node = this.createNode();
4510                 var isGenerator = true;
4511                 var previousAllowYield = this.context.allowYield;
4512                 this.context.allowYield = true;
4513                 var params = this.parseFormalParameters();
4514                 this.context.allowYield = false;
4515                 var method = this.parsePropertyMethod(params);
4516                 this.context.allowYield = previousAllowYield;
4517                 return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
4518             };
4519             // https://tc39.github.io/ecma262/#sec-generator-function-definitions
4520             Parser.prototype.isStartOfExpression = function () {
4521                 var start = true;
4522                 var value = this.lookahead.value;
4523                 switch (this.lookahead.type) {
4524                     case 7 /* Punctuator */:
4525                         start = (value === '[') || (value === '(') || (value === '{') ||
4526                             (value === '+') || (value === '-') ||
4527                             (value === '!') || (value === '~') ||
4528                             (value === '++') || (value === '--') ||
4529                             (value === '/') || (value === '/='); // regular expression literal
4530                         break;
4531                     case 4 /* Keyword */:
4532                         start = (value === 'class') || (value === 'delete') ||
4533                             (value === 'function') || (value === 'let') || (value === 'new') ||
4534                             (value === 'super') || (value === 'this') || (value === 'typeof') ||
4535                             (value === 'void') || (value === 'yield');
4536                         break;
4537                     default:
4538                         break;
4539                 }
4540                 return start;
4541             };
4542             Parser.prototype.parseYieldExpression = function () {
4543                 var node = this.createNode();
4544                 this.expectKeyword('yield');
4545                 var argument = null;
4546                 var delegate = false;
4547                 if (!this.hasLineTerminator) {
4548                     var previousAllowYield = this.context.allowYield;
4549                     this.context.allowYield = false;
4550                     delegate = this.match('*');
4551                     if (delegate) {
4552                         this.nextToken();
4553                         argument = this.parseAssignmentExpression();
4554                     }
4555                     else if (this.isStartOfExpression()) {
4556                         argument = this.parseAssignmentExpression();
4557                     }
4558                     this.context.allowYield = previousAllowYield;
4559                 }
4560                 return this.finalize(node, new Node.YieldExpression(argument, delegate));
4561             };
4562             // https://tc39.github.io/ecma262/#sec-class-definitions
4563             Parser.prototype.parseClassElement = function (hasConstructor) {
4564                 var token = this.lookahead;
4565                 var node = this.createNode();
4566                 var kind = '';
4567                 var key = null;
4568                 var value = null;
4569                 var computed = false;
4570                 var method = false;
4571                 var isStatic = false;
4572                 var isAsync = false;
4573                 if (this.match('*')) {
4574                     this.nextToken();
4575                 }
4576                 else {
4577                     computed = this.match('[');
4578                     key = this.parseObjectPropertyKey();
4579                     var id = key;
4580                     if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
4581                         token = this.lookahead;
4582                         isStatic = true;
4583                         computed = this.match('[');
4584                         if (this.match('*')) {
4585                             this.nextToken();
4586                         }
4587                         else {
4588                             key = this.parseObjectPropertyKey();
4589                         }
4590                     }
4591                     if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {
4592                         var punctuator = this.lookahead.value;
4593                         if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
4594                             isAsync = true;
4595                             token = this.lookahead;
4596                             key = this.parseObjectPropertyKey();
4597                             if (token.type === 3 /* Identifier */ && token.value === 'constructor') {
4598                                 this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
4599                             }
4600                         }
4601                     }
4602                 }
4603                 var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
4604                 if (token.type === 3 /* Identifier */) {
4605                     if (token.value === 'get' && lookaheadPropertyKey) {
4606                         kind = 'get';
4607                         computed = this.match('[');
4608                         key = this.parseObjectPropertyKey();
4609                         this.context.allowYield = false;
4610                         value = this.parseGetterMethod();
4611                     }
4612                     else if (token.value === 'set' && lookaheadPropertyKey) {
4613                         kind = 'set';
4614                         computed = this.match('[');
4615                         key = this.parseObjectPropertyKey();
4616                         value = this.parseSetterMethod();
4617                     }
4618                 }
4619                 else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
4620                     kind = 'init';
4621                     computed = this.match('[');
4622                     key = this.parseObjectPropertyKey();
4623                     value = this.parseGeneratorMethod();
4624                     method = true;
4625                 }
4626                 if (!kind && key && this.match('(')) {
4627                     kind = 'init';
4628                     value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
4629                     method = true;
4630                 }
4631                 if (!kind) {
4632                     this.throwUnexpectedToken(this.lookahead);
4633                 }
4634                 if (kind === 'init') {
4635                     kind = 'method';
4636                 }
4637                 if (!computed) {
4638                     if (isStatic && this.isPropertyKey(key, 'prototype')) {
4639                         this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
4640                     }
4641                     if (!isStatic && this.isPropertyKey(key, 'constructor')) {
4642                         if (kind !== 'method' || !method || (value && value.generator)) {
4643                             this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
4644                         }
4645                         if (hasConstructor.value) {
4646                             this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
4647                         }
4648                         else {
4649                             hasConstructor.value = true;
4650                         }
4651                         kind = 'constructor';
4652                     }
4653                 }
4654                 return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
4655             };
4656             Parser.prototype.parseClassElementList = function () {
4657                 var body = [];
4658                 var hasConstructor = { value: false };
4659                 this.expect('{');
4660                 while (!this.match('}')) {
4661                     if (this.match(';')) {
4662                         this.nextToken();
4663                     }
4664                     else {
4665                         body.push(this.parseClassElement(hasConstructor));
4666                     }
4667                 }
4668                 this.expect('}');
4669                 return body;
4670             };
4671             Parser.prototype.parseClassBody = function () {
4672                 var node = this.createNode();
4673                 var elementList = this.parseClassElementList();
4674                 return this.finalize(node, new Node.ClassBody(elementList));
4675             };
4676             Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
4677                 var node = this.createNode();
4678                 var previousStrict = this.context.strict;
4679                 this.context.strict = true;
4680                 this.expectKeyword('class');
4681                 var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();
4682                 var superClass = null;
4683                 if (this.matchKeyword('extends')) {
4684                     this.nextToken();
4685                     superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
4686                 }
4687                 var classBody = this.parseClassBody();
4688                 this.context.strict = previousStrict;
4689                 return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
4690             };
4691             Parser.prototype.parseClassExpression = function () {
4692                 var node = this.createNode();
4693                 var previousStrict = this.context.strict;
4694                 this.context.strict = true;
4695                 this.expectKeyword('class');
4696                 var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;
4697                 var superClass = null;
4698                 if (this.matchKeyword('extends')) {
4699                     this.nextToken();
4700                     superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
4701                 }
4702                 var classBody = this.parseClassBody();
4703                 this.context.strict = previousStrict;
4704                 return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
4705             };
4706             // https://tc39.github.io/ecma262/#sec-scripts
4707             // https://tc39.github.io/ecma262/#sec-modules
4708             Parser.prototype.parseModule = function () {
4709                 this.context.strict = true;
4710                 this.context.isModule = true;
4711                 this.scanner.isModule = true;
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.Module(body));
4718             };
4719             Parser.prototype.parseScript = function () {
4720                 var node = this.createNode();
4721                 var body = this.parseDirectivePrologues();
4722                 while (this.lookahead.type !== 2 /* EOF */) {
4723                     body.push(this.parseStatementListItem());
4724                 }
4725                 return this.finalize(node, new Node.Script(body));
4726             };
4727             // https://tc39.github.io/ecma262/#sec-imports
4728             Parser.prototype.parseModuleSpecifier = function () {
4729                 var node = this.createNode();
4730                 if (this.lookahead.type !== 8 /* StringLiteral */) {
4731                     this.throwError(messages_1.Messages.InvalidModuleSpecifier);
4732                 }
4733                 var token = this.nextToken();
4734                 var raw = this.getTokenRaw(token);
4735                 return this.finalize(node, new Node.Literal(token.value, raw));
4736             };
4737             // import {<foo as bar>} ...;
4738             Parser.prototype.parseImportSpecifier = function () {
4739                 var node = this.createNode();
4740                 var imported;
4741                 var local;
4742                 if (this.lookahead.type === 3 /* Identifier */) {
4743                     imported = this.parseVariableIdentifier();
4744                     local = imported;
4745                     if (this.matchContextualKeyword('as')) {
4746                         this.nextToken();
4747                         local = this.parseVariableIdentifier();
4748                     }
4749                 }
4750                 else {
4751                     imported = this.parseIdentifierName();
4752                     local = imported;
4753                     if (this.matchContextualKeyword('as')) {
4754                         this.nextToken();
4755                         local = this.parseVariableIdentifier();
4756                     }
4757                     else {
4758                         this.throwUnexpectedToken(this.nextToken());
4759                     }
4760                 }
4761                 return this.finalize(node, new Node.ImportSpecifier(local, imported));
4762             };
4763             // {foo, bar as bas}
4764             Parser.prototype.parseNamedImports = function () {
4765                 this.expect('{');
4766                 var specifiers = [];
4767                 while (!this.match('}')) {
4768                     specifiers.push(this.parseImportSpecifier());
4769                     if (!this.match('}')) {
4770                         this.expect(',');
4771                     }
4772                 }
4773                 this.expect('}');
4774                 return specifiers;
4775             };
4776             // import <foo> ...;
4777             Parser.prototype.parseImportDefaultSpecifier = function () {
4778                 var node = this.createNode();
4779                 var local = this.parseIdentifierName();
4780                 return this.finalize(node, new Node.ImportDefaultSpecifier(local));
4781             };
4782             // import <* as foo> ...;
4783             Parser.prototype.parseImportNamespaceSpecifier = function () {
4784                 var node = this.createNode();
4785                 this.expect('*');
4786                 if (!this.matchContextualKeyword('as')) {
4787                     this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
4788                 }
4789                 this.nextToken();
4790                 var local = this.parseIdentifierName();
4791                 return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
4792             };
4793             Parser.prototype.parseImportDeclaration = function () {
4794                 if (this.context.inFunctionBody) {
4795                     this.throwError(messages_1.Messages.IllegalImportDeclaration);
4796                 }
4797                 var node = this.createNode();
4798                 this.expectKeyword('import');
4799                 var src;
4800                 var specifiers = [];
4801                 if (this.lookahead.type === 8 /* StringLiteral */) {
4802                     // import 'foo';
4803                     src = this.parseModuleSpecifier();
4804                 }
4805                 else {
4806                     if (this.match('{')) {
4807                         // import {bar}
4808                         specifiers = specifiers.concat(this.parseNamedImports());
4809                     }
4810                     else if (this.match('*')) {
4811                         // import * as foo
4812                         specifiers.push(this.parseImportNamespaceSpecifier());
4813                     }
4814                     else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
4815                         // import foo
4816                         specifiers.push(this.parseImportDefaultSpecifier());
4817                         if (this.match(',')) {
4818                             this.nextToken();
4819                             if (this.match('*')) {
4820                                 // import foo, * as foo
4821                                 specifiers.push(this.parseImportNamespaceSpecifier());
4822                             }
4823                             else if (this.match('{')) {
4824                                 // import foo, {bar}
4825                                 specifiers = specifiers.concat(this.parseNamedImports());
4826                             }
4827                             else {
4828                                 this.throwUnexpectedToken(this.lookahead);
4829                             }
4830                         }
4831                     }
4832                     else {
4833                         this.throwUnexpectedToken(this.nextToken());
4834                     }
4835                     if (!this.matchContextualKeyword('from')) {
4836                         var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
4837                         this.throwError(message, this.lookahead.value);
4838                     }
4839                     this.nextToken();
4840                     src = this.parseModuleSpecifier();
4841                 }
4842                 this.consumeSemicolon();
4843                 return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
4844             };
4845             // https://tc39.github.io/ecma262/#sec-exports
4846             Parser.prototype.parseExportSpecifier = function () {
4847                 var node = this.createNode();
4848                 var local = this.parseIdentifierName();
4849                 var exported = local;
4850                 if (this.matchContextualKeyword('as')) {
4851                     this.nextToken();
4852                     exported = this.parseIdentifierName();
4853                 }
4854                 return this.finalize(node, new Node.ExportSpecifier(local, exported));
4855             };
4856             Parser.prototype.parseExportDeclaration = function () {
4857                 if (this.context.inFunctionBody) {
4858                     this.throwError(messages_1.Messages.IllegalExportDeclaration);
4859                 }
4860                 var node = this.createNode();
4861                 this.expectKeyword('export');
4862                 var exportDeclaration;
4863                 if (this.matchKeyword('default')) {
4864                     // export default ...
4865                     this.nextToken();
4866                     if (this.matchKeyword('function')) {
4867                         // export default function foo () {}
4868                         // export default function () {}
4869                         var declaration = this.parseFunctionDeclaration(true);
4870                         exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
4871                     }
4872                     else if (this.matchKeyword('class')) {
4873                         // export default class foo {}
4874                         var declaration = this.parseClassDeclaration(true);
4875                         exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
4876                     }
4877                     else if (this.matchContextualKeyword('async')) {
4878                         // export default async function f () {}
4879                         // export default async function () {}
4880                         // export default async x => x
4881                         var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
4882                         exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
4883                     }
4884                     else {
4885                         if (this.matchContextualKeyword('from')) {
4886                             this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
4887                         }
4888                         // export default {};
4889                         // export default [];
4890                         // export default (1 + 2);
4891                         var declaration = this.match('{') ? this.parseObjectInitializer() :
4892                             this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
4893                         this.consumeSemicolon();
4894                         exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
4895                     }
4896                 }
4897                 else if (this.match('*')) {
4898                     // export * from 'foo';
4899                     this.nextToken();
4900                     if (!this.matchContextualKeyword('from')) {
4901                         var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
4902                         this.throwError(message, this.lookahead.value);
4903                     }
4904                     this.nextToken();
4905                     var src = this.parseModuleSpecifier();
4906                     this.consumeSemicolon();
4907                     exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
4908                 }
4909                 else if (this.lookahead.type === 4 /* Keyword */) {
4910                     // export var f = 1;
4911                     var declaration = void 0;
4912                     switch (this.lookahead.value) {
4913                         case 'let':
4914                         case 'const':
4915                             declaration = this.parseLexicalDeclaration({ inFor: false });
4916                             break;
4917                         case 'var':
4918                         case 'class':
4919                         case 'function':
4920                             declaration = this.parseStatementListItem();
4921                             break;
4922                         default:
4923                             this.throwUnexpectedToken(this.lookahead);
4924                     }
4925                     exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
4926                 }
4927                 else if (this.matchAsyncFunction()) {
4928                     var declaration = this.parseFunctionDeclaration();
4929                     exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
4930                 }
4931                 else {
4932                     var specifiers = [];
4933                     var source = null;
4934                     var isExportFromIdentifier = false;
4935                     this.expect('{');
4936                     while (!this.match('}')) {
4937                         isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
4938                         specifiers.push(this.parseExportSpecifier());
4939                         if (!this.match('}')) {
4940                             this.expect(',');
4941                         }
4942                     }
4943                     this.expect('}');
4944                     if (this.matchContextualKeyword('from')) {
4945                         // export {default} from 'foo';
4946                         // export {foo} from 'foo';
4947                         this.nextToken();
4948                         source = this.parseModuleSpecifier();
4949                         this.consumeSemicolon();
4950                     }
4951                     else if (isExportFromIdentifier) {
4952                         // export {default}; // missing fromClause
4953                         var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
4954                         this.throwError(message, this.lookahead.value);
4955                     }
4956                     else {
4957                         // export {foo};
4958                         this.consumeSemicolon();
4959                     }
4960                     exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
4961                 }
4962                 return exportDeclaration;
4963             };
4964             return Parser;
4965         }());
4966         exports.Parser = Parser;
4967
4968
4969 /***/ },
4970 /* 9 */
4971 /***/ function(module, exports) {
4972
4973         "use strict";
4974         // Ensure the condition is true, otherwise throw an error.
4975         // This is only to have a better contract semantic, i.e. another safety net
4976         // to catch a logic error. The condition shall be fulfilled in normal case.
4977         // Do NOT use this to enforce a certain condition on any user input.
4978         Object.defineProperty(exports, "__esModule", { value: true });
4979         function assert(condition, message) {
4980             /* istanbul ignore if */
4981             if (!condition) {
4982                 throw new Error('ASSERT: ' + message);
4983             }
4984         }
4985         exports.assert = assert;
4986
4987
4988 /***/ },
4989 /* 10 */
4990 /***/ function(module, exports) {
4991
4992         "use strict";
4993         /* tslint:disable:max-classes-per-file */
4994         Object.defineProperty(exports, "__esModule", { value: true });
4995         var ErrorHandler = (function () {
4996             function ErrorHandler() {
4997                 this.errors = [];
4998                 this.tolerant = false;
4999             }
5000             ErrorHandler.prototype.recordError = function (error) {
5001                 this.errors.push(error);
5002             };
5003             ErrorHandler.prototype.tolerate = function (error) {
5004                 if (this.tolerant) {
5005                     this.recordError(error);
5006                 }
5007                 else {
5008                     throw error;
5009                 }
5010             };
5011             ErrorHandler.prototype.constructError = function (msg, column) {
5012                 var error = new Error(msg);
5013                 try {
5014                     throw error;
5015                 }
5016                 catch (base) {
5017                     /* istanbul ignore else */
5018                     if (Object.create && Object.defineProperty) {
5019                         error = Object.create(base);
5020                         Object.defineProperty(error, 'column', { value: column });
5021                     }
5022                 }
5023                 /* istanbul ignore next */
5024                 return error;
5025             };
5026             ErrorHandler.prototype.createError = function (index, line, col, description) {
5027                 var msg = 'Line ' + line + ': ' + description;
5028                 var error = this.constructError(msg, col);
5029                 error.index = index;
5030                 error.lineNumber = line;
5031                 error.description = description;
5032                 return error;
5033             };
5034             ErrorHandler.prototype.throwError = function (index, line, col, description) {
5035                 throw this.createError(index, line, col, description);
5036             };
5037             ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
5038                 var error = this.createError(index, line, col, description);
5039                 if (this.tolerant) {
5040                     this.recordError(error);
5041                 }
5042                 else {
5043                     throw error;
5044                 }
5045             };
5046             return ErrorHandler;
5047         }());
5048         exports.ErrorHandler = ErrorHandler;
5049
5050
5051 /***/ },
5052 /* 11 */
5053 /***/ function(module, exports) {
5054
5055         "use strict";
5056         Object.defineProperty(exports, "__esModule", { value: true });
5057         // Error messages should be identical to V8.
5058         exports.Messages = {
5059             BadGetterArity: 'Getter must not have any formal parameters',
5060             BadSetterArity: 'Setter must have exactly one formal parameter',
5061             BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
5062             ConstructorIsAsync: 'Class constructor may not be an async method',
5063             ConstructorSpecialMethod: 'Class constructor may not be an accessor',
5064             DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
5065             DefaultRestParameter: 'Unexpected token =',
5066             DuplicateBinding: 'Duplicate binding %0',
5067             DuplicateConstructor: 'A class may only have one constructor',
5068             DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
5069             ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
5070             GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
5071             IllegalBreak: 'Illegal break statement',
5072             IllegalContinue: 'Illegal continue statement',
5073             IllegalExportDeclaration: 'Unexpected token',
5074             IllegalImportDeclaration: 'Unexpected token',
5075             IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
5076             IllegalReturn: 'Illegal return statement',
5077             InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
5078             InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
5079             InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
5080             InvalidLHSInForIn: 'Invalid left-hand side in for-in',
5081             InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
5082             InvalidModuleSpecifier: 'Unexpected token',
5083             InvalidRegExp: 'Invalid regular expression',
5084             LetInLexicalBinding: 'let is disallowed as a lexically bound name',
5085             MissingFromClause: 'Unexpected token',
5086             MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
5087             NewlineAfterThrow: 'Illegal newline after throw',
5088             NoAsAfterImportNamespace: 'Unexpected token',
5089             NoCatchOrFinally: 'Missing catch or finally after try',
5090             ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
5091             Redeclaration: '%0 \'%1\' has already been declared',
5092             StaticPrototype: 'Classes may not have static property named prototype',
5093             StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
5094             StrictDelete: 'Delete of an unqualified identifier in strict mode.',
5095             StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
5096             StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
5097             StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
5098             StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
5099             StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
5100             StrictModeWith: 'Strict mode code may not include a with statement',
5101             StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
5102             StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
5103             StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
5104             StrictReservedWord: 'Use of future reserved word in strict mode',
5105             StrictVarName: 'Variable name may not be eval or arguments in strict mode',
5106             TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
5107             UnexpectedEOS: 'Unexpected end of input',
5108             UnexpectedIdentifier: 'Unexpected identifier',
5109             UnexpectedNumber: 'Unexpected number',
5110             UnexpectedReserved: 'Unexpected reserved word',
5111             UnexpectedString: 'Unexpected string',
5112             UnexpectedTemplate: 'Unexpected quasi %0',
5113             UnexpectedToken: 'Unexpected token %0',
5114             UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
5115             UnknownLabel: 'Undefined label \'%0\'',
5116             UnterminatedRegExp: 'Invalid regular expression: missing /'
5117         };
5118
5119
5120 /***/ },
5121 /* 12 */
5122 /***/ function(module, exports, __webpack_require__) {
5123
5124         "use strict";
5125         Object.defineProperty(exports, "__esModule", { value: true });
5126         var assert_1 = __webpack_require__(9);
5127         var character_1 = __webpack_require__(4);
5128         var messages_1 = __webpack_require__(11);
5129         function hexValue(ch) {
5130             return '0123456789abcdef'.indexOf(ch.toLowerCase());
5131         }
5132         function octalValue(ch) {
5133             return '01234567'.indexOf(ch);
5134         }
5135         var Scanner = (function () {
5136             function Scanner(code, handler) {
5137                 this.source = code;
5138                 this.errorHandler = handler;
5139                 this.trackComment = false;
5140                 this.isModule = false;
5141                 this.length = code.length;
5142                 this.index = 0;
5143                 this.lineNumber = (code.length > 0) ? 1 : 0;
5144                 this.lineStart = 0;
5145                 this.curlyStack = [];
5146             }
5147             Scanner.prototype.saveState = function () {
5148                 return {
5149                     index: this.index,
5150                     lineNumber: this.lineNumber,
5151                     lineStart: this.lineStart
5152                 };
5153             };
5154             Scanner.prototype.restoreState = function (state) {
5155                 this.index = state.index;
5156                 this.lineNumber = state.lineNumber;
5157                 this.lineStart = state.lineStart;
5158             };
5159             Scanner.prototype.eof = function () {
5160                 return this.index >= this.length;
5161             };
5162             Scanner.prototype.throwUnexpectedToken = function (message) {
5163                 if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
5164                 return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
5165             };
5166             Scanner.prototype.tolerateUnexpectedToken = function (message) {
5167                 if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
5168                 this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
5169             };
5170             // https://tc39.github.io/ecma262/#sec-comments
5171             Scanner.prototype.skipSingleLineComment = function (offset) {
5172                 var comments = [];
5173                 var start, loc;
5174                 if (this.trackComment) {
5175                     comments = [];
5176                     start = this.index - offset;
5177                     loc = {
5178                         start: {
5179                             line: this.lineNumber,
5180                             column: this.index - this.lineStart - offset
5181                         },
5182                         end: {}
5183                     };
5184                 }
5185                 while (!this.eof()) {
5186                     var ch = this.source.charCodeAt(this.index);
5187                     ++this.index;
5188                     if (character_1.Character.isLineTerminator(ch)) {
5189                         if (this.trackComment) {
5190                             loc.end = {
5191                                 line: this.lineNumber,
5192                                 column: this.index - this.lineStart - 1
5193                             };
5194                             var entry = {
5195                                 multiLine: false,
5196                                 slice: [start + offset, this.index - 1],
5197                                 range: [start, this.index - 1],
5198                                 loc: loc
5199                             };
5200                             comments.push(entry);
5201                         }
5202                         if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
5203                             ++this.index;
5204                         }
5205                         ++this.lineNumber;
5206                         this.lineStart = this.index;
5207                         return comments;
5208                     }
5209                 }
5210                 if (this.trackComment) {
5211                     loc.end = {
5212                         line: this.lineNumber,
5213                         column: this.index - this.lineStart
5214                     };
5215                     var entry = {
5216                         multiLine: false,
5217                         slice: [start + offset, this.index],
5218                         range: [start, this.index],
5219                         loc: loc
5220                     };
5221                     comments.push(entry);
5222                 }
5223                 return comments;
5224             };
5225             Scanner.prototype.skipMultiLineComment = function () {
5226                 var comments = [];
5227                 var start, loc;
5228                 if (this.trackComment) {
5229                     comments = [];
5230                     start = this.index - 2;
5231                     loc = {
5232                         start: {
5233                             line: this.lineNumber,
5234                             column: this.index - this.lineStart - 2
5235                         },
5236                         end: {}
5237                     };
5238                 }
5239                 while (!this.eof()) {
5240                     var ch = this.source.charCodeAt(this.index);
5241                     if (character_1.Character.isLineTerminator(ch)) {
5242                         if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
5243                             ++this.index;
5244                         }
5245                         ++this.lineNumber;
5246                         ++this.index;
5247                         this.lineStart = this.index;
5248                     }
5249                     else if (ch === 0x2A) {
5250                         // Block comment ends with '*/'.
5251                         if (this.source.charCodeAt(this.index + 1) === 0x2F) {
5252                             this.index += 2;
5253                             if (this.trackComment) {
5254                                 loc.end = {
5255                                     line: this.lineNumber,
5256                                     column: this.index - this.lineStart
5257                                 };
5258                                 var entry = {
5259                                     multiLine: true,
5260                                     slice: [start + 2, this.index - 2],
5261                                     range: [start, this.index],
5262                                     loc: loc
5263                                 };
5264                                 comments.push(entry);
5265                             }
5266                             return comments;
5267                         }
5268                         ++this.index;
5269                     }
5270                     else {
5271                         ++this.index;
5272                     }
5273                 }
5274                 // Ran off the end of the file - the whole thing is a comment
5275                 if (this.trackComment) {
5276                     loc.end = {
5277                         line: this.lineNumber,
5278                         column: this.index - this.lineStart
5279                     };
5280                     var entry = {
5281                         multiLine: true,
5282                         slice: [start + 2, this.index],
5283                         range: [start, this.index],
5284                         loc: loc
5285                     };
5286                     comments.push(entry);
5287                 }
5288                 this.tolerateUnexpectedToken();
5289                 return comments;
5290             };
5291             Scanner.prototype.scanComments = function () {
5292                 var comments;
5293                 if (this.trackComment) {
5294                     comments = [];
5295                 }
5296                 var start = (this.index === 0);
5297                 while (!this.eof()) {
5298                     var ch = this.source.charCodeAt(this.index);
5299                     if (character_1.Character.isWhiteSpace(ch)) {
5300                         ++this.index;
5301                     }
5302                     else if (character_1.Character.isLineTerminator(ch)) {
5303                         ++this.index;
5304                         if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
5305                             ++this.index;
5306                         }
5307                         ++this.lineNumber;
5308                         this.lineStart = this.index;
5309                         start = true;
5310                     }
5311                     else if (ch === 0x2F) {
5312                         ch = this.source.charCodeAt(this.index + 1);
5313                         if (ch === 0x2F) {
5314                             this.index += 2;
5315                             var comment = this.skipSingleLineComment(2);
5316                             if (this.trackComment) {
5317                                 comments = comments.concat(comment);
5318                             }
5319                             start = true;
5320                         }
5321                         else if (ch === 0x2A) {
5322                             this.index += 2;
5323                             var comment = this.skipMultiLineComment();
5324                             if (this.trackComment) {
5325                                 comments = comments.concat(comment);
5326                             }
5327                         }
5328                         else {
5329                             break;
5330                         }
5331                     }
5332                     else if (start && ch === 0x2D) {
5333                         // U+003E is '>'
5334                         if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
5335                             // '-->' is a single-line comment
5336                             this.index += 3;
5337                             var comment = this.skipSingleLineComment(3);
5338                             if (this.trackComment) {
5339                                 comments = comments.concat(comment);
5340                             }
5341                         }
5342                         else {
5343                             break;
5344                         }
5345                     }
5346                     else if (ch === 0x3C && !this.isModule) {
5347                         if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
5348                             this.index += 4; // `<!--`
5349                             var comment = this.skipSingleLineComment(4);
5350                             if (this.trackComment) {
5351                                 comments = comments.concat(comment);
5352                             }
5353                         }
5354                         else {
5355                             break;
5356                         }
5357                     }
5358                     else {
5359                         break;
5360                     }
5361                 }
5362                 return comments;
5363             };
5364             // https://tc39.github.io/ecma262/#sec-future-reserved-words
5365             Scanner.prototype.isFutureReservedWord = function (id) {
5366                 switch (id) {
5367                     case 'enum':
5368                     case 'export':
5369                     case 'import':
5370                     case 'super':
5371                         return true;
5372                     default:
5373                         return false;
5374                 }
5375             };
5376             Scanner.prototype.isStrictModeReservedWord = function (id) {
5377                 switch (id) {
5378                     case 'implements':
5379                     case 'interface':
5380                     case 'package':
5381                     case 'private':
5382                     case 'protected':
5383                     case 'public':
5384                     case 'static':
5385                     case 'yield':
5386                     case 'let':
5387                         return true;
5388                     default:
5389                         return false;
5390                 }
5391             };
5392             Scanner.prototype.isRestrictedWord = function (id) {
5393                 return id === 'eval' || id === 'arguments';
5394             };
5395             // https://tc39.github.io/ecma262/#sec-keywords
5396             Scanner.prototype.isKeyword = function (id) {
5397                 switch (id.length) {
5398                     case 2:
5399                         return (id === 'if') || (id === 'in') || (id === 'do');
5400                     case 3:
5401                         return (id === 'var') || (id === 'for') || (id === 'new') ||
5402                             (id === 'try') || (id === 'let');
5403                     case 4:
5404                         return (id === 'this') || (id === 'else') || (id === 'case') ||
5405                             (id === 'void') || (id === 'with') || (id === 'enum');
5406                     case 5:
5407                         return (id === 'while') || (id === 'break') || (id === 'catch') ||
5408                             (id === 'throw') || (id === 'const') || (id === 'yield') ||
5409                             (id === 'class') || (id === 'super');
5410                     case 6:
5411                         return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
5412                             (id === 'switch') || (id === 'export') || (id === 'import');
5413                     case 7:
5414                         return (id === 'default') || (id === 'finally') || (id === 'extends');
5415                     case 8:
5416                         return (id === 'function') || (id === 'continue') || (id === 'debugger');
5417                     case 10:
5418                         return (id === 'instanceof');
5419                     default:
5420                         return false;
5421                 }
5422             };
5423             Scanner.prototype.codePointAt = function (i) {
5424                 var cp = this.source.charCodeAt(i);
5425                 if (cp >= 0xD800 && cp <= 0xDBFF) {
5426                     var second = this.source.charCodeAt(i + 1);
5427                     if (second >= 0xDC00 && second <= 0xDFFF) {
5428                         var first = cp;
5429                         cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
5430                     }
5431                 }
5432                 return cp;
5433             };
5434             Scanner.prototype.scanHexEscape = function (prefix) {
5435                 var len = (prefix === 'u') ? 4 : 2;
5436                 var code = 0;
5437                 for (var i = 0; i < len; ++i) {
5438                     if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
5439                         code = code * 16 + hexValue(this.source[this.index++]);
5440                     }
5441                     else {
5442                         return null;
5443                     }
5444                 }
5445                 return String.fromCharCode(code);
5446             };
5447             Scanner.prototype.scanUnicodeCodePointEscape = function () {
5448                 var ch = this.source[this.index];
5449                 var code = 0;
5450                 // At least, one hex digit is required.
5451                 if (ch === '}') {
5452                     this.throwUnexpectedToken();
5453                 }
5454                 while (!this.eof()) {
5455                     ch = this.source[this.index++];
5456                     if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
5457                         break;
5458                     }
5459                     code = code * 16 + hexValue(ch);
5460                 }
5461                 if (code > 0x10FFFF || ch !== '}') {
5462                     this.throwUnexpectedToken();
5463                 }
5464                 return character_1.Character.fromCodePoint(code);
5465             };
5466             Scanner.prototype.getIdentifier = function () {
5467                 var start = this.index++;
5468                 while (!this.eof()) {
5469                     var ch = this.source.charCodeAt(this.index);
5470                     if (ch === 0x5C) {
5471                         // Blackslash (U+005C) marks Unicode escape sequence.
5472                         this.index = start;
5473                         return this.getComplexIdentifier();
5474                     }
5475                     else if (ch >= 0xD800 && ch < 0xDFFF) {
5476                         // Need to handle surrogate pairs.
5477                         this.index = start;
5478                         return this.getComplexIdentifier();
5479                     }
5480                     if (character_1.Character.isIdentifierPart(ch)) {
5481                         ++this.index;
5482                     }
5483                     else {
5484                         break;
5485                     }
5486                 }
5487                 return this.source.slice(start, this.index);
5488             };
5489             Scanner.prototype.getComplexIdentifier = function () {
5490                 var cp = this.codePointAt(this.index);
5491                 var id = character_1.Character.fromCodePoint(cp);
5492                 this.index += id.length;
5493                 // '\u' (U+005C, U+0075) denotes an escaped character.
5494                 var ch;
5495                 if (cp === 0x5C) {
5496                     if (this.source.charCodeAt(this.index) !== 0x75) {
5497                         this.throwUnexpectedToken();
5498                     }
5499                     ++this.index;
5500                     if (this.source[this.index] === '{') {
5501                         ++this.index;
5502                         ch = this.scanUnicodeCodePointEscape();
5503                     }
5504                     else {
5505                         ch = this.scanHexEscape('u');
5506                         if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
5507                             this.throwUnexpectedToken();
5508                         }
5509                     }
5510                     id = ch;
5511                 }
5512                 while (!this.eof()) {
5513                     cp = this.codePointAt(this.index);
5514                     if (!character_1.Character.isIdentifierPart(cp)) {
5515                         break;
5516                     }
5517                     ch = character_1.Character.fromCodePoint(cp);
5518                     id += ch;
5519                     this.index += ch.length;
5520                     // '\u' (U+005C, U+0075) denotes an escaped character.
5521                     if (cp === 0x5C) {
5522                         id = id.substr(0, id.length - 1);
5523                         if (this.source.charCodeAt(this.index) !== 0x75) {
5524                             this.throwUnexpectedToken();
5525                         }
5526                         ++this.index;
5527                         if (this.source[this.index] === '{') {
5528                             ++this.index;
5529                             ch = this.scanUnicodeCodePointEscape();
5530                         }
5531                         else {
5532                             ch = this.scanHexEscape('u');
5533                             if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
5534                                 this.throwUnexpectedToken();
5535                             }
5536                         }
5537                         id += ch;
5538                     }
5539                 }
5540                 return id;
5541             };
5542             Scanner.prototype.octalToDecimal = function (ch) {
5543                 // \0 is not octal escape sequence
5544                 var octal = (ch !== '0');
5545                 var code = octalValue(ch);
5546                 if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
5547                     octal = true;
5548                     code = code * 8 + octalValue(this.source[this.index++]);
5549                     // 3 digits are only allowed when string starts
5550                     // with 0, 1, 2, 3
5551                     if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
5552                         code = code * 8 + octalValue(this.source[this.index++]);
5553                     }
5554                 }
5555                 return {
5556                     code: code,
5557                     octal: octal
5558                 };
5559             };
5560             // https://tc39.github.io/ecma262/#sec-names-and-keywords
5561             Scanner.prototype.scanIdentifier = function () {
5562                 var type;
5563                 var start = this.index;
5564                 // Backslash (U+005C) starts an escaped character.
5565                 var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();
5566                 // There is no keyword or literal with only one character.
5567                 // Thus, it must be an identifier.
5568                 if (id.length === 1) {
5569                     type = 3 /* Identifier */;
5570                 }
5571                 else if (this.isKeyword(id)) {
5572                     type = 4 /* Keyword */;
5573                 }
5574                 else if (id === 'null') {
5575                     type = 5 /* NullLiteral */;
5576                 }
5577                 else if (id === 'true' || id === 'false') {
5578                     type = 1 /* BooleanLiteral */;
5579                 }
5580                 else {
5581                     type = 3 /* Identifier */;
5582                 }
5583                 if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {
5584                     var restore = this.index;
5585                     this.index = start;
5586                     this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
5587                     this.index = restore;
5588                 }
5589                 return {
5590                     type: type,
5591                     value: id,
5592                     lineNumber: this.lineNumber,
5593                     lineStart: this.lineStart,
5594                     start: start,
5595                     end: this.index
5596                 };
5597             };
5598             // https://tc39.github.io/ecma262/#sec-punctuators
5599             Scanner.prototype.scanPunctuator = function () {
5600                 var start = this.index;
5601                 // Check for most common single-character punctuators.
5602                 var str = this.source[this.index];
5603                 switch (str) {
5604                     case '(':
5605                     case '{':
5606                         if (str === '{') {
5607                             this.curlyStack.push('{');
5608                         }
5609                         ++this.index;
5610                         break;
5611                     case '.':
5612                         ++this.index;
5613                         if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
5614                             // Spread operator: ...
5615                             this.index += 2;
5616                             str = '...';
5617                         }
5618                         break;
5619                     case '}':
5620                         ++this.index;
5621                         this.curlyStack.pop();
5622                         break;
5623                     case ')':
5624                     case ';':
5625                     case ',':
5626                     case '[':
5627                     case ']':
5628                     case ':':
5629                     case '?':
5630                     case '~':
5631                         ++this.index;
5632                         break;
5633                     default:
5634                         // 4-character punctuator.
5635                         str = this.source.substr(this.index, 4);
5636                         if (str === '>>>=') {
5637                             this.index += 4;
5638                         }
5639                         else {
5640                             // 3-character punctuators.
5641                             str = str.substr(0, 3);
5642                             if (str === '===' || str === '!==' || str === '>>>' ||
5643                                 str === '<<=' || str === '>>=' || str === '**=') {
5644                                 this.index += 3;
5645                             }
5646                             else {
5647                                 // 2-character punctuators.
5648                                 str = str.substr(0, 2);
5649                                 if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
5650                                     str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
5651                                     str === '++' || str === '--' || str === '<<' || str === '>>' ||
5652                                     str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
5653                                     str === '<=' || str === '>=' || str === '=>' || str === '**') {
5654                                     this.index += 2;
5655                                 }
5656                                 else {
5657                                     // 1-character punctuators.
5658                                     str = this.source[this.index];
5659                                     if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
5660                                         ++this.index;
5661                                     }
5662                                 }
5663                             }
5664                         }
5665                 }
5666                 if (this.index === start) {
5667                     this.throwUnexpectedToken();
5668                 }
5669                 return {
5670                     type: 7 /* Punctuator */,
5671                     value: str,
5672                     lineNumber: this.lineNumber,
5673                     lineStart: this.lineStart,
5674                     start: start,
5675                     end: this.index
5676                 };
5677             };
5678             // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
5679             Scanner.prototype.scanHexLiteral = function (start) {
5680                 var num = '';
5681                 while (!this.eof()) {
5682                     if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
5683                         break;
5684                     }
5685                     num += this.source[this.index++];
5686                 }
5687                 if (num.length === 0) {
5688                     this.throwUnexpectedToken();
5689                 }
5690                 if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
5691                     this.throwUnexpectedToken();
5692                 }
5693                 return {
5694                     type: 6 /* NumericLiteral */,
5695                     value: parseInt('0x' + num, 16),
5696                     lineNumber: this.lineNumber,
5697                     lineStart: this.lineStart,
5698                     start: start,
5699                     end: this.index
5700                 };
5701             };
5702             Scanner.prototype.scanBinaryLiteral = function (start) {
5703                 var num = '';
5704                 var ch;
5705                 while (!this.eof()) {
5706                     ch = this.source[this.index];
5707                     if (ch !== '0' && ch !== '1') {
5708                         break;
5709                     }
5710                     num += this.source[this.index++];
5711                 }
5712                 if (num.length === 0) {
5713                     // only 0b or 0B
5714                     this.throwUnexpectedToken();
5715                 }
5716                 if (!this.eof()) {
5717                     ch = this.source.charCodeAt(this.index);
5718                     /* istanbul ignore else */
5719                     if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
5720                         this.throwUnexpectedToken();
5721                     }
5722                 }
5723                 return {
5724                     type: 6 /* NumericLiteral */,
5725                     value: parseInt(num, 2),
5726                     lineNumber: this.lineNumber,
5727                     lineStart: this.lineStart,
5728                     start: start,
5729                     end: this.index
5730                 };
5731             };
5732             Scanner.prototype.scanOctalLiteral = function (prefix, start) {
5733                 var num = '';
5734                 var octal = false;
5735                 if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
5736                     octal = true;
5737                     num = '0' + this.source[this.index++];
5738                 }
5739                 else {
5740                     ++this.index;
5741                 }
5742                 while (!this.eof()) {
5743                     if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
5744                         break;
5745                     }
5746                     num += this.source[this.index++];
5747                 }
5748                 if (!octal && num.length === 0) {
5749                     // only 0o or 0O
5750                     this.throwUnexpectedToken();
5751                 }
5752                 if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
5753                     this.throwUnexpectedToken();
5754                 }
5755                 return {
5756                     type: 6 /* NumericLiteral */,
5757                     value: parseInt(num, 8),
5758                     octal: octal,
5759                     lineNumber: this.lineNumber,
5760                     lineStart: this.lineStart,
5761                     start: start,
5762                     end: this.index
5763                 };
5764             };
5765             Scanner.prototype.isImplicitOctalLiteral = function () {
5766                 // Implicit octal, unless there is a non-octal digit.
5767                 // (Annex B.1.1 on Numeric Literals)
5768                 for (var i = this.index + 1; i < this.length; ++i) {
5769                     var ch = this.source[i];
5770                     if (ch === '8' || ch === '9') {
5771                         return false;
5772                     }
5773                     if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
5774                         return true;
5775                     }
5776                 }
5777                 return true;
5778             };
5779             Scanner.prototype.scanNumericLiteral = function () {
5780                 var start = this.index;
5781                 var ch = this.source[start];
5782                 assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
5783                 var num = '';
5784                 if (ch !== '.') {
5785                     num = this.source[this.index++];
5786                     ch = this.source[this.index];
5787                     // Hex number starts with '0x'.
5788                     // Octal number starts with '0'.
5789                     // Octal number in ES6 starts with '0o'.
5790                     // Binary number in ES6 starts with '0b'.
5791                     if (num === '0') {
5792                         if (ch === 'x' || ch === 'X') {
5793                             ++this.index;
5794                             return this.scanHexLiteral(start);
5795                         }
5796                         if (ch === 'b' || ch === 'B') {
5797                             ++this.index;
5798                             return this.scanBinaryLiteral(start);
5799                         }
5800                         if (ch === 'o' || ch === 'O') {
5801                             return this.scanOctalLiteral(ch, start);
5802                         }
5803                         if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
5804                             if (this.isImplicitOctalLiteral()) {
5805                                 return this.scanOctalLiteral(ch, start);
5806                             }
5807                         }
5808                     }
5809                     while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
5810                         num += this.source[this.index++];
5811                     }
5812                     ch = this.source[this.index];
5813                 }
5814                 if (ch === '.') {
5815                     num += this.source[this.index++];
5816                     while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
5817                         num += this.source[this.index++];
5818                     }
5819                     ch = this.source[this.index];
5820                 }
5821                 if (ch === 'e' || ch === 'E') {
5822                     num += this.source[this.index++];
5823                     ch = this.source[this.index];
5824                     if (ch === '+' || ch === '-') {
5825                         num += this.source[this.index++];
5826                     }
5827                     if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
5828                         while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
5829                             num += this.source[this.index++];
5830                         }
5831                     }
5832                     else {
5833                         this.throwUnexpectedToken();
5834                     }
5835                 }
5836                 if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
5837                     this.throwUnexpectedToken();
5838                 }
5839                 return {
5840                     type: 6 /* NumericLiteral */,
5841                     value: parseFloat(num),
5842                     lineNumber: this.lineNumber,
5843                     lineStart: this.lineStart,
5844                     start: start,
5845                     end: this.index
5846                 };
5847             };
5848             // https://tc39.github.io/ecma262/#sec-literals-string-literals
5849             Scanner.prototype.scanStringLiteral = function () {
5850                 var start = this.index;
5851                 var quote = this.source[start];
5852                 assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
5853                 ++this.index;
5854                 var octal = false;
5855                 var str = '';
5856                 while (!this.eof()) {
5857                     var ch = this.source[this.index++];
5858                     if (ch === quote) {
5859                         quote = '';
5860                         break;
5861                     }
5862                     else if (ch === '\\') {
5863                         ch = this.source[this.index++];
5864                         if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
5865                             switch (ch) {
5866                                 case 'u':
5867                                     if (this.source[this.index] === '{') {
5868                                         ++this.index;
5869                                         str += this.scanUnicodeCodePointEscape();
5870                                     }
5871                                     else {
5872                                         var unescaped_1 = this.scanHexEscape(ch);
5873                                         if (unescaped_1 === null) {
5874                                             this.throwUnexpectedToken();
5875                                         }
5876                                         str += unescaped_1;
5877                                     }
5878                                     break;
5879                                 case 'x':
5880                                     var unescaped = this.scanHexEscape(ch);
5881                                     if (unescaped === null) {
5882                                         this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
5883                                     }
5884                                     str += unescaped;
5885                                     break;
5886                                 case 'n':
5887                                     str += '\n';
5888                                     break;
5889                                 case 'r':
5890                                     str += '\r';
5891                                     break;
5892                                 case 't':
5893                                     str += '\t';
5894                                     break;
5895                                 case 'b':
5896                                     str += '\b';
5897                                     break;
5898                                 case 'f':
5899                                     str += '\f';
5900                                     break;
5901                                 case 'v':
5902                                     str += '\x0B';
5903                                     break;
5904                                 case '8':
5905                                 case '9':
5906                                     str += ch;
5907                                     this.tolerateUnexpectedToken();
5908                                     break;
5909                                 default:
5910                                     if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
5911                                         var octToDec = this.octalToDecimal(ch);
5912                                         octal = octToDec.octal || octal;
5913                                         str += String.fromCharCode(octToDec.code);
5914                                     }
5915                                     else {
5916                                         str += ch;
5917                                     }
5918                                     break;
5919                             }
5920                         }
5921                         else {
5922                             ++this.lineNumber;
5923                             if (ch === '\r' && this.source[this.index] === '\n') {
5924                                 ++this.index;
5925                             }
5926                             this.lineStart = this.index;
5927                         }
5928                     }
5929                     else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
5930                         break;
5931                     }
5932                     else {
5933                         str += ch;
5934                     }
5935                 }
5936                 if (quote !== '') {
5937                     this.index = start;
5938                     this.throwUnexpectedToken();
5939                 }
5940                 return {
5941                     type: 8 /* StringLiteral */,
5942                     value: str,
5943                     octal: octal,
5944                     lineNumber: this.lineNumber,
5945                     lineStart: this.lineStart,
5946                     start: start,
5947                     end: this.index
5948                 };
5949             };
5950             // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
5951             Scanner.prototype.scanTemplate = function () {
5952                 var cooked = '';
5953                 var terminated = false;
5954                 var start = this.index;
5955                 var head = (this.source[start] === '`');
5956                 var tail = false;
5957                 var rawOffset = 2;
5958                 ++this.index;
5959                 while (!this.eof()) {
5960                     var ch = this.source[this.index++];
5961                     if (ch === '`') {
5962                         rawOffset = 1;
5963                         tail = true;
5964                         terminated = true;
5965                         break;
5966                     }
5967                     else if (ch === '$') {
5968                         if (this.source[this.index] === '{') {
5969                             this.curlyStack.push('${');
5970                             ++this.index;
5971                             terminated = true;
5972                             break;
5973                         }
5974                         cooked += ch;
5975                     }
5976                     else if (ch === '\\') {
5977                         ch = this.source[this.index++];
5978                         if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
5979                             switch (ch) {
5980                                 case 'n':
5981                                     cooked += '\n';
5982                                     break;
5983                                 case 'r':
5984                                     cooked += '\r';
5985                                     break;
5986                                 case 't':
5987                                     cooked += '\t';
5988                                     break;
5989                                 case 'u':
5990                                     if (this.source[this.index] === '{') {
5991                                         ++this.index;
5992                                         cooked += this.scanUnicodeCodePointEscape();
5993                                     }
5994                                     else {
5995                                         var restore = this.index;
5996                                         var unescaped_2 = this.scanHexEscape(ch);
5997                                         if (unescaped_2 !== null) {
5998                                             cooked += unescaped_2;
5999                                         }
6000                                         else {
6001                                             this.index = restore;
6002                                             cooked += ch;
6003                                         }
6004                                     }
6005                                     break;
6006                                 case 'x':
6007                                     var unescaped = this.scanHexEscape(ch);
6008                                     if (unescaped === null) {
6009                                         this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
6010                                     }
6011                                     cooked += unescaped;
6012                                     break;
6013                                 case 'b':
6014                                     cooked += '\b';
6015                                     break;
6016                                 case 'f':
6017                                     cooked += '\f';
6018                                     break;
6019                                 case 'v':
6020                                     cooked += '\v';
6021                                     break;
6022                                 default:
6023                                     if (ch === '0') {
6024                                         if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
6025                                             // Illegal: \01 \02 and so on
6026                                             this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
6027                                         }
6028                                         cooked += '\0';
6029                                     }
6030                                     else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
6031                                         // Illegal: \1 \2
6032                                         this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
6033                                     }
6034                                     else {
6035                                         cooked += ch;
6036                                     }
6037                                     break;
6038                             }
6039                         }
6040                         else {
6041                             ++this.lineNumber;
6042                             if (ch === '\r' && this.source[this.index] === '\n') {
6043                                 ++this.index;
6044                             }
6045                             this.lineStart = this.index;
6046                         }
6047                     }
6048                     else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
6049                         ++this.lineNumber;
6050                         if (ch === '\r' && this.source[this.index] === '\n') {
6051                             ++this.index;
6052                         }
6053                         this.lineStart = this.index;
6054                         cooked += '\n';
6055                     }
6056                     else {
6057                         cooked += ch;
6058                     }
6059                 }
6060                 if (!terminated) {
6061                     this.throwUnexpectedToken();
6062                 }
6063                 if (!head) {
6064                     this.curlyStack.pop();
6065                 }
6066                 return {
6067                     type: 10 /* Template */,
6068                     value: this.source.slice(start + 1, this.index - rawOffset),
6069                     cooked: cooked,
6070                     head: head,
6071                     tail: tail,
6072                     lineNumber: this.lineNumber,
6073                     lineStart: this.lineStart,
6074                     start: start,
6075                     end: this.index
6076                 };
6077             };
6078             // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
6079             Scanner.prototype.testRegExp = function (pattern, flags) {
6080                 // The BMP character to use as a replacement for astral symbols when
6081                 // translating an ES6 "u"-flagged pattern to an ES5-compatible
6082                 // approximation.
6083                 // Note: replacing with '\uFFFF' enables false positives in unlikely
6084                 // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
6085                 // pattern that would not be detected by this substitution.
6086                 var astralSubstitute = '\uFFFF';
6087                 var tmp = pattern;
6088                 var self = this;
6089                 if (flags.indexOf('u') >= 0) {
6090                     tmp = tmp
6091                         .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
6092                         var codePoint = parseInt($1 || $2, 16);
6093                         if (codePoint > 0x10FFFF) {
6094                             self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
6095                         }
6096                         if (codePoint <= 0xFFFF) {
6097                             return String.fromCharCode(codePoint);
6098                         }
6099                         return astralSubstitute;
6100                     })
6101                         .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
6102                 }
6103                 // First, detect invalid regular expressions.
6104                 try {
6105                     RegExp(tmp);
6106                 }
6107                 catch (e) {
6108                     this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
6109                 }
6110                 // Return a regular expression object for this pattern-flag pair, or
6111                 // `null` in case the current environment doesn't support the flags it
6112                 // uses.
6113                 try {
6114                     return new RegExp(pattern, flags);
6115                 }
6116                 catch (exception) {
6117                     /* istanbul ignore next */
6118                     return null;
6119                 }
6120             };
6121             Scanner.prototype.scanRegExpBody = function () {
6122                 var ch = this.source[this.index];
6123                 assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
6124                 var str = this.source[this.index++];
6125                 var classMarker = false;
6126                 var terminated = false;
6127                 while (!this.eof()) {
6128                     ch = this.source[this.index++];
6129                     str += ch;
6130                     if (ch === '\\') {
6131                         ch = this.source[this.index++];
6132                         // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
6133                         if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
6134                             this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
6135                         }
6136                         str += ch;
6137                     }
6138                     else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
6139                         this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
6140                     }
6141                     else if (classMarker) {
6142                         if (ch === ']') {
6143                             classMarker = false;
6144                         }
6145                     }
6146                     else {
6147                         if (ch === '/') {
6148                             terminated = true;
6149                             break;
6150                         }
6151                         else if (ch === '[') {
6152                             classMarker = true;
6153                         }
6154                     }
6155                 }
6156                 if (!terminated) {
6157                     this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
6158                 }
6159                 // Exclude leading and trailing slash.
6160                 return str.substr(1, str.length - 2);
6161             };
6162             Scanner.prototype.scanRegExpFlags = function () {
6163                 var str = '';
6164                 var flags = '';
6165                 while (!this.eof()) {
6166                     var ch = this.source[this.index];
6167                     if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
6168                         break;
6169                     }
6170                     ++this.index;
6171                     if (ch === '\\' && !this.eof()) {
6172                         ch = this.source[this.index];
6173                         if (ch === 'u') {
6174                             ++this.index;
6175                             var restore = this.index;
6176                             var char = this.scanHexEscape('u');
6177                             if (char !== null) {
6178                                 flags += char;
6179                                 for (str += '\\u'; restore < this.index; ++restore) {
6180                                     str += this.source[restore];
6181                                 }
6182                             }
6183                             else {
6184                                 this.index = restore;
6185                                 flags += 'u';
6186                                 str += '\\u';
6187                             }
6188                             this.tolerateUnexpectedToken();
6189                         }
6190                         else {
6191                             str += '\\';
6192                             this.tolerateUnexpectedToken();
6193                         }
6194                     }
6195                     else {
6196                         flags += ch;
6197                         str += ch;
6198                     }
6199                 }
6200                 return flags;
6201             };
6202             Scanner.prototype.scanRegExp = function () {
6203                 var start = this.index;
6204                 var pattern = this.scanRegExpBody();
6205                 var flags = this.scanRegExpFlags();
6206                 var value = this.testRegExp(pattern, flags);
6207                 return {
6208                     type: 9 /* RegularExpression */,
6209                     value: '',
6210                     pattern: pattern,
6211                     flags: flags,
6212                     regex: value,
6213                     lineNumber: this.lineNumber,
6214                     lineStart: this.lineStart,
6215                     start: start,
6216                     end: this.index
6217                 };
6218             };
6219             Scanner.prototype.lex = function () {
6220                 if (this.eof()) {
6221                     return {
6222                         type: 2 /* EOF */,
6223                         value: '',
6224                         lineNumber: this.lineNumber,
6225                         lineStart: this.lineStart,
6226                         start: this.index,
6227                         end: this.index
6228                     };
6229                 }
6230                 var cp = this.source.charCodeAt(this.index);
6231                 if (character_1.Character.isIdentifierStart(cp)) {
6232                     return this.scanIdentifier();
6233                 }
6234                 // Very common: ( and ) and ;
6235                 if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
6236                     return this.scanPunctuator();
6237                 }
6238                 // String literal starts with single quote (U+0027) or double quote (U+0022).
6239                 if (cp === 0x27 || cp === 0x22) {
6240                     return this.scanStringLiteral();
6241                 }
6242                 // Dot (.) U+002E can also start a floating-point number, hence the need
6243                 // to check the next character.
6244                 if (cp === 0x2E) {
6245                     if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
6246                         return this.scanNumericLiteral();
6247                     }
6248                     return this.scanPunctuator();
6249                 }
6250                 if (character_1.Character.isDecimalDigit(cp)) {
6251                     return this.scanNumericLiteral();
6252                 }
6253                 // Template literals start with ` (U+0060) for template head
6254                 // or } (U+007D) for template middle or template tail.
6255                 if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {
6256                     return this.scanTemplate();
6257                 }
6258                 // Possible identifier start in a surrogate pair.
6259                 if (cp >= 0xD800 && cp < 0xDFFF) {
6260                     if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
6261                         return this.scanIdentifier();
6262                     }
6263                 }
6264                 return this.scanPunctuator();
6265             };
6266             return Scanner;
6267         }());
6268         exports.Scanner = Scanner;
6269
6270
6271 /***/ },
6272 /* 13 */
6273 /***/ function(module, exports) {
6274
6275         "use strict";
6276         Object.defineProperty(exports, "__esModule", { value: true });
6277         exports.TokenName = {};
6278         exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';
6279         exports.TokenName[2 /* EOF */] = '<end>';
6280         exports.TokenName[3 /* Identifier */] = 'Identifier';
6281         exports.TokenName[4 /* Keyword */] = 'Keyword';
6282         exports.TokenName[5 /* NullLiteral */] = 'Null';
6283         exports.TokenName[6 /* NumericLiteral */] = 'Numeric';
6284         exports.TokenName[7 /* Punctuator */] = 'Punctuator';
6285         exports.TokenName[8 /* StringLiteral */] = 'String';
6286         exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';
6287         exports.TokenName[10 /* Template */] = 'Template';
6288
6289
6290 /***/ },
6291 /* 14 */
6292 /***/ function(module, exports) {
6293
6294         "use strict";
6295         // Generated by generate-xhtml-entities.js. DO NOT MODIFY!
6296         Object.defineProperty(exports, "__esModule", { value: true });
6297         exports.XHTMLEntities = {
6298             quot: '\u0022',
6299             amp: '\u0026',
6300             apos: '\u0027',
6301             gt: '\u003E',
6302             nbsp: '\u00A0',
6303             iexcl: '\u00A1',
6304             cent: '\u00A2',
6305             pound: '\u00A3',
6306             curren: '\u00A4',
6307             yen: '\u00A5',
6308             brvbar: '\u00A6',
6309             sect: '\u00A7',
6310             uml: '\u00A8',
6311             copy: '\u00A9',
6312             ordf: '\u00AA',
6313             laquo: '\u00AB',
6314             not: '\u00AC',
6315             shy: '\u00AD',
6316             reg: '\u00AE',
6317             macr: '\u00AF',
6318             deg: '\u00B0',
6319             plusmn: '\u00B1',
6320             sup2: '\u00B2',
6321             sup3: '\u00B3',
6322             acute: '\u00B4',
6323             micro: '\u00B5',
6324             para: '\u00B6',
6325             middot: '\u00B7',
6326             cedil: '\u00B8',
6327             sup1: '\u00B9',
6328             ordm: '\u00BA',
6329             raquo: '\u00BB',
6330             frac14: '\u00BC',
6331             frac12: '\u00BD',
6332             frac34: '\u00BE',
6333             iquest: '\u00BF',
6334             Agrave: '\u00C0',
6335             Aacute: '\u00C1',
6336             Acirc: '\u00C2',
6337             Atilde: '\u00C3',
6338             Auml: '\u00C4',
6339             Aring: '\u00C5',
6340             AElig: '\u00C6',
6341             Ccedil: '\u00C7',
6342             Egrave: '\u00C8',
6343             Eacute: '\u00C9',
6344             Ecirc: '\u00CA',
6345             Euml: '\u00CB',
6346             Igrave: '\u00CC',
6347             Iacute: '\u00CD',
6348             Icirc: '\u00CE',
6349             Iuml: '\u00CF',
6350             ETH: '\u00D0',
6351             Ntilde: '\u00D1',
6352             Ograve: '\u00D2',
6353             Oacute: '\u00D3',
6354             Ocirc: '\u00D4',
6355             Otilde: '\u00D5',
6356             Ouml: '\u00D6',
6357             times: '\u00D7',
6358             Oslash: '\u00D8',
6359             Ugrave: '\u00D9',
6360             Uacute: '\u00DA',
6361             Ucirc: '\u00DB',
6362             Uuml: '\u00DC',
6363             Yacute: '\u00DD',
6364             THORN: '\u00DE',
6365             szlig: '\u00DF',
6366             agrave: '\u00E0',
6367             aacute: '\u00E1',
6368             acirc: '\u00E2',
6369             atilde: '\u00E3',
6370             auml: '\u00E4',
6371             aring: '\u00E5',
6372             aelig: '\u00E6',
6373             ccedil: '\u00E7',
6374             egrave: '\u00E8',
6375             eacute: '\u00E9',
6376             ecirc: '\u00EA',
6377             euml: '\u00EB',
6378             igrave: '\u00EC',
6379             iacute: '\u00ED',
6380             icirc: '\u00EE',
6381             iuml: '\u00EF',
6382             eth: '\u00F0',
6383             ntilde: '\u00F1',
6384             ograve: '\u00F2',
6385             oacute: '\u00F3',
6386             ocirc: '\u00F4',
6387             otilde: '\u00F5',
6388             ouml: '\u00F6',
6389             divide: '\u00F7',
6390             oslash: '\u00F8',
6391             ugrave: '\u00F9',
6392             uacute: '\u00FA',
6393             ucirc: '\u00FB',
6394             uuml: '\u00FC',
6395             yacute: '\u00FD',
6396             thorn: '\u00FE',
6397             yuml: '\u00FF',
6398             OElig: '\u0152',
6399             oelig: '\u0153',
6400             Scaron: '\u0160',
6401             scaron: '\u0161',
6402             Yuml: '\u0178',
6403             fnof: '\u0192',
6404             circ: '\u02C6',
6405             tilde: '\u02DC',
6406             Alpha: '\u0391',
6407             Beta: '\u0392',
6408             Gamma: '\u0393',
6409             Delta: '\u0394',
6410             Epsilon: '\u0395',
6411             Zeta: '\u0396',
6412             Eta: '\u0397',
6413             Theta: '\u0398',
6414             Iota: '\u0399',
6415             Kappa: '\u039A',
6416             Lambda: '\u039B',
6417             Mu: '\u039C',
6418             Nu: '\u039D',
6419             Xi: '\u039E',
6420             Omicron: '\u039F',
6421             Pi: '\u03A0',
6422             Rho: '\u03A1',
6423             Sigma: '\u03A3',
6424             Tau: '\u03A4',
6425             Upsilon: '\u03A5',
6426             Phi: '\u03A6',
6427             Chi: '\u03A7',
6428             Psi: '\u03A8',
6429             Omega: '\u03A9',
6430             alpha: '\u03B1',
6431             beta: '\u03B2',
6432             gamma: '\u03B3',
6433             delta: '\u03B4',
6434             epsilon: '\u03B5',
6435             zeta: '\u03B6',
6436             eta: '\u03B7',
6437             theta: '\u03B8',
6438             iota: '\u03B9',
6439             kappa: '\u03BA',
6440             lambda: '\u03BB',
6441             mu: '\u03BC',
6442             nu: '\u03BD',
6443             xi: '\u03BE',
6444             omicron: '\u03BF',
6445             pi: '\u03C0',
6446             rho: '\u03C1',
6447             sigmaf: '\u03C2',
6448             sigma: '\u03C3',
6449             tau: '\u03C4',
6450             upsilon: '\u03C5',
6451             phi: '\u03C6',
6452             chi: '\u03C7',
6453             psi: '\u03C8',
6454             omega: '\u03C9',
6455             thetasym: '\u03D1',
6456             upsih: '\u03D2',
6457             piv: '\u03D6',
6458             ensp: '\u2002',
6459             emsp: '\u2003',
6460             thinsp: '\u2009',
6461             zwnj: '\u200C',
6462             zwj: '\u200D',
6463             lrm: '\u200E',
6464             rlm: '\u200F',
6465             ndash: '\u2013',
6466             mdash: '\u2014',
6467             lsquo: '\u2018',
6468             rsquo: '\u2019',
6469             sbquo: '\u201A',
6470             ldquo: '\u201C',
6471             rdquo: '\u201D',
6472             bdquo: '\u201E',
6473             dagger: '\u2020',
6474             Dagger: '\u2021',
6475             bull: '\u2022',
6476             hellip: '\u2026',
6477             permil: '\u2030',
6478             prime: '\u2032',
6479             Prime: '\u2033',
6480             lsaquo: '\u2039',
6481             rsaquo: '\u203A',
6482             oline: '\u203E',
6483             frasl: '\u2044',
6484             euro: '\u20AC',
6485             image: '\u2111',
6486             weierp: '\u2118',
6487             real: '\u211C',
6488             trade: '\u2122',
6489             alefsym: '\u2135',
6490             larr: '\u2190',
6491             uarr: '\u2191',
6492             rarr: '\u2192',
6493             darr: '\u2193',
6494             harr: '\u2194',
6495             crarr: '\u21B5',
6496             lArr: '\u21D0',
6497             uArr: '\u21D1',
6498             rArr: '\u21D2',
6499             dArr: '\u21D3',
6500             hArr: '\u21D4',
6501             forall: '\u2200',
6502             part: '\u2202',
6503             exist: '\u2203',
6504             empty: '\u2205',
6505             nabla: '\u2207',
6506             isin: '\u2208',
6507             notin: '\u2209',
6508             ni: '\u220B',
6509             prod: '\u220F',
6510             sum: '\u2211',
6511             minus: '\u2212',
6512             lowast: '\u2217',
6513             radic: '\u221A',
6514             prop: '\u221D',
6515             infin: '\u221E',
6516             ang: '\u2220',
6517             and: '\u2227',
6518             or: '\u2228',
6519             cap: '\u2229',
6520             cup: '\u222A',
6521             int: '\u222B',
6522             there4: '\u2234',
6523             sim: '\u223C',
6524             cong: '\u2245',
6525             asymp: '\u2248',
6526             ne: '\u2260',
6527             equiv: '\u2261',
6528             le: '\u2264',
6529             ge: '\u2265',
6530             sub: '\u2282',
6531             sup: '\u2283',
6532             nsub: '\u2284',
6533             sube: '\u2286',
6534             supe: '\u2287',
6535             oplus: '\u2295',
6536             otimes: '\u2297',
6537             perp: '\u22A5',
6538             sdot: '\u22C5',
6539             lceil: '\u2308',
6540             rceil: '\u2309',
6541             lfloor: '\u230A',
6542             rfloor: '\u230B',
6543             loz: '\u25CA',
6544             spades: '\u2660',
6545             clubs: '\u2663',
6546             hearts: '\u2665',
6547             diams: '\u2666',
6548             lang: '\u27E8',
6549             rang: '\u27E9'
6550         };
6551
6552
6553 /***/ },
6554 /* 15 */
6555 /***/ function(module, exports, __webpack_require__) {
6556
6557         "use strict";
6558         Object.defineProperty(exports, "__esModule", { value: true });
6559         var error_handler_1 = __webpack_require__(10);
6560         var scanner_1 = __webpack_require__(12);
6561         var token_1 = __webpack_require__(13);
6562         var Reader = (function () {
6563             function Reader() {
6564                 this.values = [];
6565                 this.curly = this.paren = -1;
6566             }
6567             // A function following one of those tokens is an expression.
6568             Reader.prototype.beforeFunctionExpression = function (t) {
6569                 return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
6570                     'return', 'case', 'delete', 'throw', 'void',
6571                     // assignment operators
6572                     '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',
6573                     '&=', '|=', '^=', ',',
6574                     // binary/unary operators
6575                     '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
6576                     '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
6577                     '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
6578             };
6579             // Determine if forward slash (/) is an operator or part of a regular expression
6580             // https://github.com/mozilla/sweet.js/wiki/design
6581             Reader.prototype.isRegexStart = function () {
6582                 var previous = this.values[this.values.length - 1];
6583                 var regex = (previous !== null);
6584                 switch (previous) {
6585                     case 'this':
6586                     case ']':
6587                         regex = false;
6588                         break;
6589                     case ')':
6590                         var keyword = this.values[this.paren - 1];
6591                         regex = (keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with');
6592                         break;
6593                     case '}':
6594                         // Dividing a function by anything makes little sense,
6595                         // but we have to check for that.
6596                         regex = false;
6597                         if (this.values[this.curly - 3] === 'function') {
6598                             // Anonymous function, e.g. function(){} /42
6599                             var check = this.values[this.curly - 4];
6600                             regex = check ? !this.beforeFunctionExpression(check) : false;
6601                         }
6602                         else if (this.values[this.curly - 4] === 'function') {
6603                             // Named function, e.g. function f(){} /42/
6604                             var check = this.values[this.curly - 5];
6605                             regex = check ? !this.beforeFunctionExpression(check) : true;
6606                         }
6607                         break;
6608                     default:
6609                         break;
6610                 }
6611                 return regex;
6612             };
6613             Reader.prototype.push = function (token) {
6614                 if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {
6615                     if (token.value === '{') {
6616                         this.curly = this.values.length;
6617                     }
6618                     else if (token.value === '(') {
6619                         this.paren = this.values.length;
6620                     }
6621                     this.values.push(token.value);
6622                 }
6623                 else {
6624                     this.values.push(null);
6625                 }
6626             };
6627             return Reader;
6628         }());
6629         var Tokenizer = (function () {
6630             function Tokenizer(code, config) {
6631                 this.errorHandler = new error_handler_1.ErrorHandler();
6632                 this.errorHandler.tolerant = config ? (typeof config.tolerant === 'boolean' && config.tolerant) : false;
6633                 this.scanner = new scanner_1.Scanner(code, this.errorHandler);
6634                 this.scanner.trackComment = config ? (typeof config.comment === 'boolean' && config.comment) : false;
6635                 this.trackRange = config ? (typeof config.range === 'boolean' && config.range) : false;
6636                 this.trackLoc = config ? (typeof config.loc === 'boolean' && config.loc) : false;
6637                 this.buffer = [];
6638                 this.reader = new Reader();
6639             }
6640             Tokenizer.prototype.errors = function () {
6641                 return this.errorHandler.errors;
6642             };
6643             Tokenizer.prototype.getNextToken = function () {
6644                 if (this.buffer.length === 0) {
6645                     var comments = this.scanner.scanComments();
6646                     if (this.scanner.trackComment) {
6647                         for (var i = 0; i < comments.length; ++i) {
6648                             var e = comments[i];
6649                             var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
6650                             var comment = {
6651                                 type: e.multiLine ? 'BlockComment' : 'LineComment',
6652                                 value: value
6653                             };
6654                             if (this.trackRange) {
6655                                 comment.range = e.range;
6656                             }
6657                             if (this.trackLoc) {
6658                                 comment.loc = e.loc;
6659                             }
6660                             this.buffer.push(comment);
6661                         }
6662                     }
6663                     if (!this.scanner.eof()) {
6664                         var loc = void 0;
6665                         if (this.trackLoc) {
6666                             loc = {
6667                                 start: {
6668                                     line: this.scanner.lineNumber,
6669                                     column: this.scanner.index - this.scanner.lineStart
6670                                 },
6671                                 end: {}
6672                             };
6673                         }
6674                         var startRegex = (this.scanner.source[this.scanner.index] === '/') && this.reader.isRegexStart();
6675                         var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();
6676                         this.reader.push(token);
6677                         var entry = {
6678                             type: token_1.TokenName[token.type],
6679                             value: this.scanner.source.slice(token.start, token.end)
6680                         };
6681                         if (this.trackRange) {
6682                             entry.range = [token.start, token.end];
6683                         }
6684                         if (this.trackLoc) {
6685                             loc.end = {
6686                                 line: this.scanner.lineNumber,
6687                                 column: this.scanner.index - this.scanner.lineStart
6688                             };
6689                             entry.loc = loc;
6690                         }
6691                         if (token.type === 9 /* RegularExpression */) {
6692                             var pattern = token.pattern;
6693                             var flags = token.flags;
6694                             entry.regex = { pattern: pattern, flags: flags };
6695                         }
6696                         this.buffer.push(entry);
6697                     }
6698                 }
6699                 return this.buffer.shift();
6700             };
6701             return Tokenizer;
6702         }());
6703         exports.Tokenizer = Tokenizer;
6704
6705
6706 /***/ }
6707 /******/ ])
6708 });
6709 ;