{"version":3,"sources":["webpack:////data/Redocly/redocly-default-template/node_modules/esprima/dist/esprima.js"],"names":["factory","modules","installedModules","__webpack_require__","moduleId","exports","module","id","loaded","call","m","c","p","Object","defineProperty","value","comment_handler_1","jsx_parser_1","parser_1","tokenizer_1","parse","code","options","delegate","commentHandler","proxyDelegate","node","metadata","visit","parserDelegate","collectComment","comment","attachComment","CommentHandler","attach","parser","isModule","sourceType","jsx","JSXParser","Parser","ast","parseModule","parseScript","comments","config","tokens","tolerant","errors","errorHandler","parsingOptions","tokenize","tokenizer","Tokenizer","token","getNextToken","push","e","tolerate","syntax_1","Syntax","version","this","stack","leading","trailing","prototype","insertInnerComments","type","BlockStatement","body","length","innerComments","i","entry","end","offset","start","unshift","splice","findTrailingComments","trailingComments","entry_1","firstComment","range","findLeadingComments","target","leadingComments","pop","visitNode","Program","visitComment","loc","AssignmentExpression","AssignmentPattern","ArrayExpression","ArrayPattern","ArrowFunctionExpression","AwaitExpression","BinaryExpression","BreakStatement","CallExpression","CatchClause","ClassBody","ClassDeclaration","ClassExpression","ConditionalExpression","ContinueStatement","DoWhileStatement","DebuggerStatement","EmptyStatement","ExportAllDeclaration","ExportDefaultDeclaration","ExportNamedDeclaration","ExportSpecifier","ExpressionStatement","ForStatement","ForOfStatement","ForInStatement","FunctionDeclaration","FunctionExpression","Identifier","IfStatement","ImportDeclaration","ImportDefaultSpecifier","ImportNamespaceSpecifier","ImportSpecifier","Literal","LabeledStatement","LogicalExpression","MemberExpression","MetaProperty","MethodDefinition","NewExpression","ObjectExpression","ObjectPattern","Property","RestElement","ReturnStatement","SequenceExpression","SpreadElement","Super","SwitchCase","SwitchStatement","TaggedTemplateExpression","TemplateElement","TemplateLiteral","ThisExpression","ThrowStatement","TryStatement","UnaryExpression","UpdateExpression","VariableDeclaration","VariableDeclarator","WhileStatement","WithStatement","YieldExpression","extendStatics","__extends","setPrototypeOf","__proto__","Array","d","b","hasOwnProperty","__","constructor","create","character_1","JSXNode","jsx_syntax_1","Node","token_1","xhtml_entities_1","getQualifiedElementName","elementName","qualifiedName","JSXSyntax","JSXIdentifier","name","JSXNamespacedName","ns","namespace","JSXMemberExpression","expr","object","property","TokenName","_super","parsePrimaryExpression","match","parseJSXRoot","startJSX","scanner","index","startMarker","lineNumber","line","lineStart","column","finishJSX","nextToken","reenterJSX","expectJSX","createJSXNode","collectComments","createJSXChildNode","scanXHTMLEntity","quote","result","valid","terminated","numeric","hex","eof","ch","source","Character","isDecimalDigit","charCodeAt","isHexDigit","str","substr","String","fromCharCode","parseInt","XHTMLEntities","lexJSX","cp","n1","n2","isIdentifierStart","isIdentifierPart","slice","lex","nextJSXToken","lastMarker","convertToken","nextJSXText","text","isLineTerminator","peekJSXToken","state","saveState","scanComments","next","restoreState","throwUnexpectedToken","matchJSX","parseJSXIdentifier","finalize","parseJSXElementName","name_1","parseJSXAttributeName","attributeName","identifier","name_2","parseJSXStringLiteralAttribute","raw","getTokenRaw","parseJSXExpressionAttribute","tolerateError","expression","parseAssignmentExpression","JSXExpressionContainer","parseJSXAttributeValue","parseJSXElement","parseJSXNameValueAttribute","JSXAttribute","parseJSXSpreadAttribute","argument","JSXSpreadAttribute","parseJSXAttributes","attributes","attribute","parseJSXOpeningElement","selfClosing","JSXOpeningElement","parseJSXBoundaryElement","name_3","JSXClosingElement","parseJSXEmptyExpression","JSXEmptyExpression","parseJSXExpressionContainer","parseJSXChildren","children","child","JSXText","container","parseComplexJSXElement","el","concat","element","opening","JSXElement","closing","open_1","isStartOfExpression","Regex","NonAsciiIdentifierStart","NonAsciiIdentifierPart","fromCodePoint","isWhiteSpace","indexOf","test","isOctalDigit","openingElement","closingElement","elements","params","generator","async","operator","left","right","AsyncArrowFunctionExpression","AsyncFunctionDeclaration","AsyncFunctionExpression","logical","label","callee","args","arguments","param","superClass","ComputedMemberExpression","computed","consequent","alternate","Directive","directive","declaration","specifiers","local","exported","each","init","update","imported","meta","key","kind","isStatic","Module","properties","method","shorthand","RegexLiteral","pattern","flags","regex","Script","expressions","StaticMemberExpression","discriminant","cases","tag","quasi","tail","quasis","block","handler","finalizer","prefix","declarations","assert_1","error_handler_1","messages_1","scanner_1","ErrorHandler","Scanner","trackComment","operatorPrecedence","lookahead","hasLineTerminator","context","allowIn","allowStrictDirective","allowYield","firstCoverInitializedNameError","isAssignmentTarget","isBindingElement","inFunctionBody","inIteration","inSwitch","labelSet","strict","throwError","messageFormat","values","_i","msg","replace","whole","idx","assert","createError","unexpectedTokenError","message","Messages","UnexpectedToken","UnexpectedEOS","UnexpectedIdentifier","UnexpectedNumber","UnexpectedString","UnexpectedTemplate","isFutureReservedWord","UnexpectedReserved","isStrictModeReservedWord","StrictReservedWord","lastMarkerLineStart","tolerateUnexpectedToken","multiLine","t","nextRegexToken","scanRegExp","createNode","startNode","lastLineStart","marker","expect","expectCommaSeparator","expectKeyword","keyword","matchKeyword","matchContextualKeyword","matchAssign","op","isolateCoverGrammar","parseFunction","previousIsBindingElement","previousIsAssignmentTarget","previousFirstCoverInitializedNameError","inheritCoverGrammar","consumeSemicolon","matchAsyncFunction","parseFunctionExpression","octal","StrictOctalLiteral","parseTemplateLiteral","parseGroupExpression","parseArrayInitializer","parseObjectInitializer","parseIdentifierName","parseClassExpression","parseSpreadElement","arg","parsePropertyMethod","previousStrict","previousAllowStrictDirective","simple","parseFunctionSourceElements","firstRestricted","stricted","parsePropertyMethodFunction","previousAllowYield","parseFormalParameters","parsePropertyMethodAsyncFunction","previousAwait","parseObjectPropertyKey","isPropertyKey","parseObjectProperty","hasProto","isAsync","lookaheadPropertyKey","qualifiedPropertyName","parseGetterMethod","parseSetterMethod","parseGeneratorMethod","DuplicateProtoProperty","parseTemplateHead","head","cooked","parseTemplateElement","parseExpression","reinterpretExpressionAsPattern","startToken","parseRestElement","arrow","parseArguments","isIdentifierName","parseNewExpression","parseLeftHandSideExpression","parseAsyncArgument","parseAsyncArguments","parseLeftHandSideExpressionAllowCall","maybeAsync","previousAllowIn","asyncArrow","parseSuper","parseUpdateExpression","parseUnaryExpression","isRestrictedWord","StrictLHSPrefix","InvalidLHSInAssignment","StrictLHSPostfix","parseAwaitExpression","StrictDelete","parseExponentiationExpression","binaryPrecedence","parseBinaryExpression","prec","markers","precedences","parseConditionalExpression","checkPatternParam","validateParam","reinterpretAsCoverFormalsList","paramSet","StrictParamDupe","parseYieldExpression","list","StrictLHSAssignment","parseStatementListItem","statement","IllegalExportDeclaration","parseExportDeclaration","IllegalImportDeclaration","parseImportDeclaration","parseLexicalDeclaration","inFor","parseFunctionDeclaration","parseClassDeclaration","isLexicalDeclaration","parseStatement","parseBlock","parseLexicalBinding","parsePattern","StrictVarName","DeclarationMissingInitializer","parseBindingList","parseBindingRestElement","parseArrayPattern","parsePatternWithDefault","parsePropertyPattern","keyToken","parseVariableIdentifier","parseObjectPattern","LetInLexicalBinding","parseVariableDeclaration","parseVariableDeclarationList","opt","parseVariableStatement","parseEmptyStatement","parseExpressionStatement","parseIfClause","StrictFunction","parseIfStatement","parseDoWhileStatement","previousInIteration","parseWhileStatement","parseForStatement","forIn","decl","ForInOfLoopInitializer","initStartToken","InvalidLHSInForIn","InvalidLHSInForLoop","initSeq","parseContinueStatement","UnknownLabel","IllegalContinue","parseBreakStatement","IllegalBreak","parseReturnStatement","IllegalReturn","parseWithStatement","StrictModeWith","parseSwitchCase","parseSwitchStatement","previousInSwitch","defaultFound","clause","MultipleDefaultsInSwitch","parseLabelledStatement","Redeclaration","GeneratorInLegacyContext","parseThrowStatement","NewlineAfterThrow","parseCatchClause","paramMap","DuplicateBinding","StrictCatchVariable","parseFinallyClause","parseTryStatement","NoCatchOrFinally","parseDebuggerStatement","parseDirectivePrologues","previousLabelSet","previousInFunctionBody","StrictParamName","enumerable","writable","configurable","DefaultRestParameter","ParameterAfterRestParameter","parseFormalParameter","identifierIsOptional","isGenerator","StrictFunctionName","previousAllowAwait","formalParameters","parseDirective","IllegalLanguageModeDirective","BadGetterArity","BadSetterArity","BadSetterRestParameter","parseClassElement","hasConstructor","punctuator","ConstructorIsAsync","StaticPrototype","ConstructorSpecialMethod","DuplicateConstructor","parseClassElementList","parseClassBody","elementList","classBody","parseModuleSpecifier","InvalidModuleSpecifier","parseImportSpecifier","parseNamedImports","parseImportDefaultSpecifier","parseImportNamespaceSpecifier","NoAsAfterImportNamespace","src","MissingFromClause","parseExportSpecifier","exportDeclaration","isExportFromIdentifier","condition","Error","recordError","error","constructError","base","col","description","InvalidEscapedReservedWord","InvalidHexEscapeSequence","InvalidRegExp","TemplateOctalLiteral","UnexpectedTokenIllegal","UnterminatedRegExp","hexValue","toLowerCase","octalValue","curlyStack","skipSingleLineComment","skipMultiLineComment","isKeyword","codePointAt","second","scanHexEscape","len","scanUnicodeCodePointEscape","getIdentifier","getComplexIdentifier","octalToDecimal","scanIdentifier","restore","scanPunctuator","scanHexLiteral","num","scanBinaryLiteral","scanOctalLiteral","isImplicitOctalLiteral","scanNumericLiteral","parseFloat","scanStringLiteral","unescaped_1","unescaped","octToDec","scanTemplate","rawOffset","unescaped_2","testRegExp","tmp","self","$0","$1","$2","codePoint","RegExp","exception","scanRegExpBody","classMarker","scanRegExpFlags","_char","quot","amp","apos","gt","nbsp","iexcl","cent","pound","curren","yen","brvbar","sect","uml","copy","ordf","laquo","not","shy","reg","macr","deg","plusmn","sup2","sup3","acute","micro","para","middot","cedil","sup1","ordm","raquo","frac14","frac12","frac34","iquest","Agrave","Aacute","Acirc","Atilde","Auml","Aring","AElig","Ccedil","Egrave","Eacute","Ecirc","Euml","Igrave","Iacute","Icirc","Iuml","ETH","Ntilde","Ograve","Oacute","Ocirc","Otilde","Ouml","times","Oslash","Ugrave","Uacute","Ucirc","Uuml","Yacute","THORN","szlig","agrave","aacute","acirc","atilde","auml","aring","aelig","ccedil","egrave","eacute","ecirc","euml","igrave","iacute","icirc","iuml","eth","ntilde","ograve","oacute","ocirc","otilde","ouml","divide","oslash","ugrave","uacute","ucirc","uuml","yacute","thorn","yuml","OElig","oelig","Scaron","scaron","Yuml","fnof","circ","tilde","Alpha","Beta","Gamma","Delta","Epsilon","Zeta","Eta","Theta","Iota","Kappa","Lambda","Mu","Nu","Xi","Omicron","Pi","Rho","Sigma","Tau","Upsilon","Phi","Chi","Psi","Omega","alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu","nu","xi","omicron","pi","rho","sigmaf","sigma","tau","upsilon","phi","chi","psi","omega","thetasym","upsih","piv","ensp","emsp","thinsp","zwnj","zwj","lrm","rlm","ndash","mdash","lsquo","rsquo","sbquo","ldquo","rdquo","bdquo","dagger","Dagger","bull","hellip","permil","prime","Prime","lsaquo","rsaquo","oline","frasl","euro","image","weierp","real","trade","alefsym","larr","uarr","rarr","darr","harr","crarr","lArr","uArr","rArr","dArr","hArr","forall","part","exist","empty","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","prop","infin","ang","and","or","cap","cup","there4","sim","cong","asymp","ne","equiv","le","ge","sub","sup","nsub","sube","supe","oplus","otimes","perp","sdot","lceil","rceil","lfloor","rfloor","loz","spades","clubs","hearts","diams","lang","rang","Reader","curly","paren","beforeFunctionExpression","isRegexStart","previous","check","trackRange","trackLoc","buffer","reader","shift"],"mappings":"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","file":"12e15a8d-06c94682bb6e733c40e9.js","sourcesContent":["require(\"core-js/modules/web.dom.iterable\");\n\nrequire(\"core-js/modules/es6.array.iterator\");\n\nrequire(\"core-js/modules/es6.object.to-string\");\n\nrequire(\"core-js/modules/es6.regexp.constructor\");\n\nrequire(\"core-js/modules/es6.string.code-point-at\");\n\nrequire(\"core-js/modules/es6.regexp.flags\");\n\nrequire(\"core-js/modules/es6.regexp.replace\");\n\nrequire(\"core-js/modules/es6.array.index-of\");\n\nrequire(\"core-js/modules/es6.regexp.match\");\n\nrequire(\"core-js/modules/es6.function.name\");\n\nrequire(\"core-js/modules/es6.object.create\");\n\nrequire(\"core-js/modules/es6.object.set-prototype-of\");\n\nrequire(\"core-js/modules/es6.object.define-property\");\n\n(function webpackUniversalModuleDefinition(root, factory) {\n  /* istanbul ignore next */\n  if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define([], factory);\n  /* istanbul ignore next */\n  else if (typeof exports === 'object') exports[\"esprima\"] = factory();else root[\"esprima\"] = factory();\n})(this, function () {\n  return (\n    /******/\n    function (modules) {\n      // webpackBootstrap\n\n      /******/\n      // The module cache\n\n      /******/\n      var installedModules = {};\n      /******/\n      // The require function\n\n      /******/\n\n      function __webpack_require__(moduleId) {\n        /******/\n        // Check if module is in cache\n\n        /* istanbul ignore if */\n\n        /******/\n        if (installedModules[moduleId])\n          /******/\n          return installedModules[moduleId].exports;\n        /******/\n        // Create a new module (and put it into the cache)\n\n        /******/\n\n        var module = installedModules[moduleId] = {\n          /******/\n          exports: {},\n\n          /******/\n          id: moduleId,\n\n          /******/\n          loaded: false\n          /******/\n\n        };\n        /******/\n        // Execute the module function\n\n        /******/\n\n        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n        /******/\n        // Flag the module as loaded\n\n        /******/\n\n        module.loaded = true;\n        /******/\n        // Return the exports of the module\n\n        /******/\n\n        return module.exports;\n        /******/\n      }\n      /******/\n      // expose the modules object (__webpack_modules__)\n\n      /******/\n\n\n      __webpack_require__.m = modules;\n      /******/\n      // expose the module cache\n\n      /******/\n\n      __webpack_require__.c = installedModules;\n      /******/\n      // __webpack_public_path__\n\n      /******/\n\n      __webpack_require__.p = \"\";\n      /******/\n      // Load entry module and return exports\n\n      /******/\n\n      return __webpack_require__(0);\n      /******/\n    }(\n    /************************************************************************/\n\n    /******/\n    [\n    /* 0 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n      /*\n        Copyright JS Foundation and other contributors, https://js.foundation/\n      \t  Redistribution and use in source and binary forms, with or without\n        modification, are permitted provided that the following conditions are met:\n      \t    * Redistributions of source code must retain the above copyright\n            notice, this list of conditions and the following disclaimer.\n          * Redistributions in binary form must reproduce the above copyright\n            notice, this list of conditions and the following disclaimer in the\n            documentation and/or other materials provided with the distribution.\n      \t  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n        ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n        DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n        ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n        (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n        THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n      */\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var comment_handler_1 = __webpack_require__(1);\n\n      var jsx_parser_1 = __webpack_require__(3);\n\n      var parser_1 = __webpack_require__(8);\n\n      var tokenizer_1 = __webpack_require__(15);\n\n      function parse(code, options, delegate) {\n        var commentHandler = null;\n\n        var proxyDelegate = function proxyDelegate(node, metadata) {\n          if (delegate) {\n            delegate(node, metadata);\n          }\n\n          if (commentHandler) {\n            commentHandler.visit(node, metadata);\n          }\n        };\n\n        var parserDelegate = typeof delegate === 'function' ? proxyDelegate : null;\n        var collectComment = false;\n\n        if (options) {\n          collectComment = typeof options.comment === 'boolean' && options.comment;\n          var attachComment = typeof options.attachComment === 'boolean' && options.attachComment;\n\n          if (collectComment || attachComment) {\n            commentHandler = new comment_handler_1.CommentHandler();\n            commentHandler.attach = attachComment;\n            options.comment = true;\n            parserDelegate = proxyDelegate;\n          }\n        }\n\n        var isModule = false;\n\n        if (options && typeof options.sourceType === 'string') {\n          isModule = options.sourceType === 'module';\n        }\n\n        var parser;\n\n        if (options && typeof options.jsx === 'boolean' && options.jsx) {\n          parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);\n        } else {\n          parser = new parser_1.Parser(code, options, parserDelegate);\n        }\n\n        var program = isModule ? parser.parseModule() : parser.parseScript();\n        var ast = program;\n\n        if (collectComment && commentHandler) {\n          ast.comments = commentHandler.comments;\n        }\n\n        if (parser.config.tokens) {\n          ast.tokens = parser.tokens;\n        }\n\n        if (parser.config.tolerant) {\n          ast.errors = parser.errorHandler.errors;\n        }\n\n        return ast;\n      }\n\n      exports.parse = parse;\n\n      function parseModule(code, options, delegate) {\n        var parsingOptions = options || {};\n        parsingOptions.sourceType = 'module';\n        return parse(code, parsingOptions, delegate);\n      }\n\n      exports.parseModule = parseModule;\n\n      function parseScript(code, options, delegate) {\n        var parsingOptions = options || {};\n        parsingOptions.sourceType = 'script';\n        return parse(code, parsingOptions, delegate);\n      }\n\n      exports.parseScript = parseScript;\n\n      function tokenize(code, options, delegate) {\n        var tokenizer = new tokenizer_1.Tokenizer(code, options);\n        var tokens;\n        tokens = [];\n\n        try {\n          while (true) {\n            var token = tokenizer.getNextToken();\n\n            if (!token) {\n              break;\n            }\n\n            if (delegate) {\n              token = delegate(token);\n            }\n\n            tokens.push(token);\n          }\n        } catch (e) {\n          tokenizer.errorHandler.tolerate(e);\n        }\n\n        if (tokenizer.errorHandler.tolerant) {\n          tokens.errors = tokenizer.errors();\n        }\n\n        return tokens;\n      }\n\n      exports.tokenize = tokenize;\n\n      var syntax_1 = __webpack_require__(2);\n\n      exports.Syntax = syntax_1.Syntax; // Sync with *.json manifests.\n\n      exports.version = '4.0.1';\n      /***/\n    },\n    /* 1 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var syntax_1 = __webpack_require__(2);\n\n      var CommentHandler = function () {\n        function CommentHandler() {\n          this.attach = false;\n          this.comments = [];\n          this.stack = [];\n          this.leading = [];\n          this.trailing = [];\n        }\n\n        CommentHandler.prototype.insertInnerComments = function (node, metadata) {\n          //  innnerComments for properties empty block\n          //  `function a() {/** comments **\\/}`\n          if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {\n            var innerComments = [];\n\n            for (var i = this.leading.length - 1; i >= 0; --i) {\n              var entry = this.leading[i];\n\n              if (metadata.end.offset >= entry.start) {\n                innerComments.unshift(entry.comment);\n                this.leading.splice(i, 1);\n                this.trailing.splice(i, 1);\n              }\n            }\n\n            if (innerComments.length) {\n              node.innerComments = innerComments;\n            }\n          }\n        };\n\n        CommentHandler.prototype.findTrailingComments = function (metadata) {\n          var trailingComments = [];\n\n          if (this.trailing.length > 0) {\n            for (var i = this.trailing.length - 1; i >= 0; --i) {\n              var entry_1 = this.trailing[i];\n\n              if (entry_1.start >= metadata.end.offset) {\n                trailingComments.unshift(entry_1.comment);\n              }\n            }\n\n            this.trailing.length = 0;\n            return trailingComments;\n          }\n\n          var entry = this.stack[this.stack.length - 1];\n\n          if (entry && entry.node.trailingComments) {\n            var firstComment = entry.node.trailingComments[0];\n\n            if (firstComment && firstComment.range[0] >= metadata.end.offset) {\n              trailingComments = entry.node.trailingComments;\n              delete entry.node.trailingComments;\n            }\n          }\n\n          return trailingComments;\n        };\n\n        CommentHandler.prototype.findLeadingComments = function (metadata) {\n          var leadingComments = [];\n          var target;\n\n          while (this.stack.length > 0) {\n            var entry = this.stack[this.stack.length - 1];\n\n            if (entry && entry.start >= metadata.start.offset) {\n              target = entry.node;\n              this.stack.pop();\n            } else {\n              break;\n            }\n          }\n\n          if (target) {\n            var count = target.leadingComments ? target.leadingComments.length : 0;\n\n            for (var i = count - 1; i >= 0; --i) {\n              var comment = target.leadingComments[i];\n\n              if (comment.range[1] <= metadata.start.offset) {\n                leadingComments.unshift(comment);\n                target.leadingComments.splice(i, 1);\n              }\n            }\n\n            if (target.leadingComments && target.leadingComments.length === 0) {\n              delete target.leadingComments;\n            }\n\n            return leadingComments;\n          }\n\n          for (var i = this.leading.length - 1; i >= 0; --i) {\n            var entry = this.leading[i];\n\n            if (entry.start <= metadata.start.offset) {\n              leadingComments.unshift(entry.comment);\n              this.leading.splice(i, 1);\n            }\n          }\n\n          return leadingComments;\n        };\n\n        CommentHandler.prototype.visitNode = function (node, metadata) {\n          if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {\n            return;\n          }\n\n          this.insertInnerComments(node, metadata);\n          var trailingComments = this.findTrailingComments(metadata);\n          var leadingComments = this.findLeadingComments(metadata);\n\n          if (leadingComments.length > 0) {\n            node.leadingComments = leadingComments;\n          }\n\n          if (trailingComments.length > 0) {\n            node.trailingComments = trailingComments;\n          }\n\n          this.stack.push({\n            node: node,\n            start: metadata.start.offset\n          });\n        };\n\n        CommentHandler.prototype.visitComment = function (node, metadata) {\n          var type = node.type[0] === 'L' ? 'Line' : 'Block';\n          var comment = {\n            type: type,\n            value: node.value\n          };\n\n          if (node.range) {\n            comment.range = node.range;\n          }\n\n          if (node.loc) {\n            comment.loc = node.loc;\n          }\n\n          this.comments.push(comment);\n\n          if (this.attach) {\n            var entry = {\n              comment: {\n                type: type,\n                value: node.value,\n                range: [metadata.start.offset, metadata.end.offset]\n              },\n              start: metadata.start.offset\n            };\n\n            if (node.loc) {\n              entry.comment.loc = node.loc;\n            }\n\n            node.type = type;\n            this.leading.push(entry);\n            this.trailing.push(entry);\n          }\n        };\n\n        CommentHandler.prototype.visit = function (node, metadata) {\n          if (node.type === 'LineComment') {\n            this.visitComment(node, metadata);\n          } else if (node.type === 'BlockComment') {\n            this.visitComment(node, metadata);\n          } else if (this.attach) {\n            this.visitNode(node, metadata);\n          }\n        };\n\n        return CommentHandler;\n      }();\n\n      exports.CommentHandler = CommentHandler;\n      /***/\n    },\n    /* 2 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.Syntax = {\n        AssignmentExpression: 'AssignmentExpression',\n        AssignmentPattern: 'AssignmentPattern',\n        ArrayExpression: 'ArrayExpression',\n        ArrayPattern: 'ArrayPattern',\n        ArrowFunctionExpression: 'ArrowFunctionExpression',\n        AwaitExpression: 'AwaitExpression',\n        BlockStatement: 'BlockStatement',\n        BinaryExpression: 'BinaryExpression',\n        BreakStatement: 'BreakStatement',\n        CallExpression: 'CallExpression',\n        CatchClause: 'CatchClause',\n        ClassBody: 'ClassBody',\n        ClassDeclaration: 'ClassDeclaration',\n        ClassExpression: 'ClassExpression',\n        ConditionalExpression: 'ConditionalExpression',\n        ContinueStatement: 'ContinueStatement',\n        DoWhileStatement: 'DoWhileStatement',\n        DebuggerStatement: 'DebuggerStatement',\n        EmptyStatement: 'EmptyStatement',\n        ExportAllDeclaration: 'ExportAllDeclaration',\n        ExportDefaultDeclaration: 'ExportDefaultDeclaration',\n        ExportNamedDeclaration: 'ExportNamedDeclaration',\n        ExportSpecifier: 'ExportSpecifier',\n        ExpressionStatement: 'ExpressionStatement',\n        ForStatement: 'ForStatement',\n        ForOfStatement: 'ForOfStatement',\n        ForInStatement: 'ForInStatement',\n        FunctionDeclaration: 'FunctionDeclaration',\n        FunctionExpression: 'FunctionExpression',\n        Identifier: 'Identifier',\n        IfStatement: 'IfStatement',\n        ImportDeclaration: 'ImportDeclaration',\n        ImportDefaultSpecifier: 'ImportDefaultSpecifier',\n        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',\n        ImportSpecifier: 'ImportSpecifier',\n        Literal: 'Literal',\n        LabeledStatement: 'LabeledStatement',\n        LogicalExpression: 'LogicalExpression',\n        MemberExpression: 'MemberExpression',\n        MetaProperty: 'MetaProperty',\n        MethodDefinition: 'MethodDefinition',\n        NewExpression: 'NewExpression',\n        ObjectExpression: 'ObjectExpression',\n        ObjectPattern: 'ObjectPattern',\n        Program: 'Program',\n        Property: 'Property',\n        RestElement: 'RestElement',\n        ReturnStatement: 'ReturnStatement',\n        SequenceExpression: 'SequenceExpression',\n        SpreadElement: 'SpreadElement',\n        Super: 'Super',\n        SwitchCase: 'SwitchCase',\n        SwitchStatement: 'SwitchStatement',\n        TaggedTemplateExpression: 'TaggedTemplateExpression',\n        TemplateElement: 'TemplateElement',\n        TemplateLiteral: 'TemplateLiteral',\n        ThisExpression: 'ThisExpression',\n        ThrowStatement: 'ThrowStatement',\n        TryStatement: 'TryStatement',\n        UnaryExpression: 'UnaryExpression',\n        UpdateExpression: 'UpdateExpression',\n        VariableDeclaration: 'VariableDeclaration',\n        VariableDeclarator: 'VariableDeclarator',\n        WhileStatement: 'WhileStatement',\n        WithStatement: 'WithStatement',\n        YieldExpression: 'YieldExpression'\n      };\n      /***/\n    },\n    /* 3 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n      /* istanbul ignore next */\n\n      var __extends = this && this.__extends || function () {\n        var extendStatics = Object.setPrototypeOf || {\n          __proto__: []\n        } instanceof Array && function (d, b) {\n          d.__proto__ = b;\n        } || function (d, b) {\n          for (var p in b) {\n            if (b.hasOwnProperty(p)) d[p] = b[p];\n          }\n        };\n\n        return function (d, b) {\n          extendStatics(d, b);\n\n          function __() {\n            this.constructor = d;\n          }\n\n          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n        };\n      }();\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var character_1 = __webpack_require__(4);\n\n      var JSXNode = __webpack_require__(5);\n\n      var jsx_syntax_1 = __webpack_require__(6);\n\n      var Node = __webpack_require__(7);\n\n      var parser_1 = __webpack_require__(8);\n\n      var token_1 = __webpack_require__(13);\n\n      var xhtml_entities_1 = __webpack_require__(14);\n\n      token_1.TokenName[100\n      /* Identifier */\n      ] = 'JSXIdentifier';\n      token_1.TokenName[101\n      /* Text */\n      ] = 'JSXText'; // Fully qualified element name, e.g. <svg:path> returns \"svg:path\"\n\n      function getQualifiedElementName(elementName) {\n        var qualifiedName;\n\n        switch (elementName.type) {\n          case jsx_syntax_1.JSXSyntax.JSXIdentifier:\n            var id = elementName;\n            qualifiedName = id.name;\n            break;\n\n          case jsx_syntax_1.JSXSyntax.JSXNamespacedName:\n            var ns = elementName;\n            qualifiedName = getQualifiedElementName(ns.namespace) + ':' + getQualifiedElementName(ns.name);\n            break;\n\n          case jsx_syntax_1.JSXSyntax.JSXMemberExpression:\n            var expr = elementName;\n            qualifiedName = getQualifiedElementName(expr.object) + '.' + getQualifiedElementName(expr.property);\n            break;\n\n          /* istanbul ignore next */\n\n          default:\n            break;\n        }\n\n        return qualifiedName;\n      }\n\n      var JSXParser = function (_super) {\n        __extends(JSXParser, _super);\n\n        function JSXParser(code, options, delegate) {\n          return _super.call(this, code, options, delegate) || this;\n        }\n\n        JSXParser.prototype.parsePrimaryExpression = function () {\n          return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);\n        };\n\n        JSXParser.prototype.startJSX = function () {\n          // Unwind the scanner before the lookahead token.\n          this.scanner.index = this.startMarker.index;\n          this.scanner.lineNumber = this.startMarker.line;\n          this.scanner.lineStart = this.startMarker.index - this.startMarker.column;\n        };\n\n        JSXParser.prototype.finishJSX = function () {\n          // Prime the next lookahead.\n          this.nextToken();\n        };\n\n        JSXParser.prototype.reenterJSX = function () {\n          this.startJSX();\n          this.expectJSX('}'); // Pop the closing '}' added from the lookahead.\n\n          if (this.config.tokens) {\n            this.tokens.pop();\n          }\n        };\n\n        JSXParser.prototype.createJSXNode = function () {\n          this.collectComments();\n          return {\n            index: this.scanner.index,\n            line: this.scanner.lineNumber,\n            column: this.scanner.index - this.scanner.lineStart\n          };\n        };\n\n        JSXParser.prototype.createJSXChildNode = function () {\n          return {\n            index: this.scanner.index,\n            line: this.scanner.lineNumber,\n            column: this.scanner.index - this.scanner.lineStart\n          };\n        };\n\n        JSXParser.prototype.scanXHTMLEntity = function (quote) {\n          var result = '&';\n          var valid = true;\n          var terminated = false;\n          var numeric = false;\n          var hex = false;\n\n          while (!this.scanner.eof() && valid && !terminated) {\n            var ch = this.scanner.source[this.scanner.index];\n\n            if (ch === quote) {\n              break;\n            }\n\n            terminated = ch === ';';\n            result += ch;\n            ++this.scanner.index;\n\n            if (!terminated) {\n              switch (result.length) {\n                case 2:\n                  // e.g. '&#123;'\n                  numeric = ch === '#';\n                  break;\n\n                case 3:\n                  if (numeric) {\n                    // e.g. '&#x41;'\n                    hex = ch === 'x';\n                    valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));\n                    numeric = numeric && !hex;\n                  }\n\n                  break;\n\n                default:\n                  valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));\n                  valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));\n                  break;\n              }\n            }\n          }\n\n          if (valid && terminated && result.length > 2) {\n            // e.g. '&#x41;' becomes just '#x41'\n            var str = result.substr(1, result.length - 2);\n\n            if (numeric && str.length > 1) {\n              result = String.fromCharCode(parseInt(str.substr(1), 10));\n            } else if (hex && str.length > 2) {\n              result = String.fromCharCode(parseInt('0' + str.substr(1), 16));\n            } else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {\n              result = xhtml_entities_1.XHTMLEntities[str];\n            }\n          }\n\n          return result;\n        }; // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.\n\n\n        JSXParser.prototype.lexJSX = function () {\n          var cp = this.scanner.source.charCodeAt(this.scanner.index); // < > / : = { }\n\n          if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {\n            var value = this.scanner.source[this.scanner.index++];\n            return {\n              type: 7\n              /* Punctuator */\n              ,\n              value: value,\n              lineNumber: this.scanner.lineNumber,\n              lineStart: this.scanner.lineStart,\n              start: this.scanner.index - 1,\n              end: this.scanner.index\n            };\n          } // \" '\n\n\n          if (cp === 34 || cp === 39) {\n            var start = this.scanner.index;\n            var quote = this.scanner.source[this.scanner.index++];\n            var str = '';\n\n            while (!this.scanner.eof()) {\n              var ch = this.scanner.source[this.scanner.index++];\n\n              if (ch === quote) {\n                break;\n              } else if (ch === '&') {\n                str += this.scanXHTMLEntity(quote);\n              } else {\n                str += ch;\n              }\n            }\n\n            return {\n              type: 8\n              /* StringLiteral */\n              ,\n              value: str,\n              lineNumber: this.scanner.lineNumber,\n              lineStart: this.scanner.lineStart,\n              start: start,\n              end: this.scanner.index\n            };\n          } // ... or .\n\n\n          if (cp === 46) {\n            var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);\n            var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);\n            var value = n1 === 46 && n2 === 46 ? '...' : '.';\n            var start = this.scanner.index;\n            this.scanner.index += value.length;\n            return {\n              type: 7\n              /* Punctuator */\n              ,\n              value: value,\n              lineNumber: this.scanner.lineNumber,\n              lineStart: this.scanner.lineStart,\n              start: start,\n              end: this.scanner.index\n            };\n          } // `\n\n\n          if (cp === 96) {\n            // Only placeholder, since it will be rescanned as a real assignment expression.\n            return {\n              type: 10\n              /* Template */\n              ,\n              value: '',\n              lineNumber: this.scanner.lineNumber,\n              lineStart: this.scanner.lineStart,\n              start: this.scanner.index,\n              end: this.scanner.index\n            };\n          } // Identifer can not contain backslash (char code 92).\n\n\n          if (character_1.Character.isIdentifierStart(cp) && cp !== 92) {\n            var start = this.scanner.index;\n            ++this.scanner.index;\n\n            while (!this.scanner.eof()) {\n              var ch = this.scanner.source.charCodeAt(this.scanner.index);\n\n              if (character_1.Character.isIdentifierPart(ch) && ch !== 92) {\n                ++this.scanner.index;\n              } else if (ch === 45) {\n                // Hyphen (char code 45) can be part of an identifier.\n                ++this.scanner.index;\n              } else {\n                break;\n              }\n            }\n\n            var id = this.scanner.source.slice(start, this.scanner.index);\n            return {\n              type: 100\n              /* Identifier */\n              ,\n              value: id,\n              lineNumber: this.scanner.lineNumber,\n              lineStart: this.scanner.lineStart,\n              start: start,\n              end: this.scanner.index\n            };\n          }\n\n          return this.scanner.lex();\n        };\n\n        JSXParser.prototype.nextJSXToken = function () {\n          this.collectComments();\n          this.startMarker.index = this.scanner.index;\n          this.startMarker.line = this.scanner.lineNumber;\n          this.startMarker.column = this.scanner.index - this.scanner.lineStart;\n          var token = this.lexJSX();\n          this.lastMarker.index = this.scanner.index;\n          this.lastMarker.line = this.scanner.lineNumber;\n          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;\n\n          if (this.config.tokens) {\n            this.tokens.push(this.convertToken(token));\n          }\n\n          return token;\n        };\n\n        JSXParser.prototype.nextJSXText = function () {\n          this.startMarker.index = this.scanner.index;\n          this.startMarker.line = this.scanner.lineNumber;\n          this.startMarker.column = this.scanner.index - this.scanner.lineStart;\n          var start = this.scanner.index;\n          var text = '';\n\n          while (!this.scanner.eof()) {\n            var ch = this.scanner.source[this.scanner.index];\n\n            if (ch === '{' || ch === '<') {\n              break;\n            }\n\n            ++this.scanner.index;\n            text += ch;\n\n            if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n              ++this.scanner.lineNumber;\n\n              if (ch === '\\r' && this.scanner.source[this.scanner.index] === '\\n') {\n                ++this.scanner.index;\n              }\n\n              this.scanner.lineStart = this.scanner.index;\n            }\n          }\n\n          this.lastMarker.index = this.scanner.index;\n          this.lastMarker.line = this.scanner.lineNumber;\n          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;\n          var token = {\n            type: 101\n            /* Text */\n            ,\n            value: text,\n            lineNumber: this.scanner.lineNumber,\n            lineStart: this.scanner.lineStart,\n            start: start,\n            end: this.scanner.index\n          };\n\n          if (text.length > 0 && this.config.tokens) {\n            this.tokens.push(this.convertToken(token));\n          }\n\n          return token;\n        };\n\n        JSXParser.prototype.peekJSXToken = function () {\n          var state = this.scanner.saveState();\n          this.scanner.scanComments();\n          var next = this.lexJSX();\n          this.scanner.restoreState(state);\n          return next;\n        }; // Expect the next JSX token to match the specified punctuator.\n        // If not, an exception will be thrown.\n\n\n        JSXParser.prototype.expectJSX = function (value) {\n          var token = this.nextJSXToken();\n\n          if (token.type !== 7\n          /* Punctuator */\n          || token.value !== value) {\n            this.throwUnexpectedToken(token);\n          }\n        }; // Return true if the next JSX token matches the specified punctuator.\n\n\n        JSXParser.prototype.matchJSX = function (value) {\n          var next = this.peekJSXToken();\n          return next.type === 7\n          /* Punctuator */\n          && next.value === value;\n        };\n\n        JSXParser.prototype.parseJSXIdentifier = function () {\n          var node = this.createJSXNode();\n          var token = this.nextJSXToken();\n\n          if (token.type !== 100\n          /* Identifier */\n          ) {\n              this.throwUnexpectedToken(token);\n            }\n\n          return this.finalize(node, new JSXNode.JSXIdentifier(token.value));\n        };\n\n        JSXParser.prototype.parseJSXElementName = function () {\n          var node = this.createJSXNode();\n          var elementName = this.parseJSXIdentifier();\n\n          if (this.matchJSX(':')) {\n            var namespace = elementName;\n            this.expectJSX(':');\n            var name_1 = this.parseJSXIdentifier();\n            elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));\n          } else if (this.matchJSX('.')) {\n            while (this.matchJSX('.')) {\n              var object = elementName;\n              this.expectJSX('.');\n              var property = this.parseJSXIdentifier();\n              elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));\n            }\n          }\n\n          return elementName;\n        };\n\n        JSXParser.prototype.parseJSXAttributeName = function () {\n          var node = this.createJSXNode();\n          var attributeName;\n          var identifier = this.parseJSXIdentifier();\n\n          if (this.matchJSX(':')) {\n            var namespace = identifier;\n            this.expectJSX(':');\n            var name_2 = this.parseJSXIdentifier();\n            attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));\n          } else {\n            attributeName = identifier;\n          }\n\n          return attributeName;\n        };\n\n        JSXParser.prototype.parseJSXStringLiteralAttribute = function () {\n          var node = this.createJSXNode();\n          var token = this.nextJSXToken();\n\n          if (token.type !== 8\n          /* StringLiteral */\n          ) {\n              this.throwUnexpectedToken(token);\n            }\n\n          var raw = this.getTokenRaw(token);\n          return this.finalize(node, new Node.Literal(token.value, raw));\n        };\n\n        JSXParser.prototype.parseJSXExpressionAttribute = function () {\n          var node = this.createJSXNode();\n          this.expectJSX('{');\n          this.finishJSX();\n\n          if (this.match('}')) {\n            this.tolerateError('JSX attributes must only be assigned a non-empty expression');\n          }\n\n          var expression = this.parseAssignmentExpression();\n          this.reenterJSX();\n          return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));\n        };\n\n        JSXParser.prototype.parseJSXAttributeValue = function () {\n          return this.matchJSX('{') ? this.parseJSXExpressionAttribute() : this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();\n        };\n\n        JSXParser.prototype.parseJSXNameValueAttribute = function () {\n          var node = this.createJSXNode();\n          var name = this.parseJSXAttributeName();\n          var value = null;\n\n          if (this.matchJSX('=')) {\n            this.expectJSX('=');\n            value = this.parseJSXAttributeValue();\n          }\n\n          return this.finalize(node, new JSXNode.JSXAttribute(name, value));\n        };\n\n        JSXParser.prototype.parseJSXSpreadAttribute = function () {\n          var node = this.createJSXNode();\n          this.expectJSX('{');\n          this.expectJSX('...');\n          this.finishJSX();\n          var argument = this.parseAssignmentExpression();\n          this.reenterJSX();\n          return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));\n        };\n\n        JSXParser.prototype.parseJSXAttributes = function () {\n          var attributes = [];\n\n          while (!this.matchJSX('/') && !this.matchJSX('>')) {\n            var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() : this.parseJSXNameValueAttribute();\n            attributes.push(attribute);\n          }\n\n          return attributes;\n        };\n\n        JSXParser.prototype.parseJSXOpeningElement = function () {\n          var node = this.createJSXNode();\n          this.expectJSX('<');\n          var name = this.parseJSXElementName();\n          var attributes = this.parseJSXAttributes();\n          var selfClosing = this.matchJSX('/');\n\n          if (selfClosing) {\n            this.expectJSX('/');\n          }\n\n          this.expectJSX('>');\n          return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));\n        };\n\n        JSXParser.prototype.parseJSXBoundaryElement = function () {\n          var node = this.createJSXNode();\n          this.expectJSX('<');\n\n          if (this.matchJSX('/')) {\n            this.expectJSX('/');\n            var name_3 = this.parseJSXElementName();\n            this.expectJSX('>');\n            return this.finalize(node, new JSXNode.JSXClosingElement(name_3));\n          }\n\n          var name = this.parseJSXElementName();\n          var attributes = this.parseJSXAttributes();\n          var selfClosing = this.matchJSX('/');\n\n          if (selfClosing) {\n            this.expectJSX('/');\n          }\n\n          this.expectJSX('>');\n          return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));\n        };\n\n        JSXParser.prototype.parseJSXEmptyExpression = function () {\n          var node = this.createJSXChildNode();\n          this.collectComments();\n          this.lastMarker.index = this.scanner.index;\n          this.lastMarker.line = this.scanner.lineNumber;\n          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;\n          return this.finalize(node, new JSXNode.JSXEmptyExpression());\n        };\n\n        JSXParser.prototype.parseJSXExpressionContainer = function () {\n          var node = this.createJSXNode();\n          this.expectJSX('{');\n          var expression;\n\n          if (this.matchJSX('}')) {\n            expression = this.parseJSXEmptyExpression();\n            this.expectJSX('}');\n          } else {\n            this.finishJSX();\n            expression = this.parseAssignmentExpression();\n            this.reenterJSX();\n          }\n\n          return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));\n        };\n\n        JSXParser.prototype.parseJSXChildren = function () {\n          var children = [];\n\n          while (!this.scanner.eof()) {\n            var node = this.createJSXChildNode();\n            var token = this.nextJSXText();\n\n            if (token.start < token.end) {\n              var raw = this.getTokenRaw(token);\n              var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));\n              children.push(child);\n            }\n\n            if (this.scanner.source[this.scanner.index] === '{') {\n              var container = this.parseJSXExpressionContainer();\n              children.push(container);\n            } else {\n              break;\n            }\n          }\n\n          return children;\n        };\n\n        JSXParser.prototype.parseComplexJSXElement = function (el) {\n          var stack = [];\n\n          while (!this.scanner.eof()) {\n            el.children = el.children.concat(this.parseJSXChildren());\n            var node = this.createJSXChildNode();\n            var element = this.parseJSXBoundaryElement();\n\n            if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {\n              var opening = element;\n\n              if (opening.selfClosing) {\n                var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));\n                el.children.push(child);\n              } else {\n                stack.push(el);\n                el = {\n                  node: node,\n                  opening: opening,\n                  closing: null,\n                  children: []\n                };\n              }\n            }\n\n            if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {\n              el.closing = element;\n              var open_1 = getQualifiedElementName(el.opening.name);\n              var close_1 = getQualifiedElementName(el.closing.name);\n\n              if (open_1 !== close_1) {\n                this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);\n              }\n\n              if (stack.length > 0) {\n                var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));\n                el = stack[stack.length - 1];\n                el.children.push(child);\n                stack.pop();\n              } else {\n                break;\n              }\n            }\n          }\n\n          return el;\n        };\n\n        JSXParser.prototype.parseJSXElement = function () {\n          var node = this.createJSXNode();\n          var opening = this.parseJSXOpeningElement();\n          var children = [];\n          var closing = null;\n\n          if (!opening.selfClosing) {\n            var el = this.parseComplexJSXElement({\n              node: node,\n              opening: opening,\n              closing: closing,\n              children: children\n            });\n            children = el.children;\n            closing = el.closing;\n          }\n\n          return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));\n        };\n\n        JSXParser.prototype.parseJSXRoot = function () {\n          // Pop the opening '<' added from the lookahead.\n          if (this.config.tokens) {\n            this.tokens.pop();\n          }\n\n          this.startJSX();\n          var element = this.parseJSXElement();\n          this.finishJSX();\n          return element;\n        };\n\n        JSXParser.prototype.isStartOfExpression = function () {\n          return _super.prototype.isStartOfExpression.call(this) || this.match('<');\n        };\n\n        return JSXParser;\n      }(parser_1.Parser);\n\n      exports.JSXParser = JSXParser;\n      /***/\n    },\n    /* 4 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      }); // See also tools/generate-unicode-regex.js.\n\n      var Regex = {\n        // Unicode v8.0.0 NonAsciiIdentifierStart:\n        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]/,\n        // Unicode v8.0.0 NonAsciiIdentifierPart:\n        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]/\n      };\n      exports.Character = {\n        /* tslint:disable:no-bitwise */\n        fromCodePoint: function fromCodePoint(cp) {\n          return cp < 0x10000 ? String.fromCharCode(cp) : String.fromCharCode(0xD800 + (cp - 0x10000 >> 10)) + String.fromCharCode(0xDC00 + (cp - 0x10000 & 1023));\n        },\n        // https://tc39.github.io/ecma262/#sec-white-space\n        isWhiteSpace: function isWhiteSpace(cp) {\n          return cp === 0x20 || cp === 0x09 || cp === 0x0B || cp === 0x0C || cp === 0xA0 || cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0;\n        },\n        // https://tc39.github.io/ecma262/#sec-line-terminators\n        isLineTerminator: function isLineTerminator(cp) {\n          return cp === 0x0A || cp === 0x0D || cp === 0x2028 || cp === 0x2029;\n        },\n        // https://tc39.github.io/ecma262/#sec-names-and-keywords\n        isIdentifierStart: function isIdentifierStart(cp) {\n          return cp === 0x24 || cp === 0x5F || cp >= 0x41 && cp <= 0x5A || cp >= 0x61 && cp <= 0x7A || cp === 0x5C || cp >= 0x80 && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp));\n        },\n        isIdentifierPart: function isIdentifierPart(cp) {\n          return cp === 0x24 || cp === 0x5F || cp >= 0x41 && cp <= 0x5A || cp >= 0x61 && cp <= 0x7A || cp >= 0x30 && cp <= 0x39 || cp === 0x5C || cp >= 0x80 && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp));\n        },\n        // https://tc39.github.io/ecma262/#sec-literals-numeric-literals\n        isDecimalDigit: function isDecimalDigit(cp) {\n          return cp >= 0x30 && cp <= 0x39; // 0..9\n        },\n        isHexDigit: function isHexDigit(cp) {\n          return cp >= 0x30 && cp <= 0x39 || cp >= 0x41 && cp <= 0x46 || cp >= 0x61 && cp <= 0x66; // a..f\n        },\n        isOctalDigit: function isOctalDigit(cp) {\n          return cp >= 0x30 && cp <= 0x37; // 0..7\n        }\n      };\n      /***/\n    },\n    /* 5 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var jsx_syntax_1 = __webpack_require__(6);\n      /* tslint:disable:max-classes-per-file */\n\n\n      var JSXClosingElement = function () {\n        function JSXClosingElement(name) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;\n          this.name = name;\n        }\n\n        return JSXClosingElement;\n      }();\n\n      exports.JSXClosingElement = JSXClosingElement;\n\n      var JSXElement = function () {\n        function JSXElement(openingElement, children, closingElement) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXElement;\n          this.openingElement = openingElement;\n          this.children = children;\n          this.closingElement = closingElement;\n        }\n\n        return JSXElement;\n      }();\n\n      exports.JSXElement = JSXElement;\n\n      var JSXEmptyExpression = function () {\n        function JSXEmptyExpression() {\n          this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;\n        }\n\n        return JSXEmptyExpression;\n      }();\n\n      exports.JSXEmptyExpression = JSXEmptyExpression;\n\n      var JSXExpressionContainer = function () {\n        function JSXExpressionContainer(expression) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;\n          this.expression = expression;\n        }\n\n        return JSXExpressionContainer;\n      }();\n\n      exports.JSXExpressionContainer = JSXExpressionContainer;\n\n      var JSXIdentifier = function () {\n        function JSXIdentifier(name) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;\n          this.name = name;\n        }\n\n        return JSXIdentifier;\n      }();\n\n      exports.JSXIdentifier = JSXIdentifier;\n\n      var JSXMemberExpression = function () {\n        function JSXMemberExpression(object, property) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;\n          this.object = object;\n          this.property = property;\n        }\n\n        return JSXMemberExpression;\n      }();\n\n      exports.JSXMemberExpression = JSXMemberExpression;\n\n      var JSXAttribute = function () {\n        function JSXAttribute(name, value) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;\n          this.name = name;\n          this.value = value;\n        }\n\n        return JSXAttribute;\n      }();\n\n      exports.JSXAttribute = JSXAttribute;\n\n      var JSXNamespacedName = function () {\n        function JSXNamespacedName(namespace, name) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;\n          this.namespace = namespace;\n          this.name = name;\n        }\n\n        return JSXNamespacedName;\n      }();\n\n      exports.JSXNamespacedName = JSXNamespacedName;\n\n      var JSXOpeningElement = function () {\n        function JSXOpeningElement(name, selfClosing, attributes) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;\n          this.name = name;\n          this.selfClosing = selfClosing;\n          this.attributes = attributes;\n        }\n\n        return JSXOpeningElement;\n      }();\n\n      exports.JSXOpeningElement = JSXOpeningElement;\n\n      var JSXSpreadAttribute = function () {\n        function JSXSpreadAttribute(argument) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;\n          this.argument = argument;\n        }\n\n        return JSXSpreadAttribute;\n      }();\n\n      exports.JSXSpreadAttribute = JSXSpreadAttribute;\n\n      var JSXText = function () {\n        function JSXText(value, raw) {\n          this.type = jsx_syntax_1.JSXSyntax.JSXText;\n          this.value = value;\n          this.raw = raw;\n        }\n\n        return JSXText;\n      }();\n\n      exports.JSXText = JSXText;\n      /***/\n    },\n    /* 6 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.JSXSyntax = {\n        JSXAttribute: 'JSXAttribute',\n        JSXClosingElement: 'JSXClosingElement',\n        JSXElement: 'JSXElement',\n        JSXEmptyExpression: 'JSXEmptyExpression',\n        JSXExpressionContainer: 'JSXExpressionContainer',\n        JSXIdentifier: 'JSXIdentifier',\n        JSXMemberExpression: 'JSXMemberExpression',\n        JSXNamespacedName: 'JSXNamespacedName',\n        JSXOpeningElement: 'JSXOpeningElement',\n        JSXSpreadAttribute: 'JSXSpreadAttribute',\n        JSXText: 'JSXText'\n      };\n      /***/\n    },\n    /* 7 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var syntax_1 = __webpack_require__(2);\n      /* tslint:disable:max-classes-per-file */\n\n\n      var ArrayExpression = function () {\n        function ArrayExpression(elements) {\n          this.type = syntax_1.Syntax.ArrayExpression;\n          this.elements = elements;\n        }\n\n        return ArrayExpression;\n      }();\n\n      exports.ArrayExpression = ArrayExpression;\n\n      var ArrayPattern = function () {\n        function ArrayPattern(elements) {\n          this.type = syntax_1.Syntax.ArrayPattern;\n          this.elements = elements;\n        }\n\n        return ArrayPattern;\n      }();\n\n      exports.ArrayPattern = ArrayPattern;\n\n      var ArrowFunctionExpression = function () {\n        function ArrowFunctionExpression(params, body, expression) {\n          this.type = syntax_1.Syntax.ArrowFunctionExpression;\n          this.id = null;\n          this.params = params;\n          this.body = body;\n          this.generator = false;\n          this.expression = expression;\n          this.async = false;\n        }\n\n        return ArrowFunctionExpression;\n      }();\n\n      exports.ArrowFunctionExpression = ArrowFunctionExpression;\n\n      var AssignmentExpression = function () {\n        function AssignmentExpression(operator, left, right) {\n          this.type = syntax_1.Syntax.AssignmentExpression;\n          this.operator = operator;\n          this.left = left;\n          this.right = right;\n        }\n\n        return AssignmentExpression;\n      }();\n\n      exports.AssignmentExpression = AssignmentExpression;\n\n      var AssignmentPattern = function () {\n        function AssignmentPattern(left, right) {\n          this.type = syntax_1.Syntax.AssignmentPattern;\n          this.left = left;\n          this.right = right;\n        }\n\n        return AssignmentPattern;\n      }();\n\n      exports.AssignmentPattern = AssignmentPattern;\n\n      var AsyncArrowFunctionExpression = function () {\n        function AsyncArrowFunctionExpression(params, body, expression) {\n          this.type = syntax_1.Syntax.ArrowFunctionExpression;\n          this.id = null;\n          this.params = params;\n          this.body = body;\n          this.generator = false;\n          this.expression = expression;\n          this.async = true;\n        }\n\n        return AsyncArrowFunctionExpression;\n      }();\n\n      exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;\n\n      var AsyncFunctionDeclaration = function () {\n        function AsyncFunctionDeclaration(id, params, body) {\n          this.type = syntax_1.Syntax.FunctionDeclaration;\n          this.id = id;\n          this.params = params;\n          this.body = body;\n          this.generator = false;\n          this.expression = false;\n          this.async = true;\n        }\n\n        return AsyncFunctionDeclaration;\n      }();\n\n      exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;\n\n      var AsyncFunctionExpression = function () {\n        function AsyncFunctionExpression(id, params, body) {\n          this.type = syntax_1.Syntax.FunctionExpression;\n          this.id = id;\n          this.params = params;\n          this.body = body;\n          this.generator = false;\n          this.expression = false;\n          this.async = true;\n        }\n\n        return AsyncFunctionExpression;\n      }();\n\n      exports.AsyncFunctionExpression = AsyncFunctionExpression;\n\n      var AwaitExpression = function () {\n        function AwaitExpression(argument) {\n          this.type = syntax_1.Syntax.AwaitExpression;\n          this.argument = argument;\n        }\n\n        return AwaitExpression;\n      }();\n\n      exports.AwaitExpression = AwaitExpression;\n\n      var BinaryExpression = function () {\n        function BinaryExpression(operator, left, right) {\n          var logical = operator === '||' || operator === '&&';\n          this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;\n          this.operator = operator;\n          this.left = left;\n          this.right = right;\n        }\n\n        return BinaryExpression;\n      }();\n\n      exports.BinaryExpression = BinaryExpression;\n\n      var BlockStatement = function () {\n        function BlockStatement(body) {\n          this.type = syntax_1.Syntax.BlockStatement;\n          this.body = body;\n        }\n\n        return BlockStatement;\n      }();\n\n      exports.BlockStatement = BlockStatement;\n\n      var BreakStatement = function () {\n        function BreakStatement(label) {\n          this.type = syntax_1.Syntax.BreakStatement;\n          this.label = label;\n        }\n\n        return BreakStatement;\n      }();\n\n      exports.BreakStatement = BreakStatement;\n\n      var CallExpression = function () {\n        function CallExpression(callee, args) {\n          this.type = syntax_1.Syntax.CallExpression;\n          this.callee = callee;\n          this.arguments = args;\n        }\n\n        return CallExpression;\n      }();\n\n      exports.CallExpression = CallExpression;\n\n      var CatchClause = function () {\n        function CatchClause(param, body) {\n          this.type = syntax_1.Syntax.CatchClause;\n          this.param = param;\n          this.body = body;\n        }\n\n        return CatchClause;\n      }();\n\n      exports.CatchClause = CatchClause;\n\n      var ClassBody = function () {\n        function ClassBody(body) {\n          this.type = syntax_1.Syntax.ClassBody;\n          this.body = body;\n        }\n\n        return ClassBody;\n      }();\n\n      exports.ClassBody = ClassBody;\n\n      var ClassDeclaration = function () {\n        function ClassDeclaration(id, superClass, body) {\n          this.type = syntax_1.Syntax.ClassDeclaration;\n          this.id = id;\n          this.superClass = superClass;\n          this.body = body;\n        }\n\n        return ClassDeclaration;\n      }();\n\n      exports.ClassDeclaration = ClassDeclaration;\n\n      var ClassExpression = function () {\n        function ClassExpression(id, superClass, body) {\n          this.type = syntax_1.Syntax.ClassExpression;\n          this.id = id;\n          this.superClass = superClass;\n          this.body = body;\n        }\n\n        return ClassExpression;\n      }();\n\n      exports.ClassExpression = ClassExpression;\n\n      var ComputedMemberExpression = function () {\n        function ComputedMemberExpression(object, property) {\n          this.type = syntax_1.Syntax.MemberExpression;\n          this.computed = true;\n          this.object = object;\n          this.property = property;\n        }\n\n        return ComputedMemberExpression;\n      }();\n\n      exports.ComputedMemberExpression = ComputedMemberExpression;\n\n      var ConditionalExpression = function () {\n        function ConditionalExpression(test, consequent, alternate) {\n          this.type = syntax_1.Syntax.ConditionalExpression;\n          this.test = test;\n          this.consequent = consequent;\n          this.alternate = alternate;\n        }\n\n        return ConditionalExpression;\n      }();\n\n      exports.ConditionalExpression = ConditionalExpression;\n\n      var ContinueStatement = function () {\n        function ContinueStatement(label) {\n          this.type = syntax_1.Syntax.ContinueStatement;\n          this.label = label;\n        }\n\n        return ContinueStatement;\n      }();\n\n      exports.ContinueStatement = ContinueStatement;\n\n      var DebuggerStatement = function () {\n        function DebuggerStatement() {\n          this.type = syntax_1.Syntax.DebuggerStatement;\n        }\n\n        return DebuggerStatement;\n      }();\n\n      exports.DebuggerStatement = DebuggerStatement;\n\n      var Directive = function () {\n        function Directive(expression, directive) {\n          this.type = syntax_1.Syntax.ExpressionStatement;\n          this.expression = expression;\n          this.directive = directive;\n        }\n\n        return Directive;\n      }();\n\n      exports.Directive = Directive;\n\n      var DoWhileStatement = function () {\n        function DoWhileStatement(body, test) {\n          this.type = syntax_1.Syntax.DoWhileStatement;\n          this.body = body;\n          this.test = test;\n        }\n\n        return DoWhileStatement;\n      }();\n\n      exports.DoWhileStatement = DoWhileStatement;\n\n      var EmptyStatement = function () {\n        function EmptyStatement() {\n          this.type = syntax_1.Syntax.EmptyStatement;\n        }\n\n        return EmptyStatement;\n      }();\n\n      exports.EmptyStatement = EmptyStatement;\n\n      var ExportAllDeclaration = function () {\n        function ExportAllDeclaration(source) {\n          this.type = syntax_1.Syntax.ExportAllDeclaration;\n          this.source = source;\n        }\n\n        return ExportAllDeclaration;\n      }();\n\n      exports.ExportAllDeclaration = ExportAllDeclaration;\n\n      var ExportDefaultDeclaration = function () {\n        function ExportDefaultDeclaration(declaration) {\n          this.type = syntax_1.Syntax.ExportDefaultDeclaration;\n          this.declaration = declaration;\n        }\n\n        return ExportDefaultDeclaration;\n      }();\n\n      exports.ExportDefaultDeclaration = ExportDefaultDeclaration;\n\n      var ExportNamedDeclaration = function () {\n        function ExportNamedDeclaration(declaration, specifiers, source) {\n          this.type = syntax_1.Syntax.ExportNamedDeclaration;\n          this.declaration = declaration;\n          this.specifiers = specifiers;\n          this.source = source;\n        }\n\n        return ExportNamedDeclaration;\n      }();\n\n      exports.ExportNamedDeclaration = ExportNamedDeclaration;\n\n      var ExportSpecifier = function () {\n        function ExportSpecifier(local, exported) {\n          this.type = syntax_1.Syntax.ExportSpecifier;\n          this.exported = exported;\n          this.local = local;\n        }\n\n        return ExportSpecifier;\n      }();\n\n      exports.ExportSpecifier = ExportSpecifier;\n\n      var ExpressionStatement = function () {\n        function ExpressionStatement(expression) {\n          this.type = syntax_1.Syntax.ExpressionStatement;\n          this.expression = expression;\n        }\n\n        return ExpressionStatement;\n      }();\n\n      exports.ExpressionStatement = ExpressionStatement;\n\n      var ForInStatement = function () {\n        function ForInStatement(left, right, body) {\n          this.type = syntax_1.Syntax.ForInStatement;\n          this.left = left;\n          this.right = right;\n          this.body = body;\n          this.each = false;\n        }\n\n        return ForInStatement;\n      }();\n\n      exports.ForInStatement = ForInStatement;\n\n      var ForOfStatement = function () {\n        function ForOfStatement(left, right, body) {\n          this.type = syntax_1.Syntax.ForOfStatement;\n          this.left = left;\n          this.right = right;\n          this.body = body;\n        }\n\n        return ForOfStatement;\n      }();\n\n      exports.ForOfStatement = ForOfStatement;\n\n      var ForStatement = function () {\n        function ForStatement(init, test, update, body) {\n          this.type = syntax_1.Syntax.ForStatement;\n          this.init = init;\n          this.test = test;\n          this.update = update;\n          this.body = body;\n        }\n\n        return ForStatement;\n      }();\n\n      exports.ForStatement = ForStatement;\n\n      var FunctionDeclaration = function () {\n        function FunctionDeclaration(id, params, body, generator) {\n          this.type = syntax_1.Syntax.FunctionDeclaration;\n          this.id = id;\n          this.params = params;\n          this.body = body;\n          this.generator = generator;\n          this.expression = false;\n          this.async = false;\n        }\n\n        return FunctionDeclaration;\n      }();\n\n      exports.FunctionDeclaration = FunctionDeclaration;\n\n      var FunctionExpression = function () {\n        function FunctionExpression(id, params, body, generator) {\n          this.type = syntax_1.Syntax.FunctionExpression;\n          this.id = id;\n          this.params = params;\n          this.body = body;\n          this.generator = generator;\n          this.expression = false;\n          this.async = false;\n        }\n\n        return FunctionExpression;\n      }();\n\n      exports.FunctionExpression = FunctionExpression;\n\n      var Identifier = function () {\n        function Identifier(name) {\n          this.type = syntax_1.Syntax.Identifier;\n          this.name = name;\n        }\n\n        return Identifier;\n      }();\n\n      exports.Identifier = Identifier;\n\n      var IfStatement = function () {\n        function IfStatement(test, consequent, alternate) {\n          this.type = syntax_1.Syntax.IfStatement;\n          this.test = test;\n          this.consequent = consequent;\n          this.alternate = alternate;\n        }\n\n        return IfStatement;\n      }();\n\n      exports.IfStatement = IfStatement;\n\n      var ImportDeclaration = function () {\n        function ImportDeclaration(specifiers, source) {\n          this.type = syntax_1.Syntax.ImportDeclaration;\n          this.specifiers = specifiers;\n          this.source = source;\n        }\n\n        return ImportDeclaration;\n      }();\n\n      exports.ImportDeclaration = ImportDeclaration;\n\n      var ImportDefaultSpecifier = function () {\n        function ImportDefaultSpecifier(local) {\n          this.type = syntax_1.Syntax.ImportDefaultSpecifier;\n          this.local = local;\n        }\n\n        return ImportDefaultSpecifier;\n      }();\n\n      exports.ImportDefaultSpecifier = ImportDefaultSpecifier;\n\n      var ImportNamespaceSpecifier = function () {\n        function ImportNamespaceSpecifier(local) {\n          this.type = syntax_1.Syntax.ImportNamespaceSpecifier;\n          this.local = local;\n        }\n\n        return ImportNamespaceSpecifier;\n      }();\n\n      exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;\n\n      var ImportSpecifier = function () {\n        function ImportSpecifier(local, imported) {\n          this.type = syntax_1.Syntax.ImportSpecifier;\n          this.local = local;\n          this.imported = imported;\n        }\n\n        return ImportSpecifier;\n      }();\n\n      exports.ImportSpecifier = ImportSpecifier;\n\n      var LabeledStatement = function () {\n        function LabeledStatement(label, body) {\n          this.type = syntax_1.Syntax.LabeledStatement;\n          this.label = label;\n          this.body = body;\n        }\n\n        return LabeledStatement;\n      }();\n\n      exports.LabeledStatement = LabeledStatement;\n\n      var Literal = function () {\n        function Literal(value, raw) {\n          this.type = syntax_1.Syntax.Literal;\n          this.value = value;\n          this.raw = raw;\n        }\n\n        return Literal;\n      }();\n\n      exports.Literal = Literal;\n\n      var MetaProperty = function () {\n        function MetaProperty(meta, property) {\n          this.type = syntax_1.Syntax.MetaProperty;\n          this.meta = meta;\n          this.property = property;\n        }\n\n        return MetaProperty;\n      }();\n\n      exports.MetaProperty = MetaProperty;\n\n      var MethodDefinition = function () {\n        function MethodDefinition(key, computed, value, kind, isStatic) {\n          this.type = syntax_1.Syntax.MethodDefinition;\n          this.key = key;\n          this.computed = computed;\n          this.value = value;\n          this.kind = kind;\n          this[\"static\"] = isStatic;\n        }\n\n        return MethodDefinition;\n      }();\n\n      exports.MethodDefinition = MethodDefinition;\n\n      var Module = function () {\n        function Module(body) {\n          this.type = syntax_1.Syntax.Program;\n          this.body = body;\n          this.sourceType = 'module';\n        }\n\n        return Module;\n      }();\n\n      exports.Module = Module;\n\n      var NewExpression = function () {\n        function NewExpression(callee, args) {\n          this.type = syntax_1.Syntax.NewExpression;\n          this.callee = callee;\n          this.arguments = args;\n        }\n\n        return NewExpression;\n      }();\n\n      exports.NewExpression = NewExpression;\n\n      var ObjectExpression = function () {\n        function ObjectExpression(properties) {\n          this.type = syntax_1.Syntax.ObjectExpression;\n          this.properties = properties;\n        }\n\n        return ObjectExpression;\n      }();\n\n      exports.ObjectExpression = ObjectExpression;\n\n      var ObjectPattern = function () {\n        function ObjectPattern(properties) {\n          this.type = syntax_1.Syntax.ObjectPattern;\n          this.properties = properties;\n        }\n\n        return ObjectPattern;\n      }();\n\n      exports.ObjectPattern = ObjectPattern;\n\n      var Property = function () {\n        function Property(kind, key, computed, value, method, shorthand) {\n          this.type = syntax_1.Syntax.Property;\n          this.key = key;\n          this.computed = computed;\n          this.value = value;\n          this.kind = kind;\n          this.method = method;\n          this.shorthand = shorthand;\n        }\n\n        return Property;\n      }();\n\n      exports.Property = Property;\n\n      var RegexLiteral = function () {\n        function RegexLiteral(value, raw, pattern, flags) {\n          this.type = syntax_1.Syntax.Literal;\n          this.value = value;\n          this.raw = raw;\n          this.regex = {\n            pattern: pattern,\n            flags: flags\n          };\n        }\n\n        return RegexLiteral;\n      }();\n\n      exports.RegexLiteral = RegexLiteral;\n\n      var RestElement = function () {\n        function RestElement(argument) {\n          this.type = syntax_1.Syntax.RestElement;\n          this.argument = argument;\n        }\n\n        return RestElement;\n      }();\n\n      exports.RestElement = RestElement;\n\n      var ReturnStatement = function () {\n        function ReturnStatement(argument) {\n          this.type = syntax_1.Syntax.ReturnStatement;\n          this.argument = argument;\n        }\n\n        return ReturnStatement;\n      }();\n\n      exports.ReturnStatement = ReturnStatement;\n\n      var Script = function () {\n        function Script(body) {\n          this.type = syntax_1.Syntax.Program;\n          this.body = body;\n          this.sourceType = 'script';\n        }\n\n        return Script;\n      }();\n\n      exports.Script = Script;\n\n      var SequenceExpression = function () {\n        function SequenceExpression(expressions) {\n          this.type = syntax_1.Syntax.SequenceExpression;\n          this.expressions = expressions;\n        }\n\n        return SequenceExpression;\n      }();\n\n      exports.SequenceExpression = SequenceExpression;\n\n      var SpreadElement = function () {\n        function SpreadElement(argument) {\n          this.type = syntax_1.Syntax.SpreadElement;\n          this.argument = argument;\n        }\n\n        return SpreadElement;\n      }();\n\n      exports.SpreadElement = SpreadElement;\n\n      var StaticMemberExpression = function () {\n        function StaticMemberExpression(object, property) {\n          this.type = syntax_1.Syntax.MemberExpression;\n          this.computed = false;\n          this.object = object;\n          this.property = property;\n        }\n\n        return StaticMemberExpression;\n      }();\n\n      exports.StaticMemberExpression = StaticMemberExpression;\n\n      var Super = function () {\n        function Super() {\n          this.type = syntax_1.Syntax.Super;\n        }\n\n        return Super;\n      }();\n\n      exports.Super = Super;\n\n      var SwitchCase = function () {\n        function SwitchCase(test, consequent) {\n          this.type = syntax_1.Syntax.SwitchCase;\n          this.test = test;\n          this.consequent = consequent;\n        }\n\n        return SwitchCase;\n      }();\n\n      exports.SwitchCase = SwitchCase;\n\n      var SwitchStatement = function () {\n        function SwitchStatement(discriminant, cases) {\n          this.type = syntax_1.Syntax.SwitchStatement;\n          this.discriminant = discriminant;\n          this.cases = cases;\n        }\n\n        return SwitchStatement;\n      }();\n\n      exports.SwitchStatement = SwitchStatement;\n\n      var TaggedTemplateExpression = function () {\n        function TaggedTemplateExpression(tag, quasi) {\n          this.type = syntax_1.Syntax.TaggedTemplateExpression;\n          this.tag = tag;\n          this.quasi = quasi;\n        }\n\n        return TaggedTemplateExpression;\n      }();\n\n      exports.TaggedTemplateExpression = TaggedTemplateExpression;\n\n      var TemplateElement = function () {\n        function TemplateElement(value, tail) {\n          this.type = syntax_1.Syntax.TemplateElement;\n          this.value = value;\n          this.tail = tail;\n        }\n\n        return TemplateElement;\n      }();\n\n      exports.TemplateElement = TemplateElement;\n\n      var TemplateLiteral = function () {\n        function TemplateLiteral(quasis, expressions) {\n          this.type = syntax_1.Syntax.TemplateLiteral;\n          this.quasis = quasis;\n          this.expressions = expressions;\n        }\n\n        return TemplateLiteral;\n      }();\n\n      exports.TemplateLiteral = TemplateLiteral;\n\n      var ThisExpression = function () {\n        function ThisExpression() {\n          this.type = syntax_1.Syntax.ThisExpression;\n        }\n\n        return ThisExpression;\n      }();\n\n      exports.ThisExpression = ThisExpression;\n\n      var ThrowStatement = function () {\n        function ThrowStatement(argument) {\n          this.type = syntax_1.Syntax.ThrowStatement;\n          this.argument = argument;\n        }\n\n        return ThrowStatement;\n      }();\n\n      exports.ThrowStatement = ThrowStatement;\n\n      var TryStatement = function () {\n        function TryStatement(block, handler, finalizer) {\n          this.type = syntax_1.Syntax.TryStatement;\n          this.block = block;\n          this.handler = handler;\n          this.finalizer = finalizer;\n        }\n\n        return TryStatement;\n      }();\n\n      exports.TryStatement = TryStatement;\n\n      var UnaryExpression = function () {\n        function UnaryExpression(operator, argument) {\n          this.type = syntax_1.Syntax.UnaryExpression;\n          this.operator = operator;\n          this.argument = argument;\n          this.prefix = true;\n        }\n\n        return UnaryExpression;\n      }();\n\n      exports.UnaryExpression = UnaryExpression;\n\n      var UpdateExpression = function () {\n        function UpdateExpression(operator, argument, prefix) {\n          this.type = syntax_1.Syntax.UpdateExpression;\n          this.operator = operator;\n          this.argument = argument;\n          this.prefix = prefix;\n        }\n\n        return UpdateExpression;\n      }();\n\n      exports.UpdateExpression = UpdateExpression;\n\n      var VariableDeclaration = function () {\n        function VariableDeclaration(declarations, kind) {\n          this.type = syntax_1.Syntax.VariableDeclaration;\n          this.declarations = declarations;\n          this.kind = kind;\n        }\n\n        return VariableDeclaration;\n      }();\n\n      exports.VariableDeclaration = VariableDeclaration;\n\n      var VariableDeclarator = function () {\n        function VariableDeclarator(id, init) {\n          this.type = syntax_1.Syntax.VariableDeclarator;\n          this.id = id;\n          this.init = init;\n        }\n\n        return VariableDeclarator;\n      }();\n\n      exports.VariableDeclarator = VariableDeclarator;\n\n      var WhileStatement = function () {\n        function WhileStatement(test, body) {\n          this.type = syntax_1.Syntax.WhileStatement;\n          this.test = test;\n          this.body = body;\n        }\n\n        return WhileStatement;\n      }();\n\n      exports.WhileStatement = WhileStatement;\n\n      var WithStatement = function () {\n        function WithStatement(object, body) {\n          this.type = syntax_1.Syntax.WithStatement;\n          this.object = object;\n          this.body = body;\n        }\n\n        return WithStatement;\n      }();\n\n      exports.WithStatement = WithStatement;\n\n      var YieldExpression = function () {\n        function YieldExpression(argument, delegate) {\n          this.type = syntax_1.Syntax.YieldExpression;\n          this.argument = argument;\n          this.delegate = delegate;\n        }\n\n        return YieldExpression;\n      }();\n\n      exports.YieldExpression = YieldExpression;\n      /***/\n    },\n    /* 8 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var assert_1 = __webpack_require__(9);\n\n      var error_handler_1 = __webpack_require__(10);\n\n      var messages_1 = __webpack_require__(11);\n\n      var Node = __webpack_require__(7);\n\n      var scanner_1 = __webpack_require__(12);\n\n      var syntax_1 = __webpack_require__(2);\n\n      var token_1 = __webpack_require__(13);\n\n      var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';\n\n      var Parser = function () {\n        function Parser(code, options, delegate) {\n          if (options === void 0) {\n            options = {};\n          }\n\n          this.config = {\n            range: typeof options.range === 'boolean' && options.range,\n            loc: typeof options.loc === 'boolean' && options.loc,\n            source: null,\n            tokens: typeof options.tokens === 'boolean' && options.tokens,\n            comment: typeof options.comment === 'boolean' && options.comment,\n            tolerant: typeof options.tolerant === 'boolean' && options.tolerant\n          };\n\n          if (this.config.loc && options.source && options.source !== null) {\n            this.config.source = String(options.source);\n          }\n\n          this.delegate = delegate;\n          this.errorHandler = new error_handler_1.ErrorHandler();\n          this.errorHandler.tolerant = this.config.tolerant;\n          this.scanner = new scanner_1.Scanner(code, this.errorHandler);\n          this.scanner.trackComment = this.config.comment;\n          this.operatorPrecedence = {\n            ')': 0,\n            ';': 0,\n            ',': 0,\n            '=': 0,\n            ']': 0,\n            '||': 1,\n            '&&': 2,\n            '|': 3,\n            '^': 4,\n            '&': 5,\n            '==': 6,\n            '!=': 6,\n            '===': 6,\n            '!==': 6,\n            '<': 7,\n            '>': 7,\n            '<=': 7,\n            '>=': 7,\n            '<<': 8,\n            '>>': 8,\n            '>>>': 8,\n            '+': 9,\n            '-': 9,\n            '*': 11,\n            '/': 11,\n            '%': 11\n          };\n          this.lookahead = {\n            type: 2\n            /* EOF */\n            ,\n            value: '',\n            lineNumber: this.scanner.lineNumber,\n            lineStart: 0,\n            start: 0,\n            end: 0\n          };\n          this.hasLineTerminator = false;\n          this.context = {\n            isModule: false,\n            \"await\": false,\n            allowIn: true,\n            allowStrictDirective: true,\n            allowYield: true,\n            firstCoverInitializedNameError: null,\n            isAssignmentTarget: false,\n            isBindingElement: false,\n            inFunctionBody: false,\n            inIteration: false,\n            inSwitch: false,\n            labelSet: {},\n            strict: false\n          };\n          this.tokens = [];\n          this.startMarker = {\n            index: 0,\n            line: this.scanner.lineNumber,\n            column: 0\n          };\n          this.lastMarker = {\n            index: 0,\n            line: this.scanner.lineNumber,\n            column: 0\n          };\n          this.nextToken();\n          this.lastMarker = {\n            index: this.scanner.index,\n            line: this.scanner.lineNumber,\n            column: this.scanner.index - this.scanner.lineStart\n          };\n        }\n\n        Parser.prototype.throwError = function (messageFormat) {\n          var values = [];\n\n          for (var _i = 1; _i < arguments.length; _i++) {\n            values[_i - 1] = arguments[_i];\n          }\n\n          var args = Array.prototype.slice.call(arguments, 1);\n          var msg = messageFormat.replace(/%(\\d)/g, function (whole, idx) {\n            assert_1.assert(idx < args.length, 'Message reference must be in range');\n            return args[idx];\n          });\n          var index = this.lastMarker.index;\n          var line = this.lastMarker.line;\n          var column = this.lastMarker.column + 1;\n          throw this.errorHandler.createError(index, line, column, msg);\n        };\n\n        Parser.prototype.tolerateError = function (messageFormat) {\n          var values = [];\n\n          for (var _i = 1; _i < arguments.length; _i++) {\n            values[_i - 1] = arguments[_i];\n          }\n\n          var args = Array.prototype.slice.call(arguments, 1);\n          var msg = messageFormat.replace(/%(\\d)/g, function (whole, idx) {\n            assert_1.assert(idx < args.length, 'Message reference must be in range');\n            return args[idx];\n          });\n          var index = this.lastMarker.index;\n          var line = this.scanner.lineNumber;\n          var column = this.lastMarker.column + 1;\n          this.errorHandler.tolerateError(index, line, column, msg);\n        }; // Throw an exception because of the token.\n\n\n        Parser.prototype.unexpectedTokenError = function (token, message) {\n          var msg = message || messages_1.Messages.UnexpectedToken;\n          var value;\n\n          if (token) {\n            if (!message) {\n              msg = token.type === 2\n              /* EOF */\n              ? messages_1.Messages.UnexpectedEOS : token.type === 3\n              /* Identifier */\n              ? messages_1.Messages.UnexpectedIdentifier : token.type === 6\n              /* NumericLiteral */\n              ? messages_1.Messages.UnexpectedNumber : token.type === 8\n              /* StringLiteral */\n              ? messages_1.Messages.UnexpectedString : token.type === 10\n              /* Template */\n              ? messages_1.Messages.UnexpectedTemplate : messages_1.Messages.UnexpectedToken;\n\n              if (token.type === 4\n              /* Keyword */\n              ) {\n                  if (this.scanner.isFutureReservedWord(token.value)) {\n                    msg = messages_1.Messages.UnexpectedReserved;\n                  } else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {\n                    msg = messages_1.Messages.StrictReservedWord;\n                  }\n                }\n            }\n\n            value = token.value;\n          } else {\n            value = 'ILLEGAL';\n          }\n\n          msg = msg.replace('%0', value);\n\n          if (token && typeof token.lineNumber === 'number') {\n            var index = token.start;\n            var line = token.lineNumber;\n            var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;\n            var column = token.start - lastMarkerLineStart + 1;\n            return this.errorHandler.createError(index, line, column, msg);\n          } else {\n            var index = this.lastMarker.index;\n            var line = this.lastMarker.line;\n            var column = this.lastMarker.column + 1;\n            return this.errorHandler.createError(index, line, column, msg);\n          }\n        };\n\n        Parser.prototype.throwUnexpectedToken = function (token, message) {\n          throw this.unexpectedTokenError(token, message);\n        };\n\n        Parser.prototype.tolerateUnexpectedToken = function (token, message) {\n          this.errorHandler.tolerate(this.unexpectedTokenError(token, message));\n        };\n\n        Parser.prototype.collectComments = function () {\n          if (!this.config.comment) {\n            this.scanner.scanComments();\n          } else {\n            var comments = this.scanner.scanComments();\n\n            if (comments.length > 0 && this.delegate) {\n              for (var i = 0; i < comments.length; ++i) {\n                var e = comments[i];\n                var node = void 0;\n                node = {\n                  type: e.multiLine ? 'BlockComment' : 'LineComment',\n                  value: this.scanner.source.slice(e.slice[0], e.slice[1])\n                };\n\n                if (this.config.range) {\n                  node.range = e.range;\n                }\n\n                if (this.config.loc) {\n                  node.loc = e.loc;\n                }\n\n                var metadata = {\n                  start: {\n                    line: e.loc.start.line,\n                    column: e.loc.start.column,\n                    offset: e.range[0]\n                  },\n                  end: {\n                    line: e.loc.end.line,\n                    column: e.loc.end.column,\n                    offset: e.range[1]\n                  }\n                };\n                this.delegate(node, metadata);\n              }\n            }\n          }\n        }; // From internal representation to an external structure\n\n\n        Parser.prototype.getTokenRaw = function (token) {\n          return this.scanner.source.slice(token.start, token.end);\n        };\n\n        Parser.prototype.convertToken = function (token) {\n          var t = {\n            type: token_1.TokenName[token.type],\n            value: this.getTokenRaw(token)\n          };\n\n          if (this.config.range) {\n            t.range = [token.start, token.end];\n          }\n\n          if (this.config.loc) {\n            t.loc = {\n              start: {\n                line: this.startMarker.line,\n                column: this.startMarker.column\n              },\n              end: {\n                line: this.scanner.lineNumber,\n                column: this.scanner.index - this.scanner.lineStart\n              }\n            };\n          }\n\n          if (token.type === 9\n          /* RegularExpression */\n          ) {\n              var pattern = token.pattern;\n              var flags = token.flags;\n              t.regex = {\n                pattern: pattern,\n                flags: flags\n              };\n            }\n\n          return t;\n        };\n\n        Parser.prototype.nextToken = function () {\n          var token = this.lookahead;\n          this.lastMarker.index = this.scanner.index;\n          this.lastMarker.line = this.scanner.lineNumber;\n          this.lastMarker.column = this.scanner.index - this.scanner.lineStart;\n          this.collectComments();\n\n          if (this.scanner.index !== this.startMarker.index) {\n            this.startMarker.index = this.scanner.index;\n            this.startMarker.line = this.scanner.lineNumber;\n            this.startMarker.column = this.scanner.index - this.scanner.lineStart;\n          }\n\n          var next = this.scanner.lex();\n          this.hasLineTerminator = token.lineNumber !== next.lineNumber;\n\n          if (next && this.context.strict && next.type === 3\n          /* Identifier */\n          ) {\n              if (this.scanner.isStrictModeReservedWord(next.value)) {\n                next.type = 4\n                /* Keyword */\n                ;\n              }\n            }\n\n          this.lookahead = next;\n\n          if (this.config.tokens && next.type !== 2\n          /* EOF */\n          ) {\n              this.tokens.push(this.convertToken(next));\n            }\n\n          return token;\n        };\n\n        Parser.prototype.nextRegexToken = function () {\n          this.collectComments();\n          var token = this.scanner.scanRegExp();\n\n          if (this.config.tokens) {\n            // Pop the previous token, '/' or '/='\n            // This is added from the lookahead token.\n            this.tokens.pop();\n            this.tokens.push(this.convertToken(token));\n          } // Prime the next lookahead.\n\n\n          this.lookahead = token;\n          this.nextToken();\n          return token;\n        };\n\n        Parser.prototype.createNode = function () {\n          return {\n            index: this.startMarker.index,\n            line: this.startMarker.line,\n            column: this.startMarker.column\n          };\n        };\n\n        Parser.prototype.startNode = function (token, lastLineStart) {\n          if (lastLineStart === void 0) {\n            lastLineStart = 0;\n          }\n\n          var column = token.start - token.lineStart;\n          var line = token.lineNumber;\n\n          if (column < 0) {\n            column += lastLineStart;\n            line--;\n          }\n\n          return {\n            index: token.start,\n            line: line,\n            column: column\n          };\n        };\n\n        Parser.prototype.finalize = function (marker, node) {\n          if (this.config.range) {\n            node.range = [marker.index, this.lastMarker.index];\n          }\n\n          if (this.config.loc) {\n            node.loc = {\n              start: {\n                line: marker.line,\n                column: marker.column\n              },\n              end: {\n                line: this.lastMarker.line,\n                column: this.lastMarker.column\n              }\n            };\n\n            if (this.config.source) {\n              node.loc.source = this.config.source;\n            }\n          }\n\n          if (this.delegate) {\n            var metadata = {\n              start: {\n                line: marker.line,\n                column: marker.column,\n                offset: marker.index\n              },\n              end: {\n                line: this.lastMarker.line,\n                column: this.lastMarker.column,\n                offset: this.lastMarker.index\n              }\n            };\n            this.delegate(node, metadata);\n          }\n\n          return node;\n        }; // Expect the next token to match the specified punctuator.\n        // If not, an exception will be thrown.\n\n\n        Parser.prototype.expect = function (value) {\n          var token = this.nextToken();\n\n          if (token.type !== 7\n          /* Punctuator */\n          || token.value !== value) {\n            this.throwUnexpectedToken(token);\n          }\n        }; // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().\n\n\n        Parser.prototype.expectCommaSeparator = function () {\n          if (this.config.tolerant) {\n            var token = this.lookahead;\n\n            if (token.type === 7\n            /* Punctuator */\n            && token.value === ',') {\n              this.nextToken();\n            } else if (token.type === 7\n            /* Punctuator */\n            && token.value === ';') {\n              this.nextToken();\n              this.tolerateUnexpectedToken(token);\n            } else {\n              this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);\n            }\n          } else {\n            this.expect(',');\n          }\n        }; // Expect the next token to match the specified keyword.\n        // If not, an exception will be thrown.\n\n\n        Parser.prototype.expectKeyword = function (keyword) {\n          var token = this.nextToken();\n\n          if (token.type !== 4\n          /* Keyword */\n          || token.value !== keyword) {\n            this.throwUnexpectedToken(token);\n          }\n        }; // Return true if the next token matches the specified punctuator.\n\n\n        Parser.prototype.match = function (value) {\n          return this.lookahead.type === 7\n          /* Punctuator */\n          && this.lookahead.value === value;\n        }; // Return true if the next token matches the specified keyword\n\n\n        Parser.prototype.matchKeyword = function (keyword) {\n          return this.lookahead.type === 4\n          /* Keyword */\n          && this.lookahead.value === keyword;\n        }; // Return true if the next token matches the specified contextual keyword\n        // (where an identifier is sometimes a keyword depending on the context)\n\n\n        Parser.prototype.matchContextualKeyword = function (keyword) {\n          return this.lookahead.type === 3\n          /* Identifier */\n          && this.lookahead.value === keyword;\n        }; // Return true if the next token is an assignment operator\n\n\n        Parser.prototype.matchAssign = function () {\n          if (this.lookahead.type !== 7\n          /* Punctuator */\n          ) {\n              return false;\n            }\n\n          var op = this.lookahead.value;\n          return op === '=' || op === '*=' || op === '**=' || op === '/=' || op === '%=' || op === '+=' || op === '-=' || op === '<<=' || op === '>>=' || op === '>>>=' || op === '&=' || op === '^=' || op === '|=';\n        }; // Cover grammar support.\n        //\n        // When an assignment expression position starts with an left parenthesis, the determination of the type\n        // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)\n        // or the first comma. This situation also defers the determination of all the expressions nested in the pair.\n        //\n        // There are three productions that can be parsed in a parentheses pair that needs to be determined\n        // after the outermost pair is closed. They are:\n        //\n        //   1. AssignmentExpression\n        //   2. BindingElements\n        //   3. AssignmentTargets\n        //\n        // In order to avoid exponential backtracking, we use two flags to denote if the production can be\n        // binding element or assignment target.\n        //\n        // The three productions have the relationship:\n        //\n        //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression\n        //\n        // with a single exception that CoverInitializedName when used directly in an Expression, generates\n        // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the\n        // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.\n        //\n        // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not\n        // effect the current flags. This means the production the parser parses is only used as an expression. Therefore\n        // the CoverInitializedName check is conducted.\n        //\n        // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates\n        // the flags outside of the parser. This means the production the parser parses is used as a part of a potential\n        // pattern. The CoverInitializedName check is deferred.\n\n\n        Parser.prototype.isolateCoverGrammar = function (parseFunction) {\n          var previousIsBindingElement = this.context.isBindingElement;\n          var previousIsAssignmentTarget = this.context.isAssignmentTarget;\n          var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;\n          this.context.isBindingElement = true;\n          this.context.isAssignmentTarget = true;\n          this.context.firstCoverInitializedNameError = null;\n          var result = parseFunction.call(this);\n\n          if (this.context.firstCoverInitializedNameError !== null) {\n            this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);\n          }\n\n          this.context.isBindingElement = previousIsBindingElement;\n          this.context.isAssignmentTarget = previousIsAssignmentTarget;\n          this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;\n          return result;\n        };\n\n        Parser.prototype.inheritCoverGrammar = function (parseFunction) {\n          var previousIsBindingElement = this.context.isBindingElement;\n          var previousIsAssignmentTarget = this.context.isAssignmentTarget;\n          var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;\n          this.context.isBindingElement = true;\n          this.context.isAssignmentTarget = true;\n          this.context.firstCoverInitializedNameError = null;\n          var result = parseFunction.call(this);\n          this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;\n          this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;\n          this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;\n          return result;\n        };\n\n        Parser.prototype.consumeSemicolon = function () {\n          if (this.match(';')) {\n            this.nextToken();\n          } else if (!this.hasLineTerminator) {\n            if (this.lookahead.type !== 2\n            /* EOF */\n            && !this.match('}')) {\n              this.throwUnexpectedToken(this.lookahead);\n            }\n\n            this.lastMarker.index = this.startMarker.index;\n            this.lastMarker.line = this.startMarker.line;\n            this.lastMarker.column = this.startMarker.column;\n          }\n        }; // https://tc39.github.io/ecma262/#sec-primary-expression\n\n\n        Parser.prototype.parsePrimaryExpression = function () {\n          var node = this.createNode();\n          var expr;\n          var token, raw;\n\n          switch (this.lookahead.type) {\n            case 3\n            /* Identifier */\n            :\n              if ((this.context.isModule || this.context[\"await\"]) && this.lookahead.value === 'await') {\n                this.tolerateUnexpectedToken(this.lookahead);\n              }\n\n              expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));\n              break;\n\n            case 6\n            /* NumericLiteral */\n            :\n            case 8\n            /* StringLiteral */\n            :\n              if (this.context.strict && this.lookahead.octal) {\n                this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);\n              }\n\n              this.context.isAssignmentTarget = false;\n              this.context.isBindingElement = false;\n              token = this.nextToken();\n              raw = this.getTokenRaw(token);\n              expr = this.finalize(node, new Node.Literal(token.value, raw));\n              break;\n\n            case 1\n            /* BooleanLiteral */\n            :\n              this.context.isAssignmentTarget = false;\n              this.context.isBindingElement = false;\n              token = this.nextToken();\n              raw = this.getTokenRaw(token);\n              expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));\n              break;\n\n            case 5\n            /* NullLiteral */\n            :\n              this.context.isAssignmentTarget = false;\n              this.context.isBindingElement = false;\n              token = this.nextToken();\n              raw = this.getTokenRaw(token);\n              expr = this.finalize(node, new Node.Literal(null, raw));\n              break;\n\n            case 10\n            /* Template */\n            :\n              expr = this.parseTemplateLiteral();\n              break;\n\n            case 7\n            /* Punctuator */\n            :\n              switch (this.lookahead.value) {\n                case '(':\n                  this.context.isBindingElement = false;\n                  expr = this.inheritCoverGrammar(this.parseGroupExpression);\n                  break;\n\n                case '[':\n                  expr = this.inheritCoverGrammar(this.parseArrayInitializer);\n                  break;\n\n                case '{':\n                  expr = this.inheritCoverGrammar(this.parseObjectInitializer);\n                  break;\n\n                case '/':\n                case '/=':\n                  this.context.isAssignmentTarget = false;\n                  this.context.isBindingElement = false;\n                  this.scanner.index = this.startMarker.index;\n                  token = this.nextRegexToken();\n                  raw = this.getTokenRaw(token);\n                  expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));\n                  break;\n\n                default:\n                  expr = this.throwUnexpectedToken(this.nextToken());\n              }\n\n              break;\n\n            case 4\n            /* Keyword */\n            :\n              if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {\n                expr = this.parseIdentifierName();\n              } else if (!this.context.strict && this.matchKeyword('let')) {\n                expr = this.finalize(node, new Node.Identifier(this.nextToken().value));\n              } else {\n                this.context.isAssignmentTarget = false;\n                this.context.isBindingElement = false;\n\n                if (this.matchKeyword('function')) {\n                  expr = this.parseFunctionExpression();\n                } else if (this.matchKeyword('this')) {\n                  this.nextToken();\n                  expr = this.finalize(node, new Node.ThisExpression());\n                } else if (this.matchKeyword('class')) {\n                  expr = this.parseClassExpression();\n                } else {\n                  expr = this.throwUnexpectedToken(this.nextToken());\n                }\n              }\n\n              break;\n\n            default:\n              expr = this.throwUnexpectedToken(this.nextToken());\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-array-initializer\n\n\n        Parser.prototype.parseSpreadElement = function () {\n          var node = this.createNode();\n          this.expect('...');\n          var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);\n          return this.finalize(node, new Node.SpreadElement(arg));\n        };\n\n        Parser.prototype.parseArrayInitializer = function () {\n          var node = this.createNode();\n          var elements = [];\n          this.expect('[');\n\n          while (!this.match(']')) {\n            if (this.match(',')) {\n              this.nextToken();\n              elements.push(null);\n            } else if (this.match('...')) {\n              var element = this.parseSpreadElement();\n\n              if (!this.match(']')) {\n                this.context.isAssignmentTarget = false;\n                this.context.isBindingElement = false;\n                this.expect(',');\n              }\n\n              elements.push(element);\n            } else {\n              elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));\n\n              if (!this.match(']')) {\n                this.expect(',');\n              }\n            }\n          }\n\n          this.expect(']');\n          return this.finalize(node, new Node.ArrayExpression(elements));\n        }; // https://tc39.github.io/ecma262/#sec-object-initializer\n\n\n        Parser.prototype.parsePropertyMethod = function (params) {\n          this.context.isAssignmentTarget = false;\n          this.context.isBindingElement = false;\n          var previousStrict = this.context.strict;\n          var previousAllowStrictDirective = this.context.allowStrictDirective;\n          this.context.allowStrictDirective = params.simple;\n          var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);\n\n          if (this.context.strict && params.firstRestricted) {\n            this.tolerateUnexpectedToken(params.firstRestricted, params.message);\n          }\n\n          if (this.context.strict && params.stricted) {\n            this.tolerateUnexpectedToken(params.stricted, params.message);\n          }\n\n          this.context.strict = previousStrict;\n          this.context.allowStrictDirective = previousAllowStrictDirective;\n          return body;\n        };\n\n        Parser.prototype.parsePropertyMethodFunction = function () {\n          var isGenerator = false;\n          var node = this.createNode();\n          var previousAllowYield = this.context.allowYield;\n          this.context.allowYield = true;\n          var params = this.parseFormalParameters();\n          var method = this.parsePropertyMethod(params);\n          this.context.allowYield = previousAllowYield;\n          return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));\n        };\n\n        Parser.prototype.parsePropertyMethodAsyncFunction = function () {\n          var node = this.createNode();\n          var previousAllowYield = this.context.allowYield;\n          var previousAwait = this.context[\"await\"];\n          this.context.allowYield = false;\n          this.context[\"await\"] = true;\n          var params = this.parseFormalParameters();\n          var method = this.parsePropertyMethod(params);\n          this.context.allowYield = previousAllowYield;\n          this.context[\"await\"] = previousAwait;\n          return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));\n        };\n\n        Parser.prototype.parseObjectPropertyKey = function () {\n          var node = this.createNode();\n          var token = this.nextToken();\n          var key;\n\n          switch (token.type) {\n            case 8\n            /* StringLiteral */\n            :\n            case 6\n            /* NumericLiteral */\n            :\n              if (this.context.strict && token.octal) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);\n              }\n\n              var raw = this.getTokenRaw(token);\n              key = this.finalize(node, new Node.Literal(token.value, raw));\n              break;\n\n            case 3\n            /* Identifier */\n            :\n            case 1\n            /* BooleanLiteral */\n            :\n            case 5\n            /* NullLiteral */\n            :\n            case 4\n            /* Keyword */\n            :\n              key = this.finalize(node, new Node.Identifier(token.value));\n              break;\n\n            case 7\n            /* Punctuator */\n            :\n              if (token.value === '[') {\n                key = this.isolateCoverGrammar(this.parseAssignmentExpression);\n                this.expect(']');\n              } else {\n                key = this.throwUnexpectedToken(token);\n              }\n\n              break;\n\n            default:\n              key = this.throwUnexpectedToken(token);\n          }\n\n          return key;\n        };\n\n        Parser.prototype.isPropertyKey = function (key, value) {\n          return key.type === syntax_1.Syntax.Identifier && key.name === value || key.type === syntax_1.Syntax.Literal && key.value === value;\n        };\n\n        Parser.prototype.parseObjectProperty = function (hasProto) {\n          var node = this.createNode();\n          var token = this.lookahead;\n          var kind;\n          var key = null;\n          var value = null;\n          var computed = false;\n          var method = false;\n          var shorthand = false;\n          var isAsync = false;\n\n          if (token.type === 3\n          /* Identifier */\n          ) {\n              var id = token.value;\n              this.nextToken();\n              computed = this.match('[');\n              isAsync = !this.hasLineTerminator && id === 'async' && !this.match(':') && !this.match('(') && !this.match('*') && !this.match(',');\n              key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));\n            } else if (this.match('*')) {\n            this.nextToken();\n          } else {\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n          }\n\n          var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);\n\n          if (token.type === 3\n          /* Identifier */\n          && !isAsync && token.value === 'get' && lookaheadPropertyKey) {\n            kind = 'get';\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            this.context.allowYield = false;\n            value = this.parseGetterMethod();\n          } else if (token.type === 3\n          /* Identifier */\n          && !isAsync && token.value === 'set' && lookaheadPropertyKey) {\n            kind = 'set';\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            value = this.parseSetterMethod();\n          } else if (token.type === 7\n          /* Punctuator */\n          && token.value === '*' && lookaheadPropertyKey) {\n            kind = 'init';\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            value = this.parseGeneratorMethod();\n            method = true;\n          } else {\n            if (!key) {\n              this.throwUnexpectedToken(this.lookahead);\n            }\n\n            kind = 'init';\n\n            if (this.match(':') && !isAsync) {\n              if (!computed && this.isPropertyKey(key, '__proto__')) {\n                if (hasProto.value) {\n                  this.tolerateError(messages_1.Messages.DuplicateProtoProperty);\n                }\n\n                hasProto.value = true;\n              }\n\n              this.nextToken();\n              value = this.inheritCoverGrammar(this.parseAssignmentExpression);\n            } else if (this.match('(')) {\n              value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();\n              method = true;\n            } else if (token.type === 3\n            /* Identifier */\n            ) {\n                var id = this.finalize(node, new Node.Identifier(token.value));\n\n                if (this.match('=')) {\n                  this.context.firstCoverInitializedNameError = this.lookahead;\n                  this.nextToken();\n                  shorthand = true;\n                  var init = this.isolateCoverGrammar(this.parseAssignmentExpression);\n                  value = this.finalize(node, new Node.AssignmentPattern(id, init));\n                } else {\n                  shorthand = true;\n                  value = id;\n                }\n              } else {\n              this.throwUnexpectedToken(this.nextToken());\n            }\n          }\n\n          return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));\n        };\n\n        Parser.prototype.parseObjectInitializer = function () {\n          var node = this.createNode();\n          this.expect('{');\n          var properties = [];\n          var hasProto = {\n            value: false\n          };\n\n          while (!this.match('}')) {\n            properties.push(this.parseObjectProperty(hasProto));\n\n            if (!this.match('}')) {\n              this.expectCommaSeparator();\n            }\n          }\n\n          this.expect('}');\n          return this.finalize(node, new Node.ObjectExpression(properties));\n        }; // https://tc39.github.io/ecma262/#sec-template-literals\n\n\n        Parser.prototype.parseTemplateHead = function () {\n          assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');\n          var node = this.createNode();\n          var token = this.nextToken();\n          var raw = token.value;\n          var cooked = token.cooked;\n          return this.finalize(node, new Node.TemplateElement({\n            raw: raw,\n            cooked: cooked\n          }, token.tail));\n        };\n\n        Parser.prototype.parseTemplateElement = function () {\n          if (this.lookahead.type !== 10\n          /* Template */\n          ) {\n              this.throwUnexpectedToken();\n            }\n\n          var node = this.createNode();\n          var token = this.nextToken();\n          var raw = token.value;\n          var cooked = token.cooked;\n          return this.finalize(node, new Node.TemplateElement({\n            raw: raw,\n            cooked: cooked\n          }, token.tail));\n        };\n\n        Parser.prototype.parseTemplateLiteral = function () {\n          var node = this.createNode();\n          var expressions = [];\n          var quasis = [];\n          var quasi = this.parseTemplateHead();\n          quasis.push(quasi);\n\n          while (!quasi.tail) {\n            expressions.push(this.parseExpression());\n            quasi = this.parseTemplateElement();\n            quasis.push(quasi);\n          }\n\n          return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));\n        }; // https://tc39.github.io/ecma262/#sec-grouping-operator\n\n\n        Parser.prototype.reinterpretExpressionAsPattern = function (expr) {\n          switch (expr.type) {\n            case syntax_1.Syntax.Identifier:\n            case syntax_1.Syntax.MemberExpression:\n            case syntax_1.Syntax.RestElement:\n            case syntax_1.Syntax.AssignmentPattern:\n              break;\n\n            case syntax_1.Syntax.SpreadElement:\n              expr.type = syntax_1.Syntax.RestElement;\n              this.reinterpretExpressionAsPattern(expr.argument);\n              break;\n\n            case syntax_1.Syntax.ArrayExpression:\n              expr.type = syntax_1.Syntax.ArrayPattern;\n\n              for (var i = 0; i < expr.elements.length; i++) {\n                if (expr.elements[i] !== null) {\n                  this.reinterpretExpressionAsPattern(expr.elements[i]);\n                }\n              }\n\n              break;\n\n            case syntax_1.Syntax.ObjectExpression:\n              expr.type = syntax_1.Syntax.ObjectPattern;\n\n              for (var i = 0; i < expr.properties.length; i++) {\n                this.reinterpretExpressionAsPattern(expr.properties[i].value);\n              }\n\n              break;\n\n            case syntax_1.Syntax.AssignmentExpression:\n              expr.type = syntax_1.Syntax.AssignmentPattern;\n              delete expr.operator;\n              this.reinterpretExpressionAsPattern(expr.left);\n              break;\n\n            default:\n              // Allow other node type for tolerant parsing.\n              break;\n          }\n        };\n\n        Parser.prototype.parseGroupExpression = function () {\n          var expr;\n          this.expect('(');\n\n          if (this.match(')')) {\n            this.nextToken();\n\n            if (!this.match('=>')) {\n              this.expect('=>');\n            }\n\n            expr = {\n              type: ArrowParameterPlaceHolder,\n              params: [],\n              async: false\n            };\n          } else {\n            var startToken = this.lookahead;\n            var params = [];\n\n            if (this.match('...')) {\n              expr = this.parseRestElement(params);\n              this.expect(')');\n\n              if (!this.match('=>')) {\n                this.expect('=>');\n              }\n\n              expr = {\n                type: ArrowParameterPlaceHolder,\n                params: [expr],\n                async: false\n              };\n            } else {\n              var arrow = false;\n              this.context.isBindingElement = true;\n              expr = this.inheritCoverGrammar(this.parseAssignmentExpression);\n\n              if (this.match(',')) {\n                var expressions = [];\n                this.context.isAssignmentTarget = false;\n                expressions.push(expr);\n\n                while (this.lookahead.type !== 2\n                /* EOF */\n                ) {\n                  if (!this.match(',')) {\n                    break;\n                  }\n\n                  this.nextToken();\n\n                  if (this.match(')')) {\n                    this.nextToken();\n\n                    for (var i = 0; i < expressions.length; i++) {\n                      this.reinterpretExpressionAsPattern(expressions[i]);\n                    }\n\n                    arrow = true;\n                    expr = {\n                      type: ArrowParameterPlaceHolder,\n                      params: expressions,\n                      async: false\n                    };\n                  } else if (this.match('...')) {\n                    if (!this.context.isBindingElement) {\n                      this.throwUnexpectedToken(this.lookahead);\n                    }\n\n                    expressions.push(this.parseRestElement(params));\n                    this.expect(')');\n\n                    if (!this.match('=>')) {\n                      this.expect('=>');\n                    }\n\n                    this.context.isBindingElement = false;\n\n                    for (var i = 0; i < expressions.length; i++) {\n                      this.reinterpretExpressionAsPattern(expressions[i]);\n                    }\n\n                    arrow = true;\n                    expr = {\n                      type: ArrowParameterPlaceHolder,\n                      params: expressions,\n                      async: false\n                    };\n                  } else {\n                    expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));\n                  }\n\n                  if (arrow) {\n                    break;\n                  }\n                }\n\n                if (!arrow) {\n                  expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));\n                }\n              }\n\n              if (!arrow) {\n                this.expect(')');\n\n                if (this.match('=>')) {\n                  if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {\n                    arrow = true;\n                    expr = {\n                      type: ArrowParameterPlaceHolder,\n                      params: [expr],\n                      async: false\n                    };\n                  }\n\n                  if (!arrow) {\n                    if (!this.context.isBindingElement) {\n                      this.throwUnexpectedToken(this.lookahead);\n                    }\n\n                    if (expr.type === syntax_1.Syntax.SequenceExpression) {\n                      for (var i = 0; i < expr.expressions.length; i++) {\n                        this.reinterpretExpressionAsPattern(expr.expressions[i]);\n                      }\n                    } else {\n                      this.reinterpretExpressionAsPattern(expr);\n                    }\n\n                    var parameters = expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr];\n                    expr = {\n                      type: ArrowParameterPlaceHolder,\n                      params: parameters,\n                      async: false\n                    };\n                  }\n                }\n\n                this.context.isBindingElement = false;\n              }\n            }\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions\n\n\n        Parser.prototype.parseArguments = function () {\n          this.expect('(');\n          var args = [];\n\n          if (!this.match(')')) {\n            while (true) {\n              var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAssignmentExpression);\n              args.push(expr);\n\n              if (this.match(')')) {\n                break;\n              }\n\n              this.expectCommaSeparator();\n\n              if (this.match(')')) {\n                break;\n              }\n            }\n          }\n\n          this.expect(')');\n          return args;\n        };\n\n        Parser.prototype.isIdentifierName = function (token) {\n          return token.type === 3\n          /* Identifier */\n          || token.type === 4\n          /* Keyword */\n          || token.type === 1\n          /* BooleanLiteral */\n          || token.type === 5\n          /* NullLiteral */\n          ;\n        };\n\n        Parser.prototype.parseIdentifierName = function () {\n          var node = this.createNode();\n          var token = this.nextToken();\n\n          if (!this.isIdentifierName(token)) {\n            this.throwUnexpectedToken(token);\n          }\n\n          return this.finalize(node, new Node.Identifier(token.value));\n        };\n\n        Parser.prototype.parseNewExpression = function () {\n          var node = this.createNode();\n          var id = this.parseIdentifierName();\n          assert_1.assert(id.name === 'new', 'New expression must start with `new`');\n          var expr;\n\n          if (this.match('.')) {\n            this.nextToken();\n\n            if (this.lookahead.type === 3\n            /* Identifier */\n            && this.context.inFunctionBody && this.lookahead.value === 'target') {\n              var property = this.parseIdentifierName();\n              expr = new Node.MetaProperty(id, property);\n            } else {\n              this.throwUnexpectedToken(this.lookahead);\n            }\n          } else {\n            var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);\n            var args = this.match('(') ? this.parseArguments() : [];\n            expr = new Node.NewExpression(callee, args);\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n          }\n\n          return this.finalize(node, expr);\n        };\n\n        Parser.prototype.parseAsyncArgument = function () {\n          var arg = this.parseAssignmentExpression();\n          this.context.firstCoverInitializedNameError = null;\n          return arg;\n        };\n\n        Parser.prototype.parseAsyncArguments = function () {\n          this.expect('(');\n          var args = [];\n\n          if (!this.match(')')) {\n            while (true) {\n              var expr = this.match('...') ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAsyncArgument);\n              args.push(expr);\n\n              if (this.match(')')) {\n                break;\n              }\n\n              this.expectCommaSeparator();\n\n              if (this.match(')')) {\n                break;\n              }\n            }\n          }\n\n          this.expect(')');\n          return args;\n        };\n\n        Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {\n          var startToken = this.lookahead;\n          var maybeAsync = this.matchContextualKeyword('async');\n          var previousAllowIn = this.context.allowIn;\n          this.context.allowIn = true;\n          var expr;\n\n          if (this.matchKeyword('super') && this.context.inFunctionBody) {\n            expr = this.createNode();\n            this.nextToken();\n            expr = this.finalize(expr, new Node.Super());\n\n            if (!this.match('(') && !this.match('.') && !this.match('[')) {\n              this.throwUnexpectedToken(this.lookahead);\n            }\n          } else {\n            expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);\n          }\n\n          while (true) {\n            if (this.match('.')) {\n              this.context.isBindingElement = false;\n              this.context.isAssignmentTarget = true;\n              this.expect('.');\n              var property = this.parseIdentifierName();\n              expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));\n            } else if (this.match('(')) {\n              var asyncArrow = maybeAsync && startToken.lineNumber === this.lookahead.lineNumber;\n              this.context.isBindingElement = false;\n              this.context.isAssignmentTarget = false;\n              var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();\n              expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));\n\n              if (asyncArrow && this.match('=>')) {\n                for (var i = 0; i < args.length; ++i) {\n                  this.reinterpretExpressionAsPattern(args[i]);\n                }\n\n                expr = {\n                  type: ArrowParameterPlaceHolder,\n                  params: args,\n                  async: true\n                };\n              }\n            } else if (this.match('[')) {\n              this.context.isBindingElement = false;\n              this.context.isAssignmentTarget = true;\n              this.expect('[');\n              var property = this.isolateCoverGrammar(this.parseExpression);\n              this.expect(']');\n              expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));\n            } else if (this.lookahead.type === 10\n            /* Template */\n            && this.lookahead.head) {\n              var quasi = this.parseTemplateLiteral();\n              expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));\n            } else {\n              break;\n            }\n          }\n\n          this.context.allowIn = previousAllowIn;\n          return expr;\n        };\n\n        Parser.prototype.parseSuper = function () {\n          var node = this.createNode();\n          this.expectKeyword('super');\n\n          if (!this.match('[') && !this.match('.')) {\n            this.throwUnexpectedToken(this.lookahead);\n          }\n\n          return this.finalize(node, new Node.Super());\n        };\n\n        Parser.prototype.parseLeftHandSideExpression = function () {\n          assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');\n          var node = this.startNode(this.lookahead);\n          var expr = this.matchKeyword('super') && this.context.inFunctionBody ? this.parseSuper() : this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);\n\n          while (true) {\n            if (this.match('[')) {\n              this.context.isBindingElement = false;\n              this.context.isAssignmentTarget = true;\n              this.expect('[');\n              var property = this.isolateCoverGrammar(this.parseExpression);\n              this.expect(']');\n              expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));\n            } else if (this.match('.')) {\n              this.context.isBindingElement = false;\n              this.context.isAssignmentTarget = true;\n              this.expect('.');\n              var property = this.parseIdentifierName();\n              expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));\n            } else if (this.lookahead.type === 10\n            /* Template */\n            && this.lookahead.head) {\n              var quasi = this.parseTemplateLiteral();\n              expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));\n            } else {\n              break;\n            }\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-update-expressions\n\n\n        Parser.prototype.parseUpdateExpression = function () {\n          var expr;\n          var startToken = this.lookahead;\n\n          if (this.match('++') || this.match('--')) {\n            var node = this.startNode(startToken);\n            var token = this.nextToken();\n            expr = this.inheritCoverGrammar(this.parseUnaryExpression);\n\n            if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {\n              this.tolerateError(messages_1.Messages.StrictLHSPrefix);\n            }\n\n            if (!this.context.isAssignmentTarget) {\n              this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);\n            }\n\n            var prefix = true;\n            expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n          } else {\n            expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);\n\n            if (!this.hasLineTerminator && this.lookahead.type === 7\n            /* Punctuator */\n            ) {\n                if (this.match('++') || this.match('--')) {\n                  if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {\n                    this.tolerateError(messages_1.Messages.StrictLHSPostfix);\n                  }\n\n                  if (!this.context.isAssignmentTarget) {\n                    this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);\n                  }\n\n                  this.context.isAssignmentTarget = false;\n                  this.context.isBindingElement = false;\n                  var operator = this.nextToken().value;\n                  var prefix = false;\n                  expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));\n                }\n              }\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-unary-operators\n\n\n        Parser.prototype.parseAwaitExpression = function () {\n          var node = this.createNode();\n          this.nextToken();\n          var argument = this.parseUnaryExpression();\n          return this.finalize(node, new Node.AwaitExpression(argument));\n        };\n\n        Parser.prototype.parseUnaryExpression = function () {\n          var expr;\n\n          if (this.match('+') || this.match('-') || this.match('~') || this.match('!') || this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {\n            var node = this.startNode(this.lookahead);\n            var token = this.nextToken();\n            expr = this.inheritCoverGrammar(this.parseUnaryExpression);\n            expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));\n\n            if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {\n              this.tolerateError(messages_1.Messages.StrictDelete);\n            }\n\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n          } else if (this.context[\"await\"] && this.matchContextualKeyword('await')) {\n            expr = this.parseAwaitExpression();\n          } else {\n            expr = this.parseUpdateExpression();\n          }\n\n          return expr;\n        };\n\n        Parser.prototype.parseExponentiationExpression = function () {\n          var startToken = this.lookahead;\n          var expr = this.inheritCoverGrammar(this.parseUnaryExpression);\n\n          if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {\n            this.nextToken();\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n            var left = expr;\n            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);\n            expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-exp-operator\n        // https://tc39.github.io/ecma262/#sec-multiplicative-operators\n        // https://tc39.github.io/ecma262/#sec-additive-operators\n        // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators\n        // https://tc39.github.io/ecma262/#sec-relational-operators\n        // https://tc39.github.io/ecma262/#sec-equality-operators\n        // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators\n        // https://tc39.github.io/ecma262/#sec-binary-logical-operators\n\n\n        Parser.prototype.binaryPrecedence = function (token) {\n          var op = token.value;\n          var precedence;\n\n          if (token.type === 7\n          /* Punctuator */\n          ) {\n              precedence = this.operatorPrecedence[op] || 0;\n            } else if (token.type === 4\n          /* Keyword */\n          ) {\n              precedence = op === 'instanceof' || this.context.allowIn && op === 'in' ? 7 : 0;\n            } else {\n            precedence = 0;\n          }\n\n          return precedence;\n        };\n\n        Parser.prototype.parseBinaryExpression = function () {\n          var startToken = this.lookahead;\n          var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);\n          var token = this.lookahead;\n          var prec = this.binaryPrecedence(token);\n\n          if (prec > 0) {\n            this.nextToken();\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n            var markers = [startToken, this.lookahead];\n            var left = expr;\n            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);\n            var stack = [left, token.value, right];\n            var precedences = [prec];\n\n            while (true) {\n              prec = this.binaryPrecedence(this.lookahead);\n\n              if (prec <= 0) {\n                break;\n              } // Reduce: make a binary expression from the three topmost entries.\n\n\n              while (stack.length > 2 && prec <= precedences[precedences.length - 1]) {\n                right = stack.pop();\n                var operator = stack.pop();\n                precedences.pop();\n                left = stack.pop();\n                markers.pop();\n                var node = this.startNode(markers[markers.length - 1]);\n                stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));\n              } // Shift.\n\n\n              stack.push(this.nextToken().value);\n              precedences.push(prec);\n              markers.push(this.lookahead);\n              stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));\n            } // Final reduce to clean-up the stack.\n\n\n            var i = stack.length - 1;\n            expr = stack[i];\n            var lastMarker = markers.pop();\n\n            while (i > 1) {\n              var marker = markers.pop();\n              var lastLineStart = lastMarker && lastMarker.lineStart;\n              var node = this.startNode(marker, lastLineStart);\n              var operator = stack[i - 1];\n              expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));\n              i -= 2;\n              lastMarker = marker;\n            }\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-conditional-operator\n\n\n        Parser.prototype.parseConditionalExpression = function () {\n          var startToken = this.lookahead;\n          var expr = this.inheritCoverGrammar(this.parseBinaryExpression);\n\n          if (this.match('?')) {\n            this.nextToken();\n            var previousAllowIn = this.context.allowIn;\n            this.context.allowIn = true;\n            var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);\n            this.context.allowIn = previousAllowIn;\n            this.expect(':');\n            var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);\n            expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));\n            this.context.isAssignmentTarget = false;\n            this.context.isBindingElement = false;\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-assignment-operators\n\n\n        Parser.prototype.checkPatternParam = function (options, param) {\n          switch (param.type) {\n            case syntax_1.Syntax.Identifier:\n              this.validateParam(options, param, param.name);\n              break;\n\n            case syntax_1.Syntax.RestElement:\n              this.checkPatternParam(options, param.argument);\n              break;\n\n            case syntax_1.Syntax.AssignmentPattern:\n              this.checkPatternParam(options, param.left);\n              break;\n\n            case syntax_1.Syntax.ArrayPattern:\n              for (var i = 0; i < param.elements.length; i++) {\n                if (param.elements[i] !== null) {\n                  this.checkPatternParam(options, param.elements[i]);\n                }\n              }\n\n              break;\n\n            case syntax_1.Syntax.ObjectPattern:\n              for (var i = 0; i < param.properties.length; i++) {\n                this.checkPatternParam(options, param.properties[i].value);\n              }\n\n              break;\n\n            default:\n              break;\n          }\n\n          options.simple = options.simple && param instanceof Node.Identifier;\n        };\n\n        Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {\n          var params = [expr];\n          var options;\n          var asyncArrow = false;\n\n          switch (expr.type) {\n            case syntax_1.Syntax.Identifier:\n              break;\n\n            case ArrowParameterPlaceHolder:\n              params = expr.params;\n              asyncArrow = expr.async;\n              break;\n\n            default:\n              return null;\n          }\n\n          options = {\n            simple: true,\n            paramSet: {}\n          };\n\n          for (var i = 0; i < params.length; ++i) {\n            var param = params[i];\n\n            if (param.type === syntax_1.Syntax.AssignmentPattern) {\n              if (param.right.type === syntax_1.Syntax.YieldExpression) {\n                if (param.right.argument) {\n                  this.throwUnexpectedToken(this.lookahead);\n                }\n\n                param.right.type = syntax_1.Syntax.Identifier;\n                param.right.name = 'yield';\n                delete param.right.argument;\n                delete param.right.delegate;\n              }\n            } else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {\n              this.throwUnexpectedToken(this.lookahead);\n            }\n\n            this.checkPatternParam(options, param);\n            params[i] = param;\n          }\n\n          if (this.context.strict || !this.context.allowYield) {\n            for (var i = 0; i < params.length; ++i) {\n              var param = params[i];\n\n              if (param.type === syntax_1.Syntax.YieldExpression) {\n                this.throwUnexpectedToken(this.lookahead);\n              }\n            }\n          }\n\n          if (options.message === messages_1.Messages.StrictParamDupe) {\n            var token = this.context.strict ? options.stricted : options.firstRestricted;\n            this.throwUnexpectedToken(token, options.message);\n          }\n\n          return {\n            simple: options.simple,\n            params: params,\n            stricted: options.stricted,\n            firstRestricted: options.firstRestricted,\n            message: options.message\n          };\n        };\n\n        Parser.prototype.parseAssignmentExpression = function () {\n          var expr;\n\n          if (!this.context.allowYield && this.matchKeyword('yield')) {\n            expr = this.parseYieldExpression();\n          } else {\n            var startToken = this.lookahead;\n            var token = startToken;\n            expr = this.parseConditionalExpression();\n\n            if (token.type === 3\n            /* Identifier */\n            && token.lineNumber === this.lookahead.lineNumber && token.value === 'async') {\n              if (this.lookahead.type === 3\n              /* Identifier */\n              || this.matchKeyword('yield')) {\n                var arg = this.parsePrimaryExpression();\n                this.reinterpretExpressionAsPattern(arg);\n                expr = {\n                  type: ArrowParameterPlaceHolder,\n                  params: [arg],\n                  async: true\n                };\n              }\n            }\n\n            if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {\n              // https://tc39.github.io/ecma262/#sec-arrow-function-definitions\n              this.context.isAssignmentTarget = false;\n              this.context.isBindingElement = false;\n              var isAsync = expr.async;\n              var list = this.reinterpretAsCoverFormalsList(expr);\n\n              if (list) {\n                if (this.hasLineTerminator) {\n                  this.tolerateUnexpectedToken(this.lookahead);\n                }\n\n                this.context.firstCoverInitializedNameError = null;\n                var previousStrict = this.context.strict;\n                var previousAllowStrictDirective = this.context.allowStrictDirective;\n                this.context.allowStrictDirective = list.simple;\n                var previousAllowYield = this.context.allowYield;\n                var previousAwait = this.context[\"await\"];\n                this.context.allowYield = true;\n                this.context[\"await\"] = isAsync;\n                var node = this.startNode(startToken);\n                this.expect('=>');\n                var body = void 0;\n\n                if (this.match('{')) {\n                  var previousAllowIn = this.context.allowIn;\n                  this.context.allowIn = true;\n                  body = this.parseFunctionSourceElements();\n                  this.context.allowIn = previousAllowIn;\n                } else {\n                  body = this.isolateCoverGrammar(this.parseAssignmentExpression);\n                }\n\n                var expression = body.type !== syntax_1.Syntax.BlockStatement;\n\n                if (this.context.strict && list.firstRestricted) {\n                  this.throwUnexpectedToken(list.firstRestricted, list.message);\n                }\n\n                if (this.context.strict && list.stricted) {\n                  this.tolerateUnexpectedToken(list.stricted, list.message);\n                }\n\n                expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) : this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));\n                this.context.strict = previousStrict;\n                this.context.allowStrictDirective = previousAllowStrictDirective;\n                this.context.allowYield = previousAllowYield;\n                this.context[\"await\"] = previousAwait;\n              }\n            } else {\n              if (this.matchAssign()) {\n                if (!this.context.isAssignmentTarget) {\n                  this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);\n                }\n\n                if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {\n                  var id = expr;\n\n                  if (this.scanner.isRestrictedWord(id.name)) {\n                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);\n                  }\n\n                  if (this.scanner.isStrictModeReservedWord(id.name)) {\n                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);\n                  }\n                }\n\n                if (!this.match('=')) {\n                  this.context.isAssignmentTarget = false;\n                  this.context.isBindingElement = false;\n                } else {\n                  this.reinterpretExpressionAsPattern(expr);\n                }\n\n                token = this.nextToken();\n                var operator = token.value;\n                var right = this.isolateCoverGrammar(this.parseAssignmentExpression);\n                expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));\n                this.context.firstCoverInitializedNameError = null;\n              }\n            }\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-comma-operator\n\n\n        Parser.prototype.parseExpression = function () {\n          var startToken = this.lookahead;\n          var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);\n\n          if (this.match(',')) {\n            var expressions = [];\n            expressions.push(expr);\n\n            while (this.lookahead.type !== 2\n            /* EOF */\n            ) {\n              if (!this.match(',')) {\n                break;\n              }\n\n              this.nextToken();\n              expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));\n            }\n\n            expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));\n          }\n\n          return expr;\n        }; // https://tc39.github.io/ecma262/#sec-block\n\n\n        Parser.prototype.parseStatementListItem = function () {\n          var statement;\n          this.context.isAssignmentTarget = true;\n          this.context.isBindingElement = true;\n\n          if (this.lookahead.type === 4\n          /* Keyword */\n          ) {\n              switch (this.lookahead.value) {\n                case 'export':\n                  if (!this.context.isModule) {\n                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);\n                  }\n\n                  statement = this.parseExportDeclaration();\n                  break;\n\n                case 'import':\n                  if (!this.context.isModule) {\n                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);\n                  }\n\n                  statement = this.parseImportDeclaration();\n                  break;\n\n                case 'const':\n                  statement = this.parseLexicalDeclaration({\n                    inFor: false\n                  });\n                  break;\n\n                case 'function':\n                  statement = this.parseFunctionDeclaration();\n                  break;\n\n                case 'class':\n                  statement = this.parseClassDeclaration();\n                  break;\n\n                case 'let':\n                  statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({\n                    inFor: false\n                  }) : this.parseStatement();\n                  break;\n\n                default:\n                  statement = this.parseStatement();\n                  break;\n              }\n            } else {\n            statement = this.parseStatement();\n          }\n\n          return statement;\n        };\n\n        Parser.prototype.parseBlock = function () {\n          var node = this.createNode();\n          this.expect('{');\n          var block = [];\n\n          while (true) {\n            if (this.match('}')) {\n              break;\n            }\n\n            block.push(this.parseStatementListItem());\n          }\n\n          this.expect('}');\n          return this.finalize(node, new Node.BlockStatement(block));\n        }; // https://tc39.github.io/ecma262/#sec-let-and-const-declarations\n\n\n        Parser.prototype.parseLexicalBinding = function (kind, options) {\n          var node = this.createNode();\n          var params = [];\n          var id = this.parsePattern(params, kind);\n\n          if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {\n            if (this.scanner.isRestrictedWord(id.name)) {\n              this.tolerateError(messages_1.Messages.StrictVarName);\n            }\n          }\n\n          var init = null;\n\n          if (kind === 'const') {\n            if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {\n              if (this.match('=')) {\n                this.nextToken();\n                init = this.isolateCoverGrammar(this.parseAssignmentExpression);\n              } else {\n                this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');\n              }\n            }\n          } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match('=')) {\n            this.expect('=');\n            init = this.isolateCoverGrammar(this.parseAssignmentExpression);\n          }\n\n          return this.finalize(node, new Node.VariableDeclarator(id, init));\n        };\n\n        Parser.prototype.parseBindingList = function (kind, options) {\n          var list = [this.parseLexicalBinding(kind, options)];\n\n          while (this.match(',')) {\n            this.nextToken();\n            list.push(this.parseLexicalBinding(kind, options));\n          }\n\n          return list;\n        };\n\n        Parser.prototype.isLexicalDeclaration = function () {\n          var state = this.scanner.saveState();\n          this.scanner.scanComments();\n          var next = this.scanner.lex();\n          this.scanner.restoreState(state);\n          return next.type === 3\n          /* Identifier */\n          || next.type === 7\n          /* Punctuator */\n          && next.value === '[' || next.type === 7\n          /* Punctuator */\n          && next.value === '{' || next.type === 4\n          /* Keyword */\n          && next.value === 'let' || next.type === 4\n          /* Keyword */\n          && next.value === 'yield';\n        };\n\n        Parser.prototype.parseLexicalDeclaration = function (options) {\n          var node = this.createNode();\n          var kind = this.nextToken().value;\n          assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');\n          var declarations = this.parseBindingList(kind, options);\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.VariableDeclaration(declarations, kind));\n        }; // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns\n\n\n        Parser.prototype.parseBindingRestElement = function (params, kind) {\n          var node = this.createNode();\n          this.expect('...');\n          var arg = this.parsePattern(params, kind);\n          return this.finalize(node, new Node.RestElement(arg));\n        };\n\n        Parser.prototype.parseArrayPattern = function (params, kind) {\n          var node = this.createNode();\n          this.expect('[');\n          var elements = [];\n\n          while (!this.match(']')) {\n            if (this.match(',')) {\n              this.nextToken();\n              elements.push(null);\n            } else {\n              if (this.match('...')) {\n                elements.push(this.parseBindingRestElement(params, kind));\n                break;\n              } else {\n                elements.push(this.parsePatternWithDefault(params, kind));\n              }\n\n              if (!this.match(']')) {\n                this.expect(',');\n              }\n            }\n          }\n\n          this.expect(']');\n          return this.finalize(node, new Node.ArrayPattern(elements));\n        };\n\n        Parser.prototype.parsePropertyPattern = function (params, kind) {\n          var node = this.createNode();\n          var computed = false;\n          var shorthand = false;\n          var method = false;\n          var key;\n          var value;\n\n          if (this.lookahead.type === 3\n          /* Identifier */\n          ) {\n              var keyToken = this.lookahead;\n              key = this.parseVariableIdentifier();\n              var init = this.finalize(node, new Node.Identifier(keyToken.value));\n\n              if (this.match('=')) {\n                params.push(keyToken);\n                shorthand = true;\n                this.nextToken();\n                var expr = this.parseAssignmentExpression();\n                value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));\n              } else if (!this.match(':')) {\n                params.push(keyToken);\n                shorthand = true;\n                value = init;\n              } else {\n                this.expect(':');\n                value = this.parsePatternWithDefault(params, kind);\n              }\n            } else {\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            this.expect(':');\n            value = this.parsePatternWithDefault(params, kind);\n          }\n\n          return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));\n        };\n\n        Parser.prototype.parseObjectPattern = function (params, kind) {\n          var node = this.createNode();\n          var properties = [];\n          this.expect('{');\n\n          while (!this.match('}')) {\n            properties.push(this.parsePropertyPattern(params, kind));\n\n            if (!this.match('}')) {\n              this.expect(',');\n            }\n          }\n\n          this.expect('}');\n          return this.finalize(node, new Node.ObjectPattern(properties));\n        };\n\n        Parser.prototype.parsePattern = function (params, kind) {\n          var pattern;\n\n          if (this.match('[')) {\n            pattern = this.parseArrayPattern(params, kind);\n          } else if (this.match('{')) {\n            pattern = this.parseObjectPattern(params, kind);\n          } else {\n            if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {\n              this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);\n            }\n\n            params.push(this.lookahead);\n            pattern = this.parseVariableIdentifier(kind);\n          }\n\n          return pattern;\n        };\n\n        Parser.prototype.parsePatternWithDefault = function (params, kind) {\n          var startToken = this.lookahead;\n          var pattern = this.parsePattern(params, kind);\n\n          if (this.match('=')) {\n            this.nextToken();\n            var previousAllowYield = this.context.allowYield;\n            this.context.allowYield = true;\n            var right = this.isolateCoverGrammar(this.parseAssignmentExpression);\n            this.context.allowYield = previousAllowYield;\n            pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));\n          }\n\n          return pattern;\n        }; // https://tc39.github.io/ecma262/#sec-variable-statement\n\n\n        Parser.prototype.parseVariableIdentifier = function (kind) {\n          var node = this.createNode();\n          var token = this.nextToken();\n\n          if (token.type === 4\n          /* Keyword */\n          && token.value === 'yield') {\n            if (this.context.strict) {\n              this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);\n            } else if (!this.context.allowYield) {\n              this.throwUnexpectedToken(token);\n            }\n          } else if (token.type !== 3\n          /* Identifier */\n          ) {\n              if (this.context.strict && token.type === 4\n              /* Keyword */\n              && this.scanner.isStrictModeReservedWord(token.value)) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);\n              } else {\n                if (this.context.strict || token.value !== 'let' || kind !== 'var') {\n                  this.throwUnexpectedToken(token);\n                }\n              }\n            } else if ((this.context.isModule || this.context[\"await\"]) && token.type === 3\n          /* Identifier */\n          && token.value === 'await') {\n            this.tolerateUnexpectedToken(token);\n          }\n\n          return this.finalize(node, new Node.Identifier(token.value));\n        };\n\n        Parser.prototype.parseVariableDeclaration = function (options) {\n          var node = this.createNode();\n          var params = [];\n          var id = this.parsePattern(params, 'var');\n\n          if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {\n            if (this.scanner.isRestrictedWord(id.name)) {\n              this.tolerateError(messages_1.Messages.StrictVarName);\n            }\n          }\n\n          var init = null;\n\n          if (this.match('=')) {\n            this.nextToken();\n            init = this.isolateCoverGrammar(this.parseAssignmentExpression);\n          } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {\n            this.expect('=');\n          }\n\n          return this.finalize(node, new Node.VariableDeclarator(id, init));\n        };\n\n        Parser.prototype.parseVariableDeclarationList = function (options) {\n          var opt = {\n            inFor: options.inFor\n          };\n          var list = [];\n          list.push(this.parseVariableDeclaration(opt));\n\n          while (this.match(',')) {\n            this.nextToken();\n            list.push(this.parseVariableDeclaration(opt));\n          }\n\n          return list;\n        };\n\n        Parser.prototype.parseVariableStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('var');\n          var declarations = this.parseVariableDeclarationList({\n            inFor: false\n          });\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));\n        }; // https://tc39.github.io/ecma262/#sec-empty-statement\n\n\n        Parser.prototype.parseEmptyStatement = function () {\n          var node = this.createNode();\n          this.expect(';');\n          return this.finalize(node, new Node.EmptyStatement());\n        }; // https://tc39.github.io/ecma262/#sec-expression-statement\n\n\n        Parser.prototype.parseExpressionStatement = function () {\n          var node = this.createNode();\n          var expr = this.parseExpression();\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.ExpressionStatement(expr));\n        }; // https://tc39.github.io/ecma262/#sec-if-statement\n\n\n        Parser.prototype.parseIfClause = function () {\n          if (this.context.strict && this.matchKeyword('function')) {\n            this.tolerateError(messages_1.Messages.StrictFunction);\n          }\n\n          return this.parseStatement();\n        };\n\n        Parser.prototype.parseIfStatement = function () {\n          var node = this.createNode();\n          var consequent;\n          var alternate = null;\n          this.expectKeyword('if');\n          this.expect('(');\n          var test = this.parseExpression();\n\n          if (!this.match(')') && this.config.tolerant) {\n            this.tolerateUnexpectedToken(this.nextToken());\n            consequent = this.finalize(this.createNode(), new Node.EmptyStatement());\n          } else {\n            this.expect(')');\n            consequent = this.parseIfClause();\n\n            if (this.matchKeyword('else')) {\n              this.nextToken();\n              alternate = this.parseIfClause();\n            }\n          }\n\n          return this.finalize(node, new Node.IfStatement(test, consequent, alternate));\n        }; // https://tc39.github.io/ecma262/#sec-do-while-statement\n\n\n        Parser.prototype.parseDoWhileStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('do');\n          var previousInIteration = this.context.inIteration;\n          this.context.inIteration = true;\n          var body = this.parseStatement();\n          this.context.inIteration = previousInIteration;\n          this.expectKeyword('while');\n          this.expect('(');\n          var test = this.parseExpression();\n\n          if (!this.match(')') && this.config.tolerant) {\n            this.tolerateUnexpectedToken(this.nextToken());\n          } else {\n            this.expect(')');\n\n            if (this.match(';')) {\n              this.nextToken();\n            }\n          }\n\n          return this.finalize(node, new Node.DoWhileStatement(body, test));\n        }; // https://tc39.github.io/ecma262/#sec-while-statement\n\n\n        Parser.prototype.parseWhileStatement = function () {\n          var node = this.createNode();\n          var body;\n          this.expectKeyword('while');\n          this.expect('(');\n          var test = this.parseExpression();\n\n          if (!this.match(')') && this.config.tolerant) {\n            this.tolerateUnexpectedToken(this.nextToken());\n            body = this.finalize(this.createNode(), new Node.EmptyStatement());\n          } else {\n            this.expect(')');\n            var previousInIteration = this.context.inIteration;\n            this.context.inIteration = true;\n            body = this.parseStatement();\n            this.context.inIteration = previousInIteration;\n          }\n\n          return this.finalize(node, new Node.WhileStatement(test, body));\n        }; // https://tc39.github.io/ecma262/#sec-for-statement\n        // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements\n\n\n        Parser.prototype.parseForStatement = function () {\n          var init = null;\n          var test = null;\n          var update = null;\n          var forIn = true;\n          var left, right;\n          var node = this.createNode();\n          this.expectKeyword('for');\n          this.expect('(');\n\n          if (this.match(';')) {\n            this.nextToken();\n          } else {\n            if (this.matchKeyword('var')) {\n              init = this.createNode();\n              this.nextToken();\n              var previousAllowIn = this.context.allowIn;\n              this.context.allowIn = false;\n              var declarations = this.parseVariableDeclarationList({\n                inFor: true\n              });\n              this.context.allowIn = previousAllowIn;\n\n              if (declarations.length === 1 && this.matchKeyword('in')) {\n                var decl = declarations[0];\n\n                if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {\n                  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');\n                }\n\n                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));\n                this.nextToken();\n                left = init;\n                right = this.parseExpression();\n                init = null;\n              } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {\n                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));\n                this.nextToken();\n                left = init;\n                right = this.parseAssignmentExpression();\n                init = null;\n                forIn = false;\n              } else {\n                init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));\n                this.expect(';');\n              }\n            } else if (this.matchKeyword('const') || this.matchKeyword('let')) {\n              init = this.createNode();\n              var kind = this.nextToken().value;\n\n              if (!this.context.strict && this.lookahead.value === 'in') {\n                init = this.finalize(init, new Node.Identifier(kind));\n                this.nextToken();\n                left = init;\n                right = this.parseExpression();\n                init = null;\n              } else {\n                var previousAllowIn = this.context.allowIn;\n                this.context.allowIn = false;\n                var declarations = this.parseBindingList(kind, {\n                  inFor: true\n                });\n                this.context.allowIn = previousAllowIn;\n\n                if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {\n                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));\n                  this.nextToken();\n                  left = init;\n                  right = this.parseExpression();\n                  init = null;\n                } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {\n                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));\n                  this.nextToken();\n                  left = init;\n                  right = this.parseAssignmentExpression();\n                  init = null;\n                  forIn = false;\n                } else {\n                  this.consumeSemicolon();\n                  init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));\n                }\n              }\n            } else {\n              var initStartToken = this.lookahead;\n              var previousAllowIn = this.context.allowIn;\n              this.context.allowIn = false;\n              init = this.inheritCoverGrammar(this.parseAssignmentExpression);\n              this.context.allowIn = previousAllowIn;\n\n              if (this.matchKeyword('in')) {\n                if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {\n                  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);\n                }\n\n                this.nextToken();\n                this.reinterpretExpressionAsPattern(init);\n                left = init;\n                right = this.parseExpression();\n                init = null;\n              } else if (this.matchContextualKeyword('of')) {\n                if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {\n                  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);\n                }\n\n                this.nextToken();\n                this.reinterpretExpressionAsPattern(init);\n                left = init;\n                right = this.parseAssignmentExpression();\n                init = null;\n                forIn = false;\n              } else {\n                if (this.match(',')) {\n                  var initSeq = [init];\n\n                  while (this.match(',')) {\n                    this.nextToken();\n                    initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));\n                  }\n\n                  init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));\n                }\n\n                this.expect(';');\n              }\n            }\n          }\n\n          if (typeof left === 'undefined') {\n            if (!this.match(';')) {\n              test = this.parseExpression();\n            }\n\n            this.expect(';');\n\n            if (!this.match(')')) {\n              update = this.parseExpression();\n            }\n          }\n\n          var body;\n\n          if (!this.match(')') && this.config.tolerant) {\n            this.tolerateUnexpectedToken(this.nextToken());\n            body = this.finalize(this.createNode(), new Node.EmptyStatement());\n          } else {\n            this.expect(')');\n            var previousInIteration = this.context.inIteration;\n            this.context.inIteration = true;\n            body = this.isolateCoverGrammar(this.parseStatement);\n            this.context.inIteration = previousInIteration;\n          }\n\n          return typeof left === 'undefined' ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));\n        }; // https://tc39.github.io/ecma262/#sec-continue-statement\n\n\n        Parser.prototype.parseContinueStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('continue');\n          var label = null;\n\n          if (this.lookahead.type === 3\n          /* Identifier */\n          && !this.hasLineTerminator) {\n            var id = this.parseVariableIdentifier();\n            label = id;\n            var key = '$' + id.name;\n\n            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {\n              this.throwError(messages_1.Messages.UnknownLabel, id.name);\n            }\n          }\n\n          this.consumeSemicolon();\n\n          if (label === null && !this.context.inIteration) {\n            this.throwError(messages_1.Messages.IllegalContinue);\n          }\n\n          return this.finalize(node, new Node.ContinueStatement(label));\n        }; // https://tc39.github.io/ecma262/#sec-break-statement\n\n\n        Parser.prototype.parseBreakStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('break');\n          var label = null;\n\n          if (this.lookahead.type === 3\n          /* Identifier */\n          && !this.hasLineTerminator) {\n            var id = this.parseVariableIdentifier();\n            var key = '$' + id.name;\n\n            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {\n              this.throwError(messages_1.Messages.UnknownLabel, id.name);\n            }\n\n            label = id;\n          }\n\n          this.consumeSemicolon();\n\n          if (label === null && !this.context.inIteration && !this.context.inSwitch) {\n            this.throwError(messages_1.Messages.IllegalBreak);\n          }\n\n          return this.finalize(node, new Node.BreakStatement(label));\n        }; // https://tc39.github.io/ecma262/#sec-return-statement\n\n\n        Parser.prototype.parseReturnStatement = function () {\n          if (!this.context.inFunctionBody) {\n            this.tolerateError(messages_1.Messages.IllegalReturn);\n          }\n\n          var node = this.createNode();\n          this.expectKeyword('return');\n          var hasArgument = !this.match(';') && !this.match('}') && !this.hasLineTerminator && this.lookahead.type !== 2\n          /* EOF */\n          || this.lookahead.type === 8\n          /* StringLiteral */\n          || this.lookahead.type === 10\n          /* Template */\n          ;\n          var argument = hasArgument ? this.parseExpression() : null;\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.ReturnStatement(argument));\n        }; // https://tc39.github.io/ecma262/#sec-with-statement\n\n\n        Parser.prototype.parseWithStatement = function () {\n          if (this.context.strict) {\n            this.tolerateError(messages_1.Messages.StrictModeWith);\n          }\n\n          var node = this.createNode();\n          var body;\n          this.expectKeyword('with');\n          this.expect('(');\n          var object = this.parseExpression();\n\n          if (!this.match(')') && this.config.tolerant) {\n            this.tolerateUnexpectedToken(this.nextToken());\n            body = this.finalize(this.createNode(), new Node.EmptyStatement());\n          } else {\n            this.expect(')');\n            body = this.parseStatement();\n          }\n\n          return this.finalize(node, new Node.WithStatement(object, body));\n        }; // https://tc39.github.io/ecma262/#sec-switch-statement\n\n\n        Parser.prototype.parseSwitchCase = function () {\n          var node = this.createNode();\n          var test;\n\n          if (this.matchKeyword('default')) {\n            this.nextToken();\n            test = null;\n          } else {\n            this.expectKeyword('case');\n            test = this.parseExpression();\n          }\n\n          this.expect(':');\n          var consequent = [];\n\n          while (true) {\n            if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {\n              break;\n            }\n\n            consequent.push(this.parseStatementListItem());\n          }\n\n          return this.finalize(node, new Node.SwitchCase(test, consequent));\n        };\n\n        Parser.prototype.parseSwitchStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('switch');\n          this.expect('(');\n          var discriminant = this.parseExpression();\n          this.expect(')');\n          var previousInSwitch = this.context.inSwitch;\n          this.context.inSwitch = true;\n          var cases = [];\n          var defaultFound = false;\n          this.expect('{');\n\n          while (true) {\n            if (this.match('}')) {\n              break;\n            }\n\n            var clause = this.parseSwitchCase();\n\n            if (clause.test === null) {\n              if (defaultFound) {\n                this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);\n              }\n\n              defaultFound = true;\n            }\n\n            cases.push(clause);\n          }\n\n          this.expect('}');\n          this.context.inSwitch = previousInSwitch;\n          return this.finalize(node, new Node.SwitchStatement(discriminant, cases));\n        }; // https://tc39.github.io/ecma262/#sec-labelled-statements\n\n\n        Parser.prototype.parseLabelledStatement = function () {\n          var node = this.createNode();\n          var expr = this.parseExpression();\n          var statement;\n\n          if (expr.type === syntax_1.Syntax.Identifier && this.match(':')) {\n            this.nextToken();\n            var id = expr;\n            var key = '$' + id.name;\n\n            if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {\n              this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);\n            }\n\n            this.context.labelSet[key] = true;\n            var body = void 0;\n\n            if (this.matchKeyword('class')) {\n              this.tolerateUnexpectedToken(this.lookahead);\n              body = this.parseClassDeclaration();\n            } else if (this.matchKeyword('function')) {\n              var token = this.lookahead;\n              var declaration = this.parseFunctionDeclaration();\n\n              if (this.context.strict) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);\n              } else if (declaration.generator) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);\n              }\n\n              body = declaration;\n            } else {\n              body = this.parseStatement();\n            }\n\n            delete this.context.labelSet[key];\n            statement = new Node.LabeledStatement(id, body);\n          } else {\n            this.consumeSemicolon();\n            statement = new Node.ExpressionStatement(expr);\n          }\n\n          return this.finalize(node, statement);\n        }; // https://tc39.github.io/ecma262/#sec-throw-statement\n\n\n        Parser.prototype.parseThrowStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('throw');\n\n          if (this.hasLineTerminator) {\n            this.throwError(messages_1.Messages.NewlineAfterThrow);\n          }\n\n          var argument = this.parseExpression();\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.ThrowStatement(argument));\n        }; // https://tc39.github.io/ecma262/#sec-try-statement\n\n\n        Parser.prototype.parseCatchClause = function () {\n          var node = this.createNode();\n          this.expectKeyword('catch');\n          this.expect('(');\n\n          if (this.match(')')) {\n            this.throwUnexpectedToken(this.lookahead);\n          }\n\n          var params = [];\n          var param = this.parsePattern(params);\n          var paramMap = {};\n\n          for (var i = 0; i < params.length; i++) {\n            var key = '$' + params[i].value;\n\n            if (Object.prototype.hasOwnProperty.call(paramMap, key)) {\n              this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);\n            }\n\n            paramMap[key] = true;\n          }\n\n          if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {\n            if (this.scanner.isRestrictedWord(param.name)) {\n              this.tolerateError(messages_1.Messages.StrictCatchVariable);\n            }\n          }\n\n          this.expect(')');\n          var body = this.parseBlock();\n          return this.finalize(node, new Node.CatchClause(param, body));\n        };\n\n        Parser.prototype.parseFinallyClause = function () {\n          this.expectKeyword('finally');\n          return this.parseBlock();\n        };\n\n        Parser.prototype.parseTryStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('try');\n          var block = this.parseBlock();\n          var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;\n          var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;\n\n          if (!handler && !finalizer) {\n            this.throwError(messages_1.Messages.NoCatchOrFinally);\n          }\n\n          return this.finalize(node, new Node.TryStatement(block, handler, finalizer));\n        }; // https://tc39.github.io/ecma262/#sec-debugger-statement\n\n\n        Parser.prototype.parseDebuggerStatement = function () {\n          var node = this.createNode();\n          this.expectKeyword('debugger');\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.DebuggerStatement());\n        }; // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations\n\n\n        Parser.prototype.parseStatement = function () {\n          var statement;\n\n          switch (this.lookahead.type) {\n            case 1\n            /* BooleanLiteral */\n            :\n            case 5\n            /* NullLiteral */\n            :\n            case 6\n            /* NumericLiteral */\n            :\n            case 8\n            /* StringLiteral */\n            :\n            case 10\n            /* Template */\n            :\n            case 9\n            /* RegularExpression */\n            :\n              statement = this.parseExpressionStatement();\n              break;\n\n            case 7\n            /* Punctuator */\n            :\n              var value = this.lookahead.value;\n\n              if (value === '{') {\n                statement = this.parseBlock();\n              } else if (value === '(') {\n                statement = this.parseExpressionStatement();\n              } else if (value === ';') {\n                statement = this.parseEmptyStatement();\n              } else {\n                statement = this.parseExpressionStatement();\n              }\n\n              break;\n\n            case 3\n            /* Identifier */\n            :\n              statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();\n              break;\n\n            case 4\n            /* Keyword */\n            :\n              switch (this.lookahead.value) {\n                case 'break':\n                  statement = this.parseBreakStatement();\n                  break;\n\n                case 'continue':\n                  statement = this.parseContinueStatement();\n                  break;\n\n                case 'debugger':\n                  statement = this.parseDebuggerStatement();\n                  break;\n\n                case 'do':\n                  statement = this.parseDoWhileStatement();\n                  break;\n\n                case 'for':\n                  statement = this.parseForStatement();\n                  break;\n\n                case 'function':\n                  statement = this.parseFunctionDeclaration();\n                  break;\n\n                case 'if':\n                  statement = this.parseIfStatement();\n                  break;\n\n                case 'return':\n                  statement = this.parseReturnStatement();\n                  break;\n\n                case 'switch':\n                  statement = this.parseSwitchStatement();\n                  break;\n\n                case 'throw':\n                  statement = this.parseThrowStatement();\n                  break;\n\n                case 'try':\n                  statement = this.parseTryStatement();\n                  break;\n\n                case 'var':\n                  statement = this.parseVariableStatement();\n                  break;\n\n                case 'while':\n                  statement = this.parseWhileStatement();\n                  break;\n\n                case 'with':\n                  statement = this.parseWithStatement();\n                  break;\n\n                default:\n                  statement = this.parseExpressionStatement();\n                  break;\n              }\n\n              break;\n\n            default:\n              statement = this.throwUnexpectedToken(this.lookahead);\n          }\n\n          return statement;\n        }; // https://tc39.github.io/ecma262/#sec-function-definitions\n\n\n        Parser.prototype.parseFunctionSourceElements = function () {\n          var node = this.createNode();\n          this.expect('{');\n          var body = this.parseDirectivePrologues();\n          var previousLabelSet = this.context.labelSet;\n          var previousInIteration = this.context.inIteration;\n          var previousInSwitch = this.context.inSwitch;\n          var previousInFunctionBody = this.context.inFunctionBody;\n          this.context.labelSet = {};\n          this.context.inIteration = false;\n          this.context.inSwitch = false;\n          this.context.inFunctionBody = true;\n\n          while (this.lookahead.type !== 2\n          /* EOF */\n          ) {\n            if (this.match('}')) {\n              break;\n            }\n\n            body.push(this.parseStatementListItem());\n          }\n\n          this.expect('}');\n          this.context.labelSet = previousLabelSet;\n          this.context.inIteration = previousInIteration;\n          this.context.inSwitch = previousInSwitch;\n          this.context.inFunctionBody = previousInFunctionBody;\n          return this.finalize(node, new Node.BlockStatement(body));\n        };\n\n        Parser.prototype.validateParam = function (options, param, name) {\n          var key = '$' + name;\n\n          if (this.context.strict) {\n            if (this.scanner.isRestrictedWord(name)) {\n              options.stricted = param;\n              options.message = messages_1.Messages.StrictParamName;\n            }\n\n            if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {\n              options.stricted = param;\n              options.message = messages_1.Messages.StrictParamDupe;\n            }\n          } else if (!options.firstRestricted) {\n            if (this.scanner.isRestrictedWord(name)) {\n              options.firstRestricted = param;\n              options.message = messages_1.Messages.StrictParamName;\n            } else if (this.scanner.isStrictModeReservedWord(name)) {\n              options.firstRestricted = param;\n              options.message = messages_1.Messages.StrictReservedWord;\n            } else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {\n              options.stricted = param;\n              options.message = messages_1.Messages.StrictParamDupe;\n            }\n          }\n          /* istanbul ignore next */\n\n\n          if (typeof Object.defineProperty === 'function') {\n            Object.defineProperty(options.paramSet, key, {\n              value: true,\n              enumerable: true,\n              writable: true,\n              configurable: true\n            });\n          } else {\n            options.paramSet[key] = true;\n          }\n        };\n\n        Parser.prototype.parseRestElement = function (params) {\n          var node = this.createNode();\n          this.expect('...');\n          var arg = this.parsePattern(params);\n\n          if (this.match('=')) {\n            this.throwError(messages_1.Messages.DefaultRestParameter);\n          }\n\n          if (!this.match(')')) {\n            this.throwError(messages_1.Messages.ParameterAfterRestParameter);\n          }\n\n          return this.finalize(node, new Node.RestElement(arg));\n        };\n\n        Parser.prototype.parseFormalParameter = function (options) {\n          var params = [];\n          var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);\n\n          for (var i = 0; i < params.length; i++) {\n            this.validateParam(options, params[i], params[i].value);\n          }\n\n          options.simple = options.simple && param instanceof Node.Identifier;\n          options.params.push(param);\n        };\n\n        Parser.prototype.parseFormalParameters = function (firstRestricted) {\n          var options;\n          options = {\n            simple: true,\n            params: [],\n            firstRestricted: firstRestricted\n          };\n          this.expect('(');\n\n          if (!this.match(')')) {\n            options.paramSet = {};\n\n            while (this.lookahead.type !== 2\n            /* EOF */\n            ) {\n              this.parseFormalParameter(options);\n\n              if (this.match(')')) {\n                break;\n              }\n\n              this.expect(',');\n\n              if (this.match(')')) {\n                break;\n              }\n            }\n          }\n\n          this.expect(')');\n          return {\n            simple: options.simple,\n            params: options.params,\n            stricted: options.stricted,\n            firstRestricted: options.firstRestricted,\n            message: options.message\n          };\n        };\n\n        Parser.prototype.matchAsyncFunction = function () {\n          var match = this.matchContextualKeyword('async');\n\n          if (match) {\n            var state = this.scanner.saveState();\n            this.scanner.scanComments();\n            var next = this.scanner.lex();\n            this.scanner.restoreState(state);\n            match = state.lineNumber === next.lineNumber && next.type === 4\n            /* Keyword */\n            && next.value === 'function';\n          }\n\n          return match;\n        };\n\n        Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {\n          var node = this.createNode();\n          var isAsync = this.matchContextualKeyword('async');\n\n          if (isAsync) {\n            this.nextToken();\n          }\n\n          this.expectKeyword('function');\n          var isGenerator = isAsync ? false : this.match('*');\n\n          if (isGenerator) {\n            this.nextToken();\n          }\n\n          var message;\n          var id = null;\n          var firstRestricted = null;\n\n          if (!identifierIsOptional || !this.match('(')) {\n            var token = this.lookahead;\n            id = this.parseVariableIdentifier();\n\n            if (this.context.strict) {\n              if (this.scanner.isRestrictedWord(token.value)) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);\n              }\n            } else {\n              if (this.scanner.isRestrictedWord(token.value)) {\n                firstRestricted = token;\n                message = messages_1.Messages.StrictFunctionName;\n              } else if (this.scanner.isStrictModeReservedWord(token.value)) {\n                firstRestricted = token;\n                message = messages_1.Messages.StrictReservedWord;\n              }\n            }\n          }\n\n          var previousAllowAwait = this.context[\"await\"];\n          var previousAllowYield = this.context.allowYield;\n          this.context[\"await\"] = isAsync;\n          this.context.allowYield = !isGenerator;\n          var formalParameters = this.parseFormalParameters(firstRestricted);\n          var params = formalParameters.params;\n          var stricted = formalParameters.stricted;\n          firstRestricted = formalParameters.firstRestricted;\n\n          if (formalParameters.message) {\n            message = formalParameters.message;\n          }\n\n          var previousStrict = this.context.strict;\n          var previousAllowStrictDirective = this.context.allowStrictDirective;\n          this.context.allowStrictDirective = formalParameters.simple;\n          var body = this.parseFunctionSourceElements();\n\n          if (this.context.strict && firstRestricted) {\n            this.throwUnexpectedToken(firstRestricted, message);\n          }\n\n          if (this.context.strict && stricted) {\n            this.tolerateUnexpectedToken(stricted, message);\n          }\n\n          this.context.strict = previousStrict;\n          this.context.allowStrictDirective = previousAllowStrictDirective;\n          this.context[\"await\"] = previousAllowAwait;\n          this.context.allowYield = previousAllowYield;\n          return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) : this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));\n        };\n\n        Parser.prototype.parseFunctionExpression = function () {\n          var node = this.createNode();\n          var isAsync = this.matchContextualKeyword('async');\n\n          if (isAsync) {\n            this.nextToken();\n          }\n\n          this.expectKeyword('function');\n          var isGenerator = isAsync ? false : this.match('*');\n\n          if (isGenerator) {\n            this.nextToken();\n          }\n\n          var message;\n          var id = null;\n          var firstRestricted;\n          var previousAllowAwait = this.context[\"await\"];\n          var previousAllowYield = this.context.allowYield;\n          this.context[\"await\"] = isAsync;\n          this.context.allowYield = !isGenerator;\n\n          if (!this.match('(')) {\n            var token = this.lookahead;\n            id = !this.context.strict && !isGenerator && this.matchKeyword('yield') ? this.parseIdentifierName() : this.parseVariableIdentifier();\n\n            if (this.context.strict) {\n              if (this.scanner.isRestrictedWord(token.value)) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);\n              }\n            } else {\n              if (this.scanner.isRestrictedWord(token.value)) {\n                firstRestricted = token;\n                message = messages_1.Messages.StrictFunctionName;\n              } else if (this.scanner.isStrictModeReservedWord(token.value)) {\n                firstRestricted = token;\n                message = messages_1.Messages.StrictReservedWord;\n              }\n            }\n          }\n\n          var formalParameters = this.parseFormalParameters(firstRestricted);\n          var params = formalParameters.params;\n          var stricted = formalParameters.stricted;\n          firstRestricted = formalParameters.firstRestricted;\n\n          if (formalParameters.message) {\n            message = formalParameters.message;\n          }\n\n          var previousStrict = this.context.strict;\n          var previousAllowStrictDirective = this.context.allowStrictDirective;\n          this.context.allowStrictDirective = formalParameters.simple;\n          var body = this.parseFunctionSourceElements();\n\n          if (this.context.strict && firstRestricted) {\n            this.throwUnexpectedToken(firstRestricted, message);\n          }\n\n          if (this.context.strict && stricted) {\n            this.tolerateUnexpectedToken(stricted, message);\n          }\n\n          this.context.strict = previousStrict;\n          this.context.allowStrictDirective = previousAllowStrictDirective;\n          this.context[\"await\"] = previousAllowAwait;\n          this.context.allowYield = previousAllowYield;\n          return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) : this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));\n        }; // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive\n\n\n        Parser.prototype.parseDirective = function () {\n          var token = this.lookahead;\n          var node = this.createNode();\n          var expr = this.parseExpression();\n          var directive = expr.type === syntax_1.Syntax.Literal ? this.getTokenRaw(token).slice(1, -1) : null;\n          this.consumeSemicolon();\n          return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));\n        };\n\n        Parser.prototype.parseDirectivePrologues = function () {\n          var firstRestricted = null;\n          var body = [];\n\n          while (true) {\n            var token = this.lookahead;\n\n            if (token.type !== 8\n            /* StringLiteral */\n            ) {\n                break;\n              }\n\n            var statement = this.parseDirective();\n            body.push(statement);\n            var directive = statement.directive;\n\n            if (typeof directive !== 'string') {\n              break;\n            }\n\n            if (directive === 'use strict') {\n              this.context.strict = true;\n\n              if (firstRestricted) {\n                this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);\n              }\n\n              if (!this.context.allowStrictDirective) {\n                this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);\n              }\n            } else {\n              if (!firstRestricted && token.octal) {\n                firstRestricted = token;\n              }\n            }\n          }\n\n          return body;\n        }; // https://tc39.github.io/ecma262/#sec-method-definitions\n\n\n        Parser.prototype.qualifiedPropertyName = function (token) {\n          switch (token.type) {\n            case 3\n            /* Identifier */\n            :\n            case 8\n            /* StringLiteral */\n            :\n            case 1\n            /* BooleanLiteral */\n            :\n            case 5\n            /* NullLiteral */\n            :\n            case 6\n            /* NumericLiteral */\n            :\n            case 4\n            /* Keyword */\n            :\n              return true;\n\n            case 7\n            /* Punctuator */\n            :\n              return token.value === '[';\n\n            default:\n              break;\n          }\n\n          return false;\n        };\n\n        Parser.prototype.parseGetterMethod = function () {\n          var node = this.createNode();\n          var isGenerator = false;\n          var previousAllowYield = this.context.allowYield;\n          this.context.allowYield = !isGenerator;\n          var formalParameters = this.parseFormalParameters();\n\n          if (formalParameters.params.length > 0) {\n            this.tolerateError(messages_1.Messages.BadGetterArity);\n          }\n\n          var method = this.parsePropertyMethod(formalParameters);\n          this.context.allowYield = previousAllowYield;\n          return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));\n        };\n\n        Parser.prototype.parseSetterMethod = function () {\n          var node = this.createNode();\n          var isGenerator = false;\n          var previousAllowYield = this.context.allowYield;\n          this.context.allowYield = !isGenerator;\n          var formalParameters = this.parseFormalParameters();\n\n          if (formalParameters.params.length !== 1) {\n            this.tolerateError(messages_1.Messages.BadSetterArity);\n          } else if (formalParameters.params[0] instanceof Node.RestElement) {\n            this.tolerateError(messages_1.Messages.BadSetterRestParameter);\n          }\n\n          var method = this.parsePropertyMethod(formalParameters);\n          this.context.allowYield = previousAllowYield;\n          return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));\n        };\n\n        Parser.prototype.parseGeneratorMethod = function () {\n          var node = this.createNode();\n          var isGenerator = true;\n          var previousAllowYield = this.context.allowYield;\n          this.context.allowYield = true;\n          var params = this.parseFormalParameters();\n          this.context.allowYield = false;\n          var method = this.parsePropertyMethod(params);\n          this.context.allowYield = previousAllowYield;\n          return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));\n        }; // https://tc39.github.io/ecma262/#sec-generator-function-definitions\n\n\n        Parser.prototype.isStartOfExpression = function () {\n          var start = true;\n          var value = this.lookahead.value;\n\n          switch (this.lookahead.type) {\n            case 7\n            /* Punctuator */\n            :\n              start = value === '[' || value === '(' || value === '{' || value === '+' || value === '-' || value === '!' || value === '~' || value === '++' || value === '--' || value === '/' || value === '/='; // regular expression literal\n\n              break;\n\n            case 4\n            /* Keyword */\n            :\n              start = value === 'class' || value === 'delete' || value === 'function' || value === 'let' || value === 'new' || value === 'super' || value === 'this' || value === 'typeof' || value === 'void' || value === 'yield';\n              break;\n\n            default:\n              break;\n          }\n\n          return start;\n        };\n\n        Parser.prototype.parseYieldExpression = function () {\n          var node = this.createNode();\n          this.expectKeyword('yield');\n          var argument = null;\n          var delegate = false;\n\n          if (!this.hasLineTerminator) {\n            var previousAllowYield = this.context.allowYield;\n            this.context.allowYield = false;\n            delegate = this.match('*');\n\n            if (delegate) {\n              this.nextToken();\n              argument = this.parseAssignmentExpression();\n            } else if (this.isStartOfExpression()) {\n              argument = this.parseAssignmentExpression();\n            }\n\n            this.context.allowYield = previousAllowYield;\n          }\n\n          return this.finalize(node, new Node.YieldExpression(argument, delegate));\n        }; // https://tc39.github.io/ecma262/#sec-class-definitions\n\n\n        Parser.prototype.parseClassElement = function (hasConstructor) {\n          var token = this.lookahead;\n          var node = this.createNode();\n          var kind = '';\n          var key = null;\n          var value = null;\n          var computed = false;\n          var method = false;\n          var isStatic = false;\n          var isAsync = false;\n\n          if (this.match('*')) {\n            this.nextToken();\n          } else {\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            var id = key;\n\n            if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {\n              token = this.lookahead;\n              isStatic = true;\n              computed = this.match('[');\n\n              if (this.match('*')) {\n                this.nextToken();\n              } else {\n                key = this.parseObjectPropertyKey();\n              }\n            }\n\n            if (token.type === 3\n            /* Identifier */\n            && !this.hasLineTerminator && token.value === 'async') {\n              var punctuator = this.lookahead.value;\n\n              if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {\n                isAsync = true;\n                token = this.lookahead;\n                key = this.parseObjectPropertyKey();\n\n                if (token.type === 3\n                /* Identifier */\n                && token.value === 'constructor') {\n                  this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);\n                }\n              }\n            }\n          }\n\n          var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);\n\n          if (token.type === 3\n          /* Identifier */\n          ) {\n              if (token.value === 'get' && lookaheadPropertyKey) {\n                kind = 'get';\n                computed = this.match('[');\n                key = this.parseObjectPropertyKey();\n                this.context.allowYield = false;\n                value = this.parseGetterMethod();\n              } else if (token.value === 'set' && lookaheadPropertyKey) {\n                kind = 'set';\n                computed = this.match('[');\n                key = this.parseObjectPropertyKey();\n                value = this.parseSetterMethod();\n              }\n            } else if (token.type === 7\n          /* Punctuator */\n          && token.value === '*' && lookaheadPropertyKey) {\n            kind = 'init';\n            computed = this.match('[');\n            key = this.parseObjectPropertyKey();\n            value = this.parseGeneratorMethod();\n            method = true;\n          }\n\n          if (!kind && key && this.match('(')) {\n            kind = 'init';\n            value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();\n            method = true;\n          }\n\n          if (!kind) {\n            this.throwUnexpectedToken(this.lookahead);\n          }\n\n          if (kind === 'init') {\n            kind = 'method';\n          }\n\n          if (!computed) {\n            if (isStatic && this.isPropertyKey(key, 'prototype')) {\n              this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);\n            }\n\n            if (!isStatic && this.isPropertyKey(key, 'constructor')) {\n              if (kind !== 'method' || !method || value && value.generator) {\n                this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);\n              }\n\n              if (hasConstructor.value) {\n                this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);\n              } else {\n                hasConstructor.value = true;\n              }\n\n              kind = 'constructor';\n            }\n          }\n\n          return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));\n        };\n\n        Parser.prototype.parseClassElementList = function () {\n          var body = [];\n          var hasConstructor = {\n            value: false\n          };\n          this.expect('{');\n\n          while (!this.match('}')) {\n            if (this.match(';')) {\n              this.nextToken();\n            } else {\n              body.push(this.parseClassElement(hasConstructor));\n            }\n          }\n\n          this.expect('}');\n          return body;\n        };\n\n        Parser.prototype.parseClassBody = function () {\n          var node = this.createNode();\n          var elementList = this.parseClassElementList();\n          return this.finalize(node, new Node.ClassBody(elementList));\n        };\n\n        Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {\n          var node = this.createNode();\n          var previousStrict = this.context.strict;\n          this.context.strict = true;\n          this.expectKeyword('class');\n          var id = identifierIsOptional && this.lookahead.type !== 3\n          /* Identifier */\n          ? null : this.parseVariableIdentifier();\n          var superClass = null;\n\n          if (this.matchKeyword('extends')) {\n            this.nextToken();\n            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);\n          }\n\n          var classBody = this.parseClassBody();\n          this.context.strict = previousStrict;\n          return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));\n        };\n\n        Parser.prototype.parseClassExpression = function () {\n          var node = this.createNode();\n          var previousStrict = this.context.strict;\n          this.context.strict = true;\n          this.expectKeyword('class');\n          var id = this.lookahead.type === 3\n          /* Identifier */\n          ? this.parseVariableIdentifier() : null;\n          var superClass = null;\n\n          if (this.matchKeyword('extends')) {\n            this.nextToken();\n            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);\n          }\n\n          var classBody = this.parseClassBody();\n          this.context.strict = previousStrict;\n          return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));\n        }; // https://tc39.github.io/ecma262/#sec-scripts\n        // https://tc39.github.io/ecma262/#sec-modules\n\n\n        Parser.prototype.parseModule = function () {\n          this.context.strict = true;\n          this.context.isModule = true;\n          this.scanner.isModule = true;\n          var node = this.createNode();\n          var body = this.parseDirectivePrologues();\n\n          while (this.lookahead.type !== 2\n          /* EOF */\n          ) {\n            body.push(this.parseStatementListItem());\n          }\n\n          return this.finalize(node, new Node.Module(body));\n        };\n\n        Parser.prototype.parseScript = function () {\n          var node = this.createNode();\n          var body = this.parseDirectivePrologues();\n\n          while (this.lookahead.type !== 2\n          /* EOF */\n          ) {\n            body.push(this.parseStatementListItem());\n          }\n\n          return this.finalize(node, new Node.Script(body));\n        }; // https://tc39.github.io/ecma262/#sec-imports\n\n\n        Parser.prototype.parseModuleSpecifier = function () {\n          var node = this.createNode();\n\n          if (this.lookahead.type !== 8\n          /* StringLiteral */\n          ) {\n              this.throwError(messages_1.Messages.InvalidModuleSpecifier);\n            }\n\n          var token = this.nextToken();\n          var raw = this.getTokenRaw(token);\n          return this.finalize(node, new Node.Literal(token.value, raw));\n        }; // import {<foo as bar>} ...;\n\n\n        Parser.prototype.parseImportSpecifier = function () {\n          var node = this.createNode();\n          var imported;\n          var local;\n\n          if (this.lookahead.type === 3\n          /* Identifier */\n          ) {\n              imported = this.parseVariableIdentifier();\n              local = imported;\n\n              if (this.matchContextualKeyword('as')) {\n                this.nextToken();\n                local = this.parseVariableIdentifier();\n              }\n            } else {\n            imported = this.parseIdentifierName();\n            local = imported;\n\n            if (this.matchContextualKeyword('as')) {\n              this.nextToken();\n              local = this.parseVariableIdentifier();\n            } else {\n              this.throwUnexpectedToken(this.nextToken());\n            }\n          }\n\n          return this.finalize(node, new Node.ImportSpecifier(local, imported));\n        }; // {foo, bar as bas}\n\n\n        Parser.prototype.parseNamedImports = function () {\n          this.expect('{');\n          var specifiers = [];\n\n          while (!this.match('}')) {\n            specifiers.push(this.parseImportSpecifier());\n\n            if (!this.match('}')) {\n              this.expect(',');\n            }\n          }\n\n          this.expect('}');\n          return specifiers;\n        }; // import <foo> ...;\n\n\n        Parser.prototype.parseImportDefaultSpecifier = function () {\n          var node = this.createNode();\n          var local = this.parseIdentifierName();\n          return this.finalize(node, new Node.ImportDefaultSpecifier(local));\n        }; // import <* as foo> ...;\n\n\n        Parser.prototype.parseImportNamespaceSpecifier = function () {\n          var node = this.createNode();\n          this.expect('*');\n\n          if (!this.matchContextualKeyword('as')) {\n            this.throwError(messages_1.Messages.NoAsAfterImportNamespace);\n          }\n\n          this.nextToken();\n          var local = this.parseIdentifierName();\n          return this.finalize(node, new Node.ImportNamespaceSpecifier(local));\n        };\n\n        Parser.prototype.parseImportDeclaration = function () {\n          if (this.context.inFunctionBody) {\n            this.throwError(messages_1.Messages.IllegalImportDeclaration);\n          }\n\n          var node = this.createNode();\n          this.expectKeyword('import');\n          var src;\n          var specifiers = [];\n\n          if (this.lookahead.type === 8\n          /* StringLiteral */\n          ) {\n              // import 'foo';\n              src = this.parseModuleSpecifier();\n            } else {\n            if (this.match('{')) {\n              // import {bar}\n              specifiers = specifiers.concat(this.parseNamedImports());\n            } else if (this.match('*')) {\n              // import * as foo\n              specifiers.push(this.parseImportNamespaceSpecifier());\n            } else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {\n              // import foo\n              specifiers.push(this.parseImportDefaultSpecifier());\n\n              if (this.match(',')) {\n                this.nextToken();\n\n                if (this.match('*')) {\n                  // import foo, * as foo\n                  specifiers.push(this.parseImportNamespaceSpecifier());\n                } else if (this.match('{')) {\n                  // import foo, {bar}\n                  specifiers = specifiers.concat(this.parseNamedImports());\n                } else {\n                  this.throwUnexpectedToken(this.lookahead);\n                }\n              }\n            } else {\n              this.throwUnexpectedToken(this.nextToken());\n            }\n\n            if (!this.matchContextualKeyword('from')) {\n              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;\n              this.throwError(message, this.lookahead.value);\n            }\n\n            this.nextToken();\n            src = this.parseModuleSpecifier();\n          }\n\n          this.consumeSemicolon();\n          return this.finalize(node, new Node.ImportDeclaration(specifiers, src));\n        }; // https://tc39.github.io/ecma262/#sec-exports\n\n\n        Parser.prototype.parseExportSpecifier = function () {\n          var node = this.createNode();\n          var local = this.parseIdentifierName();\n          var exported = local;\n\n          if (this.matchContextualKeyword('as')) {\n            this.nextToken();\n            exported = this.parseIdentifierName();\n          }\n\n          return this.finalize(node, new Node.ExportSpecifier(local, exported));\n        };\n\n        Parser.prototype.parseExportDeclaration = function () {\n          if (this.context.inFunctionBody) {\n            this.throwError(messages_1.Messages.IllegalExportDeclaration);\n          }\n\n          var node = this.createNode();\n          this.expectKeyword('export');\n          var exportDeclaration;\n\n          if (this.matchKeyword('default')) {\n            // export default ...\n            this.nextToken();\n\n            if (this.matchKeyword('function')) {\n              // export default function foo () {}\n              // export default function () {}\n              var declaration = this.parseFunctionDeclaration(true);\n              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));\n            } else if (this.matchKeyword('class')) {\n              // export default class foo {}\n              var declaration = this.parseClassDeclaration(true);\n              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));\n            } else if (this.matchContextualKeyword('async')) {\n              // export default async function f () {}\n              // export default async function () {}\n              // export default async x => x\n              var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();\n              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));\n            } else {\n              if (this.matchContextualKeyword('from')) {\n                this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);\n              } // export default {};\n              // export default [];\n              // export default (1 + 2);\n\n\n              var declaration = this.match('{') ? this.parseObjectInitializer() : this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();\n              this.consumeSemicolon();\n              exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));\n            }\n          } else if (this.match('*')) {\n            // export * from 'foo';\n            this.nextToken();\n\n            if (!this.matchContextualKeyword('from')) {\n              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;\n              this.throwError(message, this.lookahead.value);\n            }\n\n            this.nextToken();\n            var src = this.parseModuleSpecifier();\n            this.consumeSemicolon();\n            exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));\n          } else if (this.lookahead.type === 4\n          /* Keyword */\n          ) {\n              // export var f = 1;\n              var declaration = void 0;\n\n              switch (this.lookahead.value) {\n                case 'let':\n                case 'const':\n                  declaration = this.parseLexicalDeclaration({\n                    inFor: false\n                  });\n                  break;\n\n                case 'var':\n                case 'class':\n                case 'function':\n                  declaration = this.parseStatementListItem();\n                  break;\n\n                default:\n                  this.throwUnexpectedToken(this.lookahead);\n              }\n\n              exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));\n            } else if (this.matchAsyncFunction()) {\n            var declaration = this.parseFunctionDeclaration();\n            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));\n          } else {\n            var specifiers = [];\n            var source = null;\n            var isExportFromIdentifier = false;\n            this.expect('{');\n\n            while (!this.match('}')) {\n              isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');\n              specifiers.push(this.parseExportSpecifier());\n\n              if (!this.match('}')) {\n                this.expect(',');\n              }\n            }\n\n            this.expect('}');\n\n            if (this.matchContextualKeyword('from')) {\n              // export {default} from 'foo';\n              // export {foo} from 'foo';\n              this.nextToken();\n              source = this.parseModuleSpecifier();\n              this.consumeSemicolon();\n            } else if (isExportFromIdentifier) {\n              // export {default}; // missing fromClause\n              var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;\n              this.throwError(message, this.lookahead.value);\n            } else {\n              // export {foo};\n              this.consumeSemicolon();\n            }\n\n            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));\n          }\n\n          return exportDeclaration;\n        };\n\n        return Parser;\n      }();\n\n      exports.Parser = Parser;\n      /***/\n    },\n    /* 9 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\"; // Ensure the condition is true, otherwise throw an error.\n      // This is only to have a better contract semantic, i.e. another safety net\n      // to catch a logic error. The condition shall be fulfilled in normal case.\n      // Do NOT use this to enforce a certain condition on any user input.\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      function assert(condition, message) {\n        /* istanbul ignore if */\n        if (!condition) {\n          throw new Error('ASSERT: ' + message);\n        }\n      }\n\n      exports.assert = assert;\n      /***/\n    },\n    /* 10 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n      /* tslint:disable:max-classes-per-file */\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var ErrorHandler = function () {\n        function ErrorHandler() {\n          this.errors = [];\n          this.tolerant = false;\n        }\n\n        ErrorHandler.prototype.recordError = function (error) {\n          this.errors.push(error);\n        };\n\n        ErrorHandler.prototype.tolerate = function (error) {\n          if (this.tolerant) {\n            this.recordError(error);\n          } else {\n            throw error;\n          }\n        };\n\n        ErrorHandler.prototype.constructError = function (msg, column) {\n          var error = new Error(msg);\n\n          try {\n            throw error;\n          } catch (base) {\n            /* istanbul ignore else */\n            if (Object.create && Object.defineProperty) {\n              error = Object.create(base);\n              Object.defineProperty(error, 'column', {\n                value: column\n              });\n            }\n          }\n          /* istanbul ignore next */\n\n\n          return error;\n        };\n\n        ErrorHandler.prototype.createError = function (index, line, col, description) {\n          var msg = 'Line ' + line + ': ' + description;\n          var error = this.constructError(msg, col);\n          error.index = index;\n          error.lineNumber = line;\n          error.description = description;\n          return error;\n        };\n\n        ErrorHandler.prototype.throwError = function (index, line, col, description) {\n          throw this.createError(index, line, col, description);\n        };\n\n        ErrorHandler.prototype.tolerateError = function (index, line, col, description) {\n          var error = this.createError(index, line, col, description);\n\n          if (this.tolerant) {\n            this.recordError(error);\n          } else {\n            throw error;\n          }\n        };\n\n        return ErrorHandler;\n      }();\n\n      exports.ErrorHandler = ErrorHandler;\n      /***/\n    },\n    /* 11 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      }); // Error messages should be identical to V8.\n\n      exports.Messages = {\n        BadGetterArity: 'Getter must not have any formal parameters',\n        BadSetterArity: 'Setter must have exactly one formal parameter',\n        BadSetterRestParameter: 'Setter function argument must not be a rest parameter',\n        ConstructorIsAsync: 'Class constructor may not be an async method',\n        ConstructorSpecialMethod: 'Class constructor may not be an accessor',\n        DeclarationMissingInitializer: 'Missing initializer in %0 declaration',\n        DefaultRestParameter: 'Unexpected token =',\n        DuplicateBinding: 'Duplicate binding %0',\n        DuplicateConstructor: 'A class may only have one constructor',\n        DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',\n        ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',\n        GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',\n        IllegalBreak: 'Illegal break statement',\n        IllegalContinue: 'Illegal continue statement',\n        IllegalExportDeclaration: 'Unexpected token',\n        IllegalImportDeclaration: 'Unexpected token',\n        IllegalLanguageModeDirective: 'Illegal \\'use strict\\' directive in function with non-simple parameter list',\n        IllegalReturn: 'Illegal return statement',\n        InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',\n        InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',\n        InvalidLHSInAssignment: 'Invalid left-hand side in assignment',\n        InvalidLHSInForIn: 'Invalid left-hand side in for-in',\n        InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',\n        InvalidModuleSpecifier: 'Unexpected token',\n        InvalidRegExp: 'Invalid regular expression',\n        LetInLexicalBinding: 'let is disallowed as a lexically bound name',\n        MissingFromClause: 'Unexpected token',\n        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',\n        NewlineAfterThrow: 'Illegal newline after throw',\n        NoAsAfterImportNamespace: 'Unexpected token',\n        NoCatchOrFinally: 'Missing catch or finally after try',\n        ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',\n        Redeclaration: '%0 \\'%1\\' has already been declared',\n        StaticPrototype: 'Classes may not have static property named prototype',\n        StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',\n        StrictDelete: 'Delete of an unqualified identifier in strict mode.',\n        StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',\n        StrictFunctionName: 'Function name may not be eval or arguments in strict mode',\n        StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',\n        StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictModeWith: 'Strict mode code may not include a with statement',\n        StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',\n        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',\n        StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',\n        StrictReservedWord: 'Use of future reserved word in strict mode',\n        StrictVarName: 'Variable name may not be eval or arguments in strict mode',\n        TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',\n        UnexpectedEOS: 'Unexpected end of input',\n        UnexpectedIdentifier: 'Unexpected identifier',\n        UnexpectedNumber: 'Unexpected number',\n        UnexpectedReserved: 'Unexpected reserved word',\n        UnexpectedString: 'Unexpected string',\n        UnexpectedTemplate: 'Unexpected quasi %0',\n        UnexpectedToken: 'Unexpected token %0',\n        UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',\n        UnknownLabel: 'Undefined label \\'%0\\'',\n        UnterminatedRegExp: 'Invalid regular expression: missing /'\n      };\n      /***/\n    },\n    /* 12 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var assert_1 = __webpack_require__(9);\n\n      var character_1 = __webpack_require__(4);\n\n      var messages_1 = __webpack_require__(11);\n\n      function hexValue(ch) {\n        return '0123456789abcdef'.indexOf(ch.toLowerCase());\n      }\n\n      function octalValue(ch) {\n        return '01234567'.indexOf(ch);\n      }\n\n      var Scanner = function () {\n        function Scanner(code, handler) {\n          this.source = code;\n          this.errorHandler = handler;\n          this.trackComment = false;\n          this.isModule = false;\n          this.length = code.length;\n          this.index = 0;\n          this.lineNumber = code.length > 0 ? 1 : 0;\n          this.lineStart = 0;\n          this.curlyStack = [];\n        }\n\n        Scanner.prototype.saveState = function () {\n          return {\n            index: this.index,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart\n          };\n        };\n\n        Scanner.prototype.restoreState = function (state) {\n          this.index = state.index;\n          this.lineNumber = state.lineNumber;\n          this.lineStart = state.lineStart;\n        };\n\n        Scanner.prototype.eof = function () {\n          return this.index >= this.length;\n        };\n\n        Scanner.prototype.throwUnexpectedToken = function (message) {\n          if (message === void 0) {\n            message = messages_1.Messages.UnexpectedTokenIllegal;\n          }\n\n          return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);\n        };\n\n        Scanner.prototype.tolerateUnexpectedToken = function (message) {\n          if (message === void 0) {\n            message = messages_1.Messages.UnexpectedTokenIllegal;\n          }\n\n          this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);\n        }; // https://tc39.github.io/ecma262/#sec-comments\n\n\n        Scanner.prototype.skipSingleLineComment = function (offset) {\n          var comments = [];\n          var start, loc;\n\n          if (this.trackComment) {\n            comments = [];\n            start = this.index - offset;\n            loc = {\n              start: {\n                line: this.lineNumber,\n                column: this.index - this.lineStart - offset\n              },\n              end: {}\n            };\n          }\n\n          while (!this.eof()) {\n            var ch = this.source.charCodeAt(this.index);\n            ++this.index;\n\n            if (character_1.Character.isLineTerminator(ch)) {\n              if (this.trackComment) {\n                loc.end = {\n                  line: this.lineNumber,\n                  column: this.index - this.lineStart - 1\n                };\n                var entry = {\n                  multiLine: false,\n                  slice: [start + offset, this.index - 1],\n                  range: [start, this.index - 1],\n                  loc: loc\n                };\n                comments.push(entry);\n              }\n\n              if (ch === 13 && this.source.charCodeAt(this.index) === 10) {\n                ++this.index;\n              }\n\n              ++this.lineNumber;\n              this.lineStart = this.index;\n              return comments;\n            }\n          }\n\n          if (this.trackComment) {\n            loc.end = {\n              line: this.lineNumber,\n              column: this.index - this.lineStart\n            };\n            var entry = {\n              multiLine: false,\n              slice: [start + offset, this.index],\n              range: [start, this.index],\n              loc: loc\n            };\n            comments.push(entry);\n          }\n\n          return comments;\n        };\n\n        Scanner.prototype.skipMultiLineComment = function () {\n          var comments = [];\n          var start, loc;\n\n          if (this.trackComment) {\n            comments = [];\n            start = this.index - 2;\n            loc = {\n              start: {\n                line: this.lineNumber,\n                column: this.index - this.lineStart - 2\n              },\n              end: {}\n            };\n          }\n\n          while (!this.eof()) {\n            var ch = this.source.charCodeAt(this.index);\n\n            if (character_1.Character.isLineTerminator(ch)) {\n              if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {\n                ++this.index;\n              }\n\n              ++this.lineNumber;\n              ++this.index;\n              this.lineStart = this.index;\n            } else if (ch === 0x2A) {\n              // Block comment ends with '*/'.\n              if (this.source.charCodeAt(this.index + 1) === 0x2F) {\n                this.index += 2;\n\n                if (this.trackComment) {\n                  loc.end = {\n                    line: this.lineNumber,\n                    column: this.index - this.lineStart\n                  };\n                  var entry = {\n                    multiLine: true,\n                    slice: [start + 2, this.index - 2],\n                    range: [start, this.index],\n                    loc: loc\n                  };\n                  comments.push(entry);\n                }\n\n                return comments;\n              }\n\n              ++this.index;\n            } else {\n              ++this.index;\n            }\n          } // Ran off the end of the file - the whole thing is a comment\n\n\n          if (this.trackComment) {\n            loc.end = {\n              line: this.lineNumber,\n              column: this.index - this.lineStart\n            };\n            var entry = {\n              multiLine: true,\n              slice: [start + 2, this.index],\n              range: [start, this.index],\n              loc: loc\n            };\n            comments.push(entry);\n          }\n\n          this.tolerateUnexpectedToken();\n          return comments;\n        };\n\n        Scanner.prototype.scanComments = function () {\n          var comments;\n\n          if (this.trackComment) {\n            comments = [];\n          }\n\n          var start = this.index === 0;\n\n          while (!this.eof()) {\n            var ch = this.source.charCodeAt(this.index);\n\n            if (character_1.Character.isWhiteSpace(ch)) {\n              ++this.index;\n            } else if (character_1.Character.isLineTerminator(ch)) {\n              ++this.index;\n\n              if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {\n                ++this.index;\n              }\n\n              ++this.lineNumber;\n              this.lineStart = this.index;\n              start = true;\n            } else if (ch === 0x2F) {\n              ch = this.source.charCodeAt(this.index + 1);\n\n              if (ch === 0x2F) {\n                this.index += 2;\n                var comment = this.skipSingleLineComment(2);\n\n                if (this.trackComment) {\n                  comments = comments.concat(comment);\n                }\n\n                start = true;\n              } else if (ch === 0x2A) {\n                this.index += 2;\n                var comment = this.skipMultiLineComment();\n\n                if (this.trackComment) {\n                  comments = comments.concat(comment);\n                }\n              } else {\n                break;\n              }\n            } else if (start && ch === 0x2D) {\n              // U+003E is '>'\n              if (this.source.charCodeAt(this.index + 1) === 0x2D && this.source.charCodeAt(this.index + 2) === 0x3E) {\n                // '-->' is a single-line comment\n                this.index += 3;\n                var comment = this.skipSingleLineComment(3);\n\n                if (this.trackComment) {\n                  comments = comments.concat(comment);\n                }\n              } else {\n                break;\n              }\n            } else if (ch === 0x3C && !this.isModule) {\n              if (this.source.slice(this.index + 1, this.index + 4) === '!--') {\n                this.index += 4; // `<!--`\n\n                var comment = this.skipSingleLineComment(4);\n\n                if (this.trackComment) {\n                  comments = comments.concat(comment);\n                }\n              } else {\n                break;\n              }\n            } else {\n              break;\n            }\n          }\n\n          return comments;\n        }; // https://tc39.github.io/ecma262/#sec-future-reserved-words\n\n\n        Scanner.prototype.isFutureReservedWord = function (id) {\n          switch (id) {\n            case 'enum':\n            case 'export':\n            case 'import':\n            case 'super':\n              return true;\n\n            default:\n              return false;\n          }\n        };\n\n        Scanner.prototype.isStrictModeReservedWord = function (id) {\n          switch (id) {\n            case 'implements':\n            case 'interface':\n            case 'package':\n            case 'private':\n            case 'protected':\n            case 'public':\n            case 'static':\n            case 'yield':\n            case 'let':\n              return true;\n\n            default:\n              return false;\n          }\n        };\n\n        Scanner.prototype.isRestrictedWord = function (id) {\n          return id === 'eval' || id === 'arguments';\n        }; // https://tc39.github.io/ecma262/#sec-keywords\n\n\n        Scanner.prototype.isKeyword = function (id) {\n          switch (id.length) {\n            case 2:\n              return id === 'if' || id === 'in' || id === 'do';\n\n            case 3:\n              return id === 'var' || id === 'for' || id === 'new' || id === 'try' || id === 'let';\n\n            case 4:\n              return id === 'this' || id === 'else' || id === 'case' || id === 'void' || id === 'with' || id === 'enum';\n\n            case 5:\n              return id === 'while' || id === 'break' || id === 'catch' || id === 'throw' || id === 'const' || id === 'yield' || id === 'class' || id === 'super';\n\n            case 6:\n              return id === 'return' || id === 'typeof' || id === 'delete' || id === 'switch' || id === 'export' || id === 'import';\n\n            case 7:\n              return id === 'default' || id === 'finally' || id === 'extends';\n\n            case 8:\n              return id === 'function' || id === 'continue' || id === 'debugger';\n\n            case 10:\n              return id === 'instanceof';\n\n            default:\n              return false;\n          }\n        };\n\n        Scanner.prototype.codePointAt = function (i) {\n          var cp = this.source.charCodeAt(i);\n\n          if (cp >= 0xD800 && cp <= 0xDBFF) {\n            var second = this.source.charCodeAt(i + 1);\n\n            if (second >= 0xDC00 && second <= 0xDFFF) {\n              var first = cp;\n              cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;\n            }\n          }\n\n          return cp;\n        };\n\n        Scanner.prototype.scanHexEscape = function (prefix) {\n          var len = prefix === 'u' ? 4 : 2;\n          var code = 0;\n\n          for (var i = 0; i < len; ++i) {\n            if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {\n              code = code * 16 + hexValue(this.source[this.index++]);\n            } else {\n              return null;\n            }\n          }\n\n          return String.fromCharCode(code);\n        };\n\n        Scanner.prototype.scanUnicodeCodePointEscape = function () {\n          var ch = this.source[this.index];\n          var code = 0; // At least, one hex digit is required.\n\n          if (ch === '}') {\n            this.throwUnexpectedToken();\n          }\n\n          while (!this.eof()) {\n            ch = this.source[this.index++];\n\n            if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {\n              break;\n            }\n\n            code = code * 16 + hexValue(ch);\n          }\n\n          if (code > 0x10FFFF || ch !== '}') {\n            this.throwUnexpectedToken();\n          }\n\n          return character_1.Character.fromCodePoint(code);\n        };\n\n        Scanner.prototype.getIdentifier = function () {\n          var start = this.index++;\n\n          while (!this.eof()) {\n            var ch = this.source.charCodeAt(this.index);\n\n            if (ch === 0x5C) {\n              // Blackslash (U+005C) marks Unicode escape sequence.\n              this.index = start;\n              return this.getComplexIdentifier();\n            } else if (ch >= 0xD800 && ch < 0xDFFF) {\n              // Need to handle surrogate pairs.\n              this.index = start;\n              return this.getComplexIdentifier();\n            }\n\n            if (character_1.Character.isIdentifierPart(ch)) {\n              ++this.index;\n            } else {\n              break;\n            }\n          }\n\n          return this.source.slice(start, this.index);\n        };\n\n        Scanner.prototype.getComplexIdentifier = function () {\n          var cp = this.codePointAt(this.index);\n          var id = character_1.Character.fromCodePoint(cp);\n          this.index += id.length; // '\\u' (U+005C, U+0075) denotes an escaped character.\n\n          var ch;\n\n          if (cp === 0x5C) {\n            if (this.source.charCodeAt(this.index) !== 0x75) {\n              this.throwUnexpectedToken();\n            }\n\n            ++this.index;\n\n            if (this.source[this.index] === '{') {\n              ++this.index;\n              ch = this.scanUnicodeCodePointEscape();\n            } else {\n              ch = this.scanHexEscape('u');\n\n              if (ch === null || ch === '\\\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {\n                this.throwUnexpectedToken();\n              }\n            }\n\n            id = ch;\n          }\n\n          while (!this.eof()) {\n            cp = this.codePointAt(this.index);\n\n            if (!character_1.Character.isIdentifierPart(cp)) {\n              break;\n            }\n\n            ch = character_1.Character.fromCodePoint(cp);\n            id += ch;\n            this.index += ch.length; // '\\u' (U+005C, U+0075) denotes an escaped character.\n\n            if (cp === 0x5C) {\n              id = id.substr(0, id.length - 1);\n\n              if (this.source.charCodeAt(this.index) !== 0x75) {\n                this.throwUnexpectedToken();\n              }\n\n              ++this.index;\n\n              if (this.source[this.index] === '{') {\n                ++this.index;\n                ch = this.scanUnicodeCodePointEscape();\n              } else {\n                ch = this.scanHexEscape('u');\n\n                if (ch === null || ch === '\\\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {\n                  this.throwUnexpectedToken();\n                }\n              }\n\n              id += ch;\n            }\n          }\n\n          return id;\n        };\n\n        Scanner.prototype.octalToDecimal = function (ch) {\n          // \\0 is not octal escape sequence\n          var octal = ch !== '0';\n          var code = octalValue(ch);\n\n          if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {\n            octal = true;\n            code = code * 8 + octalValue(this.source[this.index++]); // 3 digits are only allowed when string starts\n            // with 0, 1, 2, 3\n\n            if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {\n              code = code * 8 + octalValue(this.source[this.index++]);\n            }\n          }\n\n          return {\n            code: code,\n            octal: octal\n          };\n        }; // https://tc39.github.io/ecma262/#sec-names-and-keywords\n\n\n        Scanner.prototype.scanIdentifier = function () {\n          var type;\n          var start = this.index; // Backslash (U+005C) starts an escaped character.\n\n          var id = this.source.charCodeAt(start) === 0x5C ? this.getComplexIdentifier() : this.getIdentifier(); // There is no keyword or literal with only one character.\n          // Thus, it must be an identifier.\n\n          if (id.length === 1) {\n            type = 3\n            /* Identifier */\n            ;\n          } else if (this.isKeyword(id)) {\n            type = 4\n            /* Keyword */\n            ;\n          } else if (id === 'null') {\n            type = 5\n            /* NullLiteral */\n            ;\n          } else if (id === 'true' || id === 'false') {\n            type = 1\n            /* BooleanLiteral */\n            ;\n          } else {\n            type = 3\n            /* Identifier */\n            ;\n          }\n\n          if (type !== 3\n          /* Identifier */\n          && start + id.length !== this.index) {\n            var restore = this.index;\n            this.index = start;\n            this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);\n            this.index = restore;\n          }\n\n          return {\n            type: type,\n            value: id,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        }; // https://tc39.github.io/ecma262/#sec-punctuators\n\n\n        Scanner.prototype.scanPunctuator = function () {\n          var start = this.index; // Check for most common single-character punctuators.\n\n          var str = this.source[this.index];\n\n          switch (str) {\n            case '(':\n            case '{':\n              if (str === '{') {\n                this.curlyStack.push('{');\n              }\n\n              ++this.index;\n              break;\n\n            case '.':\n              ++this.index;\n\n              if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {\n                // Spread operator: ...\n                this.index += 2;\n                str = '...';\n              }\n\n              break;\n\n            case '}':\n              ++this.index;\n              this.curlyStack.pop();\n              break;\n\n            case ')':\n            case ';':\n            case ',':\n            case '[':\n            case ']':\n            case ':':\n            case '?':\n            case '~':\n              ++this.index;\n              break;\n\n            default:\n              // 4-character punctuator.\n              str = this.source.substr(this.index, 4);\n\n              if (str === '>>>=') {\n                this.index += 4;\n              } else {\n                // 3-character punctuators.\n                str = str.substr(0, 3);\n\n                if (str === '===' || str === '!==' || str === '>>>' || str === '<<=' || str === '>>=' || str === '**=') {\n                  this.index += 3;\n                } else {\n                  // 2-character punctuators.\n                  str = str.substr(0, 2);\n\n                  if (str === '&&' || str === '||' || str === '==' || str === '!=' || str === '+=' || str === '-=' || str === '*=' || str === '/=' || str === '++' || str === '--' || str === '<<' || str === '>>' || str === '&=' || str === '|=' || str === '^=' || str === '%=' || str === '<=' || str === '>=' || str === '=>' || str === '**') {\n                    this.index += 2;\n                  } else {\n                    // 1-character punctuators.\n                    str = this.source[this.index];\n\n                    if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {\n                      ++this.index;\n                    }\n                  }\n                }\n              }\n\n          }\n\n          if (this.index === start) {\n            this.throwUnexpectedToken();\n          }\n\n          return {\n            type: 7\n            /* Punctuator */\n            ,\n            value: str,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        }; // https://tc39.github.io/ecma262/#sec-literals-numeric-literals\n\n\n        Scanner.prototype.scanHexLiteral = function (start) {\n          var num = '';\n\n          while (!this.eof()) {\n            if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {\n              break;\n            }\n\n            num += this.source[this.index++];\n          }\n\n          if (num.length === 0) {\n            this.throwUnexpectedToken();\n          }\n\n          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {\n            this.throwUnexpectedToken();\n          }\n\n          return {\n            type: 6\n            /* NumericLiteral */\n            ,\n            value: parseInt('0x' + num, 16),\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        };\n\n        Scanner.prototype.scanBinaryLiteral = function (start) {\n          var num = '';\n          var ch;\n\n          while (!this.eof()) {\n            ch = this.source[this.index];\n\n            if (ch !== '0' && ch !== '1') {\n              break;\n            }\n\n            num += this.source[this.index++];\n          }\n\n          if (num.length === 0) {\n            // only 0b or 0B\n            this.throwUnexpectedToken();\n          }\n\n          if (!this.eof()) {\n            ch = this.source.charCodeAt(this.index);\n            /* istanbul ignore else */\n\n            if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {\n              this.throwUnexpectedToken();\n            }\n          }\n\n          return {\n            type: 6\n            /* NumericLiteral */\n            ,\n            value: parseInt(num, 2),\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        };\n\n        Scanner.prototype.scanOctalLiteral = function (prefix, start) {\n          var num = '';\n          var octal = false;\n\n          if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {\n            octal = true;\n            num = '0' + this.source[this.index++];\n          } else {\n            ++this.index;\n          }\n\n          while (!this.eof()) {\n            if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {\n              break;\n            }\n\n            num += this.source[this.index++];\n          }\n\n          if (!octal && num.length === 0) {\n            // only 0o or 0O\n            this.throwUnexpectedToken();\n          }\n\n          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n            this.throwUnexpectedToken();\n          }\n\n          return {\n            type: 6\n            /* NumericLiteral */\n            ,\n            value: parseInt(num, 8),\n            octal: octal,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        };\n\n        Scanner.prototype.isImplicitOctalLiteral = function () {\n          // Implicit octal, unless there is a non-octal digit.\n          // (Annex B.1.1 on Numeric Literals)\n          for (var i = this.index + 1; i < this.length; ++i) {\n            var ch = this.source[i];\n\n            if (ch === '8' || ch === '9') {\n              return false;\n            }\n\n            if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {\n              return true;\n            }\n          }\n\n          return true;\n        };\n\n        Scanner.prototype.scanNumericLiteral = function () {\n          var start = this.index;\n          var ch = this.source[start];\n          assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || ch === '.', 'Numeric literal must start with a decimal digit or a decimal point');\n          var num = '';\n\n          if (ch !== '.') {\n            num = this.source[this.index++];\n            ch = this.source[this.index]; // Hex number starts with '0x'.\n            // Octal number starts with '0'.\n            // Octal number in ES6 starts with '0o'.\n            // Binary number in ES6 starts with '0b'.\n\n            if (num === '0') {\n              if (ch === 'x' || ch === 'X') {\n                ++this.index;\n                return this.scanHexLiteral(start);\n              }\n\n              if (ch === 'b' || ch === 'B') {\n                ++this.index;\n                return this.scanBinaryLiteral(start);\n              }\n\n              if (ch === 'o' || ch === 'O') {\n                return this.scanOctalLiteral(ch, start);\n              }\n\n              if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {\n                if (this.isImplicitOctalLiteral()) {\n                  return this.scanOctalLiteral(ch, start);\n                }\n              }\n            }\n\n            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n              num += this.source[this.index++];\n            }\n\n            ch = this.source[this.index];\n          }\n\n          if (ch === '.') {\n            num += this.source[this.index++];\n\n            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n              num += this.source[this.index++];\n            }\n\n            ch = this.source[this.index];\n          }\n\n          if (ch === 'e' || ch === 'E') {\n            num += this.source[this.index++];\n            ch = this.source[this.index];\n\n            if (ch === '+' || ch === '-') {\n              num += this.source[this.index++];\n            }\n\n            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n              while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n                num += this.source[this.index++];\n              }\n            } else {\n              this.throwUnexpectedToken();\n            }\n          }\n\n          if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {\n            this.throwUnexpectedToken();\n          }\n\n          return {\n            type: 6\n            /* NumericLiteral */\n            ,\n            value: parseFloat(num),\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        }; // https://tc39.github.io/ecma262/#sec-literals-string-literals\n\n\n        Scanner.prototype.scanStringLiteral = function () {\n          var start = this.index;\n          var quote = this.source[start];\n          assert_1.assert(quote === '\\'' || quote === '\"', 'String literal must starts with a quote');\n          ++this.index;\n          var octal = false;\n          var str = '';\n\n          while (!this.eof()) {\n            var ch = this.source[this.index++];\n\n            if (ch === quote) {\n              quote = '';\n              break;\n            } else if (ch === '\\\\') {\n              ch = this.source[this.index++];\n\n              if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n                switch (ch) {\n                  case 'u':\n                    if (this.source[this.index] === '{') {\n                      ++this.index;\n                      str += this.scanUnicodeCodePointEscape();\n                    } else {\n                      var unescaped_1 = this.scanHexEscape(ch);\n\n                      if (unescaped_1 === null) {\n                        this.throwUnexpectedToken();\n                      }\n\n                      str += unescaped_1;\n                    }\n\n                    break;\n\n                  case 'x':\n                    var unescaped = this.scanHexEscape(ch);\n\n                    if (unescaped === null) {\n                      this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);\n                    }\n\n                    str += unescaped;\n                    break;\n\n                  case 'n':\n                    str += '\\n';\n                    break;\n\n                  case 'r':\n                    str += '\\r';\n                    break;\n\n                  case 't':\n                    str += '\\t';\n                    break;\n\n                  case 'b':\n                    str += '\\b';\n                    break;\n\n                  case 'f':\n                    str += '\\f';\n                    break;\n\n                  case 'v':\n                    str += '\\x0B';\n                    break;\n\n                  case '8':\n                  case '9':\n                    str += ch;\n                    this.tolerateUnexpectedToken();\n                    break;\n\n                  default:\n                    if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {\n                      var octToDec = this.octalToDecimal(ch);\n                      octal = octToDec.octal || octal;\n                      str += String.fromCharCode(octToDec.code);\n                    } else {\n                      str += ch;\n                    }\n\n                    break;\n                }\n              } else {\n                ++this.lineNumber;\n\n                if (ch === '\\r' && this.source[this.index] === '\\n') {\n                  ++this.index;\n                }\n\n                this.lineStart = this.index;\n              }\n            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n              break;\n            } else {\n              str += ch;\n            }\n          }\n\n          if (quote !== '') {\n            this.index = start;\n            this.throwUnexpectedToken();\n          }\n\n          return {\n            type: 8\n            /* StringLiteral */\n            ,\n            value: str,\n            octal: octal,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        }; // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components\n\n\n        Scanner.prototype.scanTemplate = function () {\n          var cooked = '';\n          var terminated = false;\n          var start = this.index;\n          var head = this.source[start] === '`';\n          var tail = false;\n          var rawOffset = 2;\n          ++this.index;\n\n          while (!this.eof()) {\n            var ch = this.source[this.index++];\n\n            if (ch === '`') {\n              rawOffset = 1;\n              tail = true;\n              terminated = true;\n              break;\n            } else if (ch === '$') {\n              if (this.source[this.index] === '{') {\n                this.curlyStack.push('${');\n                ++this.index;\n                terminated = true;\n                break;\n              }\n\n              cooked += ch;\n            } else if (ch === '\\\\') {\n              ch = this.source[this.index++];\n\n              if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n                switch (ch) {\n                  case 'n':\n                    cooked += '\\n';\n                    break;\n\n                  case 'r':\n                    cooked += '\\r';\n                    break;\n\n                  case 't':\n                    cooked += '\\t';\n                    break;\n\n                  case 'u':\n                    if (this.source[this.index] === '{') {\n                      ++this.index;\n                      cooked += this.scanUnicodeCodePointEscape();\n                    } else {\n                      var restore = this.index;\n                      var unescaped_2 = this.scanHexEscape(ch);\n\n                      if (unescaped_2 !== null) {\n                        cooked += unescaped_2;\n                      } else {\n                        this.index = restore;\n                        cooked += ch;\n                      }\n                    }\n\n                    break;\n\n                  case 'x':\n                    var unescaped = this.scanHexEscape(ch);\n\n                    if (unescaped === null) {\n                      this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);\n                    }\n\n                    cooked += unescaped;\n                    break;\n\n                  case 'b':\n                    cooked += '\\b';\n                    break;\n\n                  case 'f':\n                    cooked += '\\f';\n                    break;\n\n                  case 'v':\n                    cooked += '\\v';\n                    break;\n\n                  default:\n                    if (ch === '0') {\n                      if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {\n                        // Illegal: \\01 \\02 and so on\n                        this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);\n                      }\n\n                      cooked += '\\0';\n                    } else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {\n                      // Illegal: \\1 \\2\n                      this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);\n                    } else {\n                      cooked += ch;\n                    }\n\n                    break;\n                }\n              } else {\n                ++this.lineNumber;\n\n                if (ch === '\\r' && this.source[this.index] === '\\n') {\n                  ++this.index;\n                }\n\n                this.lineStart = this.index;\n              }\n            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n              ++this.lineNumber;\n\n              if (ch === '\\r' && this.source[this.index] === '\\n') {\n                ++this.index;\n              }\n\n              this.lineStart = this.index;\n              cooked += '\\n';\n            } else {\n              cooked += ch;\n            }\n          }\n\n          if (!terminated) {\n            this.throwUnexpectedToken();\n          }\n\n          if (!head) {\n            this.curlyStack.pop();\n          }\n\n          return {\n            type: 10\n            /* Template */\n            ,\n            value: this.source.slice(start + 1, this.index - rawOffset),\n            cooked: cooked,\n            head: head,\n            tail: tail,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        }; // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals\n\n\n        Scanner.prototype.testRegExp = function (pattern, flags) {\n          // The BMP character to use as a replacement for astral symbols when\n          // translating an ES6 \"u\"-flagged pattern to an ES5-compatible\n          // approximation.\n          // Note: replacing with '\\uFFFF' enables false positives in unlikely\n          // scenarios. For example, `[\\u{1044f}-\\u{10440}]` is an invalid\n          // pattern that would not be detected by this substitution.\n          var astralSubstitute = \"\\uFFFF\";\n          var tmp = pattern;\n          var self = this;\n\n          if (flags.indexOf('u') >= 0) {\n            tmp = tmp.replace(/\\\\u\\{([0-9a-fA-F]+)\\}|\\\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {\n              var codePoint = parseInt($1 || $2, 16);\n\n              if (codePoint > 0x10FFFF) {\n                self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);\n              }\n\n              if (codePoint <= 0xFFFF) {\n                return String.fromCharCode(codePoint);\n              }\n\n              return astralSubstitute;\n            }).replace(/[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g, astralSubstitute);\n          } // First, detect invalid regular expressions.\n\n\n          try {\n            RegExp(tmp);\n          } catch (e) {\n            this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);\n          } // Return a regular expression object for this pattern-flag pair, or\n          // `null` in case the current environment doesn't support the flags it\n          // uses.\n\n\n          try {\n            return new RegExp(pattern, flags);\n          } catch (exception) {\n            /* istanbul ignore next */\n            return null;\n          }\n        };\n\n        Scanner.prototype.scanRegExpBody = function () {\n          var ch = this.source[this.index];\n          assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');\n          var str = this.source[this.index++];\n          var classMarker = false;\n          var terminated = false;\n\n          while (!this.eof()) {\n            ch = this.source[this.index++];\n            str += ch;\n\n            if (ch === '\\\\') {\n              ch = this.source[this.index++]; // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals\n\n              if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n                this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);\n              }\n\n              str += ch;\n            } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {\n              this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);\n            } else if (classMarker) {\n              if (ch === ']') {\n                classMarker = false;\n              }\n            } else {\n              if (ch === '/') {\n                terminated = true;\n                break;\n              } else if (ch === '[') {\n                classMarker = true;\n              }\n            }\n          }\n\n          if (!terminated) {\n            this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);\n          } // Exclude leading and trailing slash.\n\n\n          return str.substr(1, str.length - 2);\n        };\n\n        Scanner.prototype.scanRegExpFlags = function () {\n          var str = '';\n          var flags = '';\n\n          while (!this.eof()) {\n            var ch = this.source[this.index];\n\n            if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {\n              break;\n            }\n\n            ++this.index;\n\n            if (ch === '\\\\' && !this.eof()) {\n              ch = this.source[this.index];\n\n              if (ch === 'u') {\n                ++this.index;\n                var restore = this.index;\n\n                var _char = this.scanHexEscape('u');\n\n                if (_char !== null) {\n                  flags += _char;\n\n                  for (str += \"\\\\u\"; restore < this.index; ++restore) {\n                    str += this.source[restore];\n                  }\n                } else {\n                  this.index = restore;\n                  flags += 'u';\n                  str += \"\\\\u\";\n                }\n\n                this.tolerateUnexpectedToken();\n              } else {\n                str += '\\\\';\n                this.tolerateUnexpectedToken();\n              }\n            } else {\n              flags += ch;\n              str += ch;\n            }\n          }\n\n          return flags;\n        };\n\n        Scanner.prototype.scanRegExp = function () {\n          var start = this.index;\n          var pattern = this.scanRegExpBody();\n          var flags = this.scanRegExpFlags();\n          var value = this.testRegExp(pattern, flags);\n          return {\n            type: 9\n            /* RegularExpression */\n            ,\n            value: '',\n            pattern: pattern,\n            flags: flags,\n            regex: value,\n            lineNumber: this.lineNumber,\n            lineStart: this.lineStart,\n            start: start,\n            end: this.index\n          };\n        };\n\n        Scanner.prototype.lex = function () {\n          if (this.eof()) {\n            return {\n              type: 2\n              /* EOF */\n              ,\n              value: '',\n              lineNumber: this.lineNumber,\n              lineStart: this.lineStart,\n              start: this.index,\n              end: this.index\n            };\n          }\n\n          var cp = this.source.charCodeAt(this.index);\n\n          if (character_1.Character.isIdentifierStart(cp)) {\n            return this.scanIdentifier();\n          } // Very common: ( and ) and ;\n\n\n          if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {\n            return this.scanPunctuator();\n          } // String literal starts with single quote (U+0027) or double quote (U+0022).\n\n\n          if (cp === 0x27 || cp === 0x22) {\n            return this.scanStringLiteral();\n          } // Dot (.) U+002E can also start a floating-point number, hence the need\n          // to check the next character.\n\n\n          if (cp === 0x2E) {\n            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {\n              return this.scanNumericLiteral();\n            }\n\n            return this.scanPunctuator();\n          }\n\n          if (character_1.Character.isDecimalDigit(cp)) {\n            return this.scanNumericLiteral();\n          } // Template literals start with ` (U+0060) for template head\n          // or } (U+007D) for template middle or template tail.\n\n\n          if (cp === 0x60 || cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${') {\n            return this.scanTemplate();\n          } // Possible identifier start in a surrogate pair.\n\n\n          if (cp >= 0xD800 && cp < 0xDFFF) {\n            if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {\n              return this.scanIdentifier();\n            }\n          }\n\n          return this.scanPunctuator();\n        };\n\n        return Scanner;\n      }();\n\n      exports.Scanner = Scanner;\n      /***/\n    },\n    /* 13 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.TokenName = {};\n      exports.TokenName[1\n      /* BooleanLiteral */\n      ] = 'Boolean';\n      exports.TokenName[2\n      /* EOF */\n      ] = '<end>';\n      exports.TokenName[3\n      /* Identifier */\n      ] = 'Identifier';\n      exports.TokenName[4\n      /* Keyword */\n      ] = 'Keyword';\n      exports.TokenName[5\n      /* NullLiteral */\n      ] = 'Null';\n      exports.TokenName[6\n      /* NumericLiteral */\n      ] = 'Numeric';\n      exports.TokenName[7\n      /* Punctuator */\n      ] = 'Punctuator';\n      exports.TokenName[8\n      /* StringLiteral */\n      ] = 'String';\n      exports.TokenName[9\n      /* RegularExpression */\n      ] = 'RegularExpression';\n      exports.TokenName[10\n      /* Template */\n      ] = 'Template';\n      /***/\n    },\n    /* 14 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\"; // Generated by generate-xhtml-entities.js. DO NOT MODIFY!\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.XHTMLEntities = {\n        quot: \"\\\"\",\n        amp: \"&\",\n        apos: \"'\",\n        gt: \">\",\n        nbsp: \"\\xA0\",\n        iexcl: \"\\xA1\",\n        cent: \"\\xA2\",\n        pound: \"\\xA3\",\n        curren: \"\\xA4\",\n        yen: \"\\xA5\",\n        brvbar: \"\\xA6\",\n        sect: \"\\xA7\",\n        uml: \"\\xA8\",\n        copy: \"\\xA9\",\n        ordf: \"\\xAA\",\n        laquo: \"\\xAB\",\n        not: \"\\xAC\",\n        shy: \"\\xAD\",\n        reg: \"\\xAE\",\n        macr: \"\\xAF\",\n        deg: \"\\xB0\",\n        plusmn: \"\\xB1\",\n        sup2: \"\\xB2\",\n        sup3: \"\\xB3\",\n        acute: \"\\xB4\",\n        micro: \"\\xB5\",\n        para: \"\\xB6\",\n        middot: \"\\xB7\",\n        cedil: \"\\xB8\",\n        sup1: \"\\xB9\",\n        ordm: \"\\xBA\",\n        raquo: \"\\xBB\",\n        frac14: \"\\xBC\",\n        frac12: \"\\xBD\",\n        frac34: \"\\xBE\",\n        iquest: \"\\xBF\",\n        Agrave: \"\\xC0\",\n        Aacute: \"\\xC1\",\n        Acirc: \"\\xC2\",\n        Atilde: \"\\xC3\",\n        Auml: \"\\xC4\",\n        Aring: \"\\xC5\",\n        AElig: \"\\xC6\",\n        Ccedil: \"\\xC7\",\n        Egrave: \"\\xC8\",\n        Eacute: \"\\xC9\",\n        Ecirc: \"\\xCA\",\n        Euml: \"\\xCB\",\n        Igrave: \"\\xCC\",\n        Iacute: \"\\xCD\",\n        Icirc: \"\\xCE\",\n        Iuml: \"\\xCF\",\n        ETH: \"\\xD0\",\n        Ntilde: \"\\xD1\",\n        Ograve: \"\\xD2\",\n        Oacute: \"\\xD3\",\n        Ocirc: \"\\xD4\",\n        Otilde: \"\\xD5\",\n        Ouml: \"\\xD6\",\n        times: \"\\xD7\",\n        Oslash: \"\\xD8\",\n        Ugrave: \"\\xD9\",\n        Uacute: \"\\xDA\",\n        Ucirc: \"\\xDB\",\n        Uuml: \"\\xDC\",\n        Yacute: \"\\xDD\",\n        THORN: \"\\xDE\",\n        szlig: \"\\xDF\",\n        agrave: \"\\xE0\",\n        aacute: \"\\xE1\",\n        acirc: \"\\xE2\",\n        atilde: \"\\xE3\",\n        auml: \"\\xE4\",\n        aring: \"\\xE5\",\n        aelig: \"\\xE6\",\n        ccedil: \"\\xE7\",\n        egrave: \"\\xE8\",\n        eacute: \"\\xE9\",\n        ecirc: \"\\xEA\",\n        euml: \"\\xEB\",\n        igrave: \"\\xEC\",\n        iacute: \"\\xED\",\n        icirc: \"\\xEE\",\n        iuml: \"\\xEF\",\n        eth: \"\\xF0\",\n        ntilde: \"\\xF1\",\n        ograve: \"\\xF2\",\n        oacute: \"\\xF3\",\n        ocirc: \"\\xF4\",\n        otilde: \"\\xF5\",\n        ouml: \"\\xF6\",\n        divide: \"\\xF7\",\n        oslash: \"\\xF8\",\n        ugrave: \"\\xF9\",\n        uacute: \"\\xFA\",\n        ucirc: \"\\xFB\",\n        uuml: \"\\xFC\",\n        yacute: \"\\xFD\",\n        thorn: \"\\xFE\",\n        yuml: \"\\xFF\",\n        OElig: \"\\u0152\",\n        oelig: \"\\u0153\",\n        Scaron: \"\\u0160\",\n        scaron: \"\\u0161\",\n        Yuml: \"\\u0178\",\n        fnof: \"\\u0192\",\n        circ: \"\\u02C6\",\n        tilde: \"\\u02DC\",\n        Alpha: \"\\u0391\",\n        Beta: \"\\u0392\",\n        Gamma: \"\\u0393\",\n        Delta: \"\\u0394\",\n        Epsilon: \"\\u0395\",\n        Zeta: \"\\u0396\",\n        Eta: \"\\u0397\",\n        Theta: \"\\u0398\",\n        Iota: \"\\u0399\",\n        Kappa: \"\\u039A\",\n        Lambda: \"\\u039B\",\n        Mu: \"\\u039C\",\n        Nu: \"\\u039D\",\n        Xi: \"\\u039E\",\n        Omicron: \"\\u039F\",\n        Pi: \"\\u03A0\",\n        Rho: \"\\u03A1\",\n        Sigma: \"\\u03A3\",\n        Tau: \"\\u03A4\",\n        Upsilon: \"\\u03A5\",\n        Phi: \"\\u03A6\",\n        Chi: \"\\u03A7\",\n        Psi: \"\\u03A8\",\n        Omega: \"\\u03A9\",\n        alpha: \"\\u03B1\",\n        beta: \"\\u03B2\",\n        gamma: \"\\u03B3\",\n        delta: \"\\u03B4\",\n        epsilon: \"\\u03B5\",\n        zeta: \"\\u03B6\",\n        eta: \"\\u03B7\",\n        theta: \"\\u03B8\",\n        iota: \"\\u03B9\",\n        kappa: \"\\u03BA\",\n        lambda: \"\\u03BB\",\n        mu: \"\\u03BC\",\n        nu: \"\\u03BD\",\n        xi: \"\\u03BE\",\n        omicron: \"\\u03BF\",\n        pi: \"\\u03C0\",\n        rho: \"\\u03C1\",\n        sigmaf: \"\\u03C2\",\n        sigma: \"\\u03C3\",\n        tau: \"\\u03C4\",\n        upsilon: \"\\u03C5\",\n        phi: \"\\u03C6\",\n        chi: \"\\u03C7\",\n        psi: \"\\u03C8\",\n        omega: \"\\u03C9\",\n        thetasym: \"\\u03D1\",\n        upsih: \"\\u03D2\",\n        piv: \"\\u03D6\",\n        ensp: \"\\u2002\",\n        emsp: \"\\u2003\",\n        thinsp: \"\\u2009\",\n        zwnj: \"\\u200C\",\n        zwj: \"\\u200D\",\n        lrm: \"\\u200E\",\n        rlm: \"\\u200F\",\n        ndash: \"\\u2013\",\n        mdash: \"\\u2014\",\n        lsquo: \"\\u2018\",\n        rsquo: \"\\u2019\",\n        sbquo: \"\\u201A\",\n        ldquo: \"\\u201C\",\n        rdquo: \"\\u201D\",\n        bdquo: \"\\u201E\",\n        dagger: \"\\u2020\",\n        Dagger: \"\\u2021\",\n        bull: \"\\u2022\",\n        hellip: \"\\u2026\",\n        permil: \"\\u2030\",\n        prime: \"\\u2032\",\n        Prime: \"\\u2033\",\n        lsaquo: \"\\u2039\",\n        rsaquo: \"\\u203A\",\n        oline: \"\\u203E\",\n        frasl: \"\\u2044\",\n        euro: \"\\u20AC\",\n        image: \"\\u2111\",\n        weierp: \"\\u2118\",\n        real: \"\\u211C\",\n        trade: \"\\u2122\",\n        alefsym: \"\\u2135\",\n        larr: \"\\u2190\",\n        uarr: \"\\u2191\",\n        rarr: \"\\u2192\",\n        darr: \"\\u2193\",\n        harr: \"\\u2194\",\n        crarr: \"\\u21B5\",\n        lArr: \"\\u21D0\",\n        uArr: \"\\u21D1\",\n        rArr: \"\\u21D2\",\n        dArr: \"\\u21D3\",\n        hArr: \"\\u21D4\",\n        forall: \"\\u2200\",\n        part: \"\\u2202\",\n        exist: \"\\u2203\",\n        empty: \"\\u2205\",\n        nabla: \"\\u2207\",\n        isin: \"\\u2208\",\n        notin: \"\\u2209\",\n        ni: \"\\u220B\",\n        prod: \"\\u220F\",\n        sum: \"\\u2211\",\n        minus: \"\\u2212\",\n        lowast: \"\\u2217\",\n        radic: \"\\u221A\",\n        prop: \"\\u221D\",\n        infin: \"\\u221E\",\n        ang: \"\\u2220\",\n        and: \"\\u2227\",\n        or: \"\\u2228\",\n        cap: \"\\u2229\",\n        cup: \"\\u222A\",\n        \"int\": \"\\u222B\",\n        there4: \"\\u2234\",\n        sim: \"\\u223C\",\n        cong: \"\\u2245\",\n        asymp: \"\\u2248\",\n        ne: \"\\u2260\",\n        equiv: \"\\u2261\",\n        le: \"\\u2264\",\n        ge: \"\\u2265\",\n        sub: \"\\u2282\",\n        sup: \"\\u2283\",\n        nsub: \"\\u2284\",\n        sube: \"\\u2286\",\n        supe: \"\\u2287\",\n        oplus: \"\\u2295\",\n        otimes: \"\\u2297\",\n        perp: \"\\u22A5\",\n        sdot: \"\\u22C5\",\n        lceil: \"\\u2308\",\n        rceil: \"\\u2309\",\n        lfloor: \"\\u230A\",\n        rfloor: \"\\u230B\",\n        loz: \"\\u25CA\",\n        spades: \"\\u2660\",\n        clubs: \"\\u2663\",\n        hearts: \"\\u2665\",\n        diams: \"\\u2666\",\n        lang: \"\\u27E8\",\n        rang: \"\\u27E9\"\n      };\n      /***/\n    },\n    /* 15 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var error_handler_1 = __webpack_require__(10);\n\n      var scanner_1 = __webpack_require__(12);\n\n      var token_1 = __webpack_require__(13);\n\n      var Reader = function () {\n        function Reader() {\n          this.values = [];\n          this.curly = this.paren = -1;\n        } // A function following one of those tokens is an expression.\n\n\n        Reader.prototype.beforeFunctionExpression = function (t) {\n          return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new', 'return', 'case', 'delete', 'throw', 'void', // assignment operators\n          '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=', '&=', '|=', '^=', ',', // binary/unary operators\n          '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&', '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=', '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;\n        }; // Determine if forward slash (/) is an operator or part of a regular expression\n        // https://github.com/mozilla/sweet.js/wiki/design\n\n\n        Reader.prototype.isRegexStart = function () {\n          var previous = this.values[this.values.length - 1];\n          var regex = previous !== null;\n\n          switch (previous) {\n            case 'this':\n            case ']':\n              regex = false;\n              break;\n\n            case ')':\n              var keyword = this.values[this.paren - 1];\n              regex = keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with';\n              break;\n\n            case '}':\n              // Dividing a function by anything makes little sense,\n              // but we have to check for that.\n              regex = false;\n\n              if (this.values[this.curly - 3] === 'function') {\n                // Anonymous function, e.g. function(){} /42\n                var check = this.values[this.curly - 4];\n                regex = check ? !this.beforeFunctionExpression(check) : false;\n              } else if (this.values[this.curly - 4] === 'function') {\n                // Named function, e.g. function f(){} /42/\n                var check = this.values[this.curly - 5];\n                regex = check ? !this.beforeFunctionExpression(check) : true;\n              }\n\n              break;\n\n            default:\n              break;\n          }\n\n          return regex;\n        };\n\n        Reader.prototype.push = function (token) {\n          if (token.type === 7\n          /* Punctuator */\n          || token.type === 4\n          /* Keyword */\n          ) {\n              if (token.value === '{') {\n                this.curly = this.values.length;\n              } else if (token.value === '(') {\n                this.paren = this.values.length;\n              }\n\n              this.values.push(token.value);\n            } else {\n            this.values.push(null);\n          }\n        };\n\n        return Reader;\n      }();\n\n      var Tokenizer = function () {\n        function Tokenizer(code, config) {\n          this.errorHandler = new error_handler_1.ErrorHandler();\n          this.errorHandler.tolerant = config ? typeof config.tolerant === 'boolean' && config.tolerant : false;\n          this.scanner = new scanner_1.Scanner(code, this.errorHandler);\n          this.scanner.trackComment = config ? typeof config.comment === 'boolean' && config.comment : false;\n          this.trackRange = config ? typeof config.range === 'boolean' && config.range : false;\n          this.trackLoc = config ? typeof config.loc === 'boolean' && config.loc : false;\n          this.buffer = [];\n          this.reader = new Reader();\n        }\n\n        Tokenizer.prototype.errors = function () {\n          return this.errorHandler.errors;\n        };\n\n        Tokenizer.prototype.getNextToken = function () {\n          if (this.buffer.length === 0) {\n            var comments = this.scanner.scanComments();\n\n            if (this.scanner.trackComment) {\n              for (var i = 0; i < comments.length; ++i) {\n                var e = comments[i];\n                var value = this.scanner.source.slice(e.slice[0], e.slice[1]);\n                var comment = {\n                  type: e.multiLine ? 'BlockComment' : 'LineComment',\n                  value: value\n                };\n\n                if (this.trackRange) {\n                  comment.range = e.range;\n                }\n\n                if (this.trackLoc) {\n                  comment.loc = e.loc;\n                }\n\n                this.buffer.push(comment);\n              }\n            }\n\n            if (!this.scanner.eof()) {\n              var loc = void 0;\n\n              if (this.trackLoc) {\n                loc = {\n                  start: {\n                    line: this.scanner.lineNumber,\n                    column: this.scanner.index - this.scanner.lineStart\n                  },\n                  end: {}\n                };\n              }\n\n              var startRegex = this.scanner.source[this.scanner.index] === '/' && this.reader.isRegexStart();\n              var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();\n              this.reader.push(token);\n              var entry = {\n                type: token_1.TokenName[token.type],\n                value: this.scanner.source.slice(token.start, token.end)\n              };\n\n              if (this.trackRange) {\n                entry.range = [token.start, token.end];\n              }\n\n              if (this.trackLoc) {\n                loc.end = {\n                  line: this.scanner.lineNumber,\n                  column: this.scanner.index - this.scanner.lineStart\n                };\n                entry.loc = loc;\n              }\n\n              if (token.type === 9\n              /* RegularExpression */\n              ) {\n                  var pattern = token.pattern;\n                  var flags = token.flags;\n                  entry.regex = {\n                    pattern: pattern,\n                    flags: flags\n                  };\n                }\n\n              this.buffer.push(entry);\n            }\n          }\n\n          return this.buffer.shift();\n        };\n\n        return Tokenizer;\n      }();\n\n      exports.Tokenizer = Tokenizer;\n      /***/\n    }\n    /******/\n    ])\n  );\n});\n\n;"],"sourceRoot":""}