[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/codemirror/ -> esprima.js (source)

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


Generated: Tue Jul 14 01:00:03 2020 Cross-referenced by PHPXref 0.7.1