blob: 81aaa67d54c17f19d12eed6d0fbb886a00c2dff1 [file] [log] [blame]
{"version":3,"sources":["webpack:///./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","static","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","await","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","int","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":"9f96d65d-7aa8bd955a463c686845.js","sourcesContent":["(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 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":""}