astexplorer.app
Version:
https://astexplorer.net with ES Modules support and Hot Reloading
1 lines • 375 kB
JavaScript
(window.webpackJsonp=window.webpackJsonp||[]).push([[100],{"./node_modules/tenko/build/tenko.prod.mjs":function(__webpack_module__,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Tenko\", function() { return Tenko; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Lexer\", function() { return Lexer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"COLLECT_TOKENS_NONE\", function() { return COLLECT_TOKENS_NONE; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"COLLECT_TOKENS_SOLID\", function() { return COLLECT_TOKENS_SOLID; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"COLLECT_TOKENS_ALL\", function() { return COLLECT_TOKENS_ALL; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"COLLECT_TOKENS_TYPES\", function() { return COLLECT_TOKENS_TYPES; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"GOAL_MODULE\", function() { return GOAL_MODULE; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"GOAL_SCRIPT\", function() { return GOAL_SCRIPT; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"WEB_COMPAT_OFF\", function() { return WEB_COMPAT_OFF; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"WEB_COMPAT_ON\", function() { return WEB_COMPAT_ON; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"VERSION_EXPONENTIATION\", function() { return VERSION_EXPONENTIATION; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"VERSION_WHATEVER\", function() { return VERSION_WHATEVER; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isWhiteToken\", function() { return isWhiteToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isNewlineToken\", function() { return isNewlineToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isCommentToken\", function() { return isCommentToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isIdentToken\", function() { return isIdentToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isNumberToken\", function() { return isNumberToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isBigintToken\", function() { return isBigintToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isStringToken\", function() { return isStringToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isPunctuatorToken\", function() { return isPunctuatorToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isRegexToken\", function() { return isRegexToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isTickToken\", function() { return isTickToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isBadTickToken\", function() { return isBadTickToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isNumberStringToken\", function() { return isNumberStringToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isNumberStringRegex\", function() { return isNumberStringRegex; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"toktypeToString\", function() { return toktypeToString; });\n\n\n\n\n// <perf>\nlet IGNORE = {};\n// </perf>\n\n// <charcodes>\n\n// </charcodes>\n\n// <utils>\nfunction inspect(...args) {\nconsole.dir(((args.length === 1)? args[0] : args), {depth:null});\n}\nfunction THROW(str, ...rest) {\nthrow new Error(`Parser error! ${str} ${(rest.length? rest : '')}`);\n}\n// </utils>\n\n// <tokentype>\nlet __$flag_leaf = 0;\nlet __$flag_group = 7;\nlet ALL_GEES;\nlet KEYWORD_TRIE_OBJLIT = {0:{17:{6:{20:{12:{4:{13:{19:{18:{hit:2072, canon:'arguments'}}}}}}}}, 18:{24:{13:{2:{hit:2074, canon:'async'}}}, hit:2073, canon:'as'}, 22:{0:{8:{19:{hit:2075, canon:'await'}}}}}, 1:{17:{4:{0:{10:{hit:2076, canon:'break'}}}}}, 2:{0:{18:{4:{hit:2077, canon:'case'}}, 19:{2:{7:{hit:2078, canon:'catch'}}}}, 11:{0:{18:{18:{hit:2079, canon:'class'}}}}, 14:{13:{18:{19:{hit:2080, canon:'const'}}, 19:{8:{13:{20:{4:{hit:2081, canon:'continue'}}}}}}}}, 3:{4:{1:{20:{6:{6:{4:{17:{hit:2082, canon:'debugger'}}}}}}, 5:{0:{20:{11:{19:{hit:2083, canon:'default'}}}}}, 11:{4:{19:{4:{hit:2084, canon:'delete'}}}}}, 14:{hit:2085, canon:'do'}}, 4:{11:{18:{4:{hit:2086, canon:'else'}}}, 13:{20:{12:{hit:2087, canon:'enum'}}}, 21:{0:{11:{hit:2088, canon:'eval'}}}, 23:{15:{14:{17:{19:{hit:2089, canon:'export'}}}}, 19:{4:{13:{3:{18:{hit:2090, canon:'extends'}}}}}}}, 5:{0:{11:{18:{4:{hit:2091, canon:'false'}}}}, 8:{13:{0:{11:{11:{24:{hit:2092, canon:'finally'}}}}}}, 14:{17:{hit:2093, canon:'for'}}, 17:{14:{12:{hit:2094, canon:'from'}}}, 20:{13:{2:{19:{8:{14:{13:{hit:2095, canon:'function'}}}}}}}}, 6:{4:{19:{hit:2096, canon:'get'}}}, 8:{5:{hit:2097, canon:'if'}, 12:{15:{11:{4:{12:{4:{13:{19:{18:{hit:2098, canon:'implements'}}}}}}}, 14:{17:{19:{hit:2099, canon:'import'}}}}}, 13:{18:{19:{0:{13:{2:{4:{14:{5:{hit:67637, canon:'instanceof'}}}}}}}}, 19:{4:{17:{5:{0:{2:{4:{hit:2102, canon:'interface'}}}}}}}, hit:67636, canon:'in'}}, 11:{4:{19:{hit:2103, canon:'let'}}}, 13:{4:{22:{hit:2104, canon:'new'}}, 20:{11:{11:{hit:2105, canon:'null'}}}}, 14:{5:{hit:2106, canon:'of'}}, 15:{0:{2:{10:{0:{6:{4:{hit:2107, canon:'package'}}}}}}, 17:{8:{21:{0:{19:{4:{hit:2108, canon:'private'}}}}}, 14:{19:{4:{2:{19:{4:{3:{hit:2109, canon:'protected'}}}}}}}}, 20:{1:{11:{8:{2:{hit:2110, canon:'public'}}}}}}, 17:{4:{19:{20:{17:{13:{hit:2111, canon:'return'}}}}}}, 18:{4:{19:{hit:2112, canon:'set'}}, 19:{0:{19:{8:{2:{hit:2113, canon:'static'}}}}}, 20:{15:{4:{17:{hit:2114, canon:'super'}}}}, 22:{8:{19:{2:{7:{hit:2115, canon:'switch'}}}}}}, 19:{0:{17:{6:{4:{19:{hit:2116, canon:'target'}}}}}, 7:{8:{18:{hit:2117, canon:'this'}}, 17:{14:{22:{hit:2118, canon:'throw'}}}}, 17:{20:{4:{hit:2119, canon:'true'}}, 24:{hit:2120, canon:'try'}}, 24:{15:{4:{14:{5:{hit:2121, canon:'typeof'}}}}}}, 21:{0:{17:{hit:2122, canon:'var'}}, 14:{8:{3:{hit:2123, canon:'void'}}}}, 22:{7:{8:{11:{4:{hit:2124, canon:'while'}}}}, 8:{19:{7:{hit:2125, canon:'with'}}}}, 24:{8:{4:{11:{3:{hit:2126, canon:'yield'}}}}}};\nfunction isWhiteToken(type) {\nreturn (type & 256) === 256;\n}\nfunction isNewlineToken(type) {\nreturn (type & 512) === 512;\n}\nfunction isCommentToken(type) {\nreturn (type & 1024) === 1024;\n}\nfunction isIdentToken(type) {\nreturn (type & 2048) === 2048;\n}\nfunction isNumberToken(type) {\nreturn (type & 4096) === 4096;\n}\nfunction isBigintToken(type) {\nreturn (type & 8192) === 8192;\n}\nfunction isStringToken(type) {\nreturn (type & 131072) === 131072;\n}\nfunction isPunctuatorToken(type) {\nreturn (type & 16384) === 16384;\n}\nfunction isRegexToken(type) {\nreturn (type & 262144) === 262144;\n}\nfunction isTickToken(type) {\nreturn (type & 524288) === 524288;\n}\nfunction isBadTickToken(type) {\nreturn (type & 1048576) === 1048576;\n}\nfunction isNumberStringToken(type) {\nreturn (type & 135168) !== 0;\n}\nfunction isNumberStringRegex(type) {\nreturn (type & 397312) !== 0;\n}\nfunction toktypeToString(type, token, ignoreUnknown) {\nswitch ((((typeof type) === 'object')? type.type : type)) {\ncase 0:\nreturn 'UNTYPED';\ncase 257:\nreturn 'SPACE';\ncase 258:\nreturn 'TAB';\ncase 771:\nreturn 'NL_SOLO';\ncase 772:\nreturn 'NL_CRLF';\ncase 1285:\nreturn 'COMMENT_SINGLE';\ncase 1286:\nreturn 'COMMENT_MULTI';\ncase 1287:\nreturn 'COMMENT_HTML';\ncase 2048:\nreturn 'IDENT';\ncase 2072:\nreturn 'ID_arguments';\ncase 2073:\nreturn 'ID_as';\ncase 2074:\nreturn 'ID_async';\ncase 2075:\nreturn 'ID_await';\ncase 2076:\nreturn 'ID_break';\ncase 2077:\nreturn 'ID_case';\ncase 2078:\nreturn 'ID_catch';\ncase 2079:\nreturn 'ID_class';\ncase 2080:\nreturn 'ID_const';\ncase 2081:\nreturn 'ID_continue';\ncase 2082:\nreturn 'ID_debugger';\ncase 2083:\nreturn 'ID_default';\ncase 2084:\nreturn 'ID_delete';\ncase 2085:\nreturn 'ID_do';\ncase 2086:\nreturn 'ID_else';\ncase 2087:\nreturn 'ID_enum';\ncase 2088:\nreturn 'ID_eval';\ncase 2089:\nreturn 'ID_export';\ncase 2090:\nreturn 'ID_extends';\ncase 2091:\nreturn 'ID_false';\ncase 2092:\nreturn 'ID_finally';\ncase 2093:\nreturn 'ID_for';\ncase 2094:\nreturn 'ID_from';\ncase 2095:\nreturn 'ID_function';\ncase 2096:\nreturn 'ID_get';\ncase 2097:\nreturn 'ID_if';\ncase 2098:\nreturn 'ID_implements';\ncase 2099:\nreturn 'ID_import';\ncase 67636:\nreturn 'ID_in';\ncase 67637:\nreturn 'ID_instanceof';\ncase 2102:\nreturn 'ID_interface';\ncase 2103:\nreturn 'ID_let';\ncase 2104:\nreturn 'ID_new';\ncase 2105:\nreturn 'ID_null';\ncase 2106:\nreturn 'ID_of';\ncase 2107:\nreturn 'ID_package';\ncase 2108:\nreturn 'ID_private';\ncase 2109:\nreturn 'ID_protected';\ncase 2110:\nreturn 'ID_public';\ncase 2111:\nreturn 'ID_return';\ncase 2112:\nreturn 'ID_set';\ncase 2113:\nreturn 'ID_static';\ncase 2114:\nreturn 'ID_super';\ncase 2115:\nreturn 'ID_switch';\ncase 2116:\nreturn 'ID_target';\ncase 2117:\nreturn 'ID_this';\ncase 2118:\nreturn 'ID_throw';\ncase 2119:\nreturn 'ID_true';\ncase 2120:\nreturn 'ID_try';\ncase 2121:\nreturn 'ID_typeof';\ncase 2122:\nreturn 'ID_var';\ncase 2123:\nreturn 'ID_void';\ncase 2124:\nreturn 'ID_while';\ncase 2125:\nreturn 'ID_with';\ncase 2126:\nreturn 'ID_yield';\ncase 4104:\nreturn 'NUMBER_HEX';\ncase 4105:\nreturn 'NUMBER_DEC';\ncase 4106:\nreturn 'NUMBER_BIN';\ncase 4107:\nreturn 'NUMBER_OCT';\ncase 4108:\nreturn 'NUMBER_OLD';\ncase 12296:\nreturn 'NUMBER_BIG_HEX';\ncase 12297:\nreturn 'NUMBER_BIG_DEC';\ncase 12298:\nreturn 'NUMBER_BIG_BIN';\ncase 12299:\nreturn 'NUMBER_BIG_OCT';\ncase 16463:\nreturn 'PUNC_EXCL';\ncase 82000:\nreturn 'PUNC_EXCL_EQ';\ncase 82001:\nreturn 'PUNC_EXCL_EQ_EQ';\ncase 82002:\nreturn 'PUNC_PERCENT';\ncase 49235:\nreturn 'PUNC_PERCENT_EQ';\ncase 82004:\nreturn 'PUNC_AND';\ncase 82005:\nreturn 'PUNC_AND_AND';\ncase 49238:\nreturn 'PUNC_AND_EQ';\ncase 16471:\nreturn 'PUNC_PAREN_OPEN';\ncase 16472:\nreturn 'PUNC_PAREN_CLOSE';\ncase 82009:\nreturn 'PUNC_STAR';\ncase 82010:\nreturn 'PUNC_STAR_STAR';\ncase 49243:\nreturn 'PUNC_STAR_EQ';\ncase 49244:\nreturn 'PUNC_STAR_STAR_EQ';\ncase 82013:\nreturn 'PUNC_PLUS';\ncase 16478:\nreturn 'PUNC_PLUS_PLUS';\ncase 49247:\nreturn 'PUNC_PLUS_EQ';\ncase 16480:\nreturn 'PUNC_COMMA';\ncase 82017:\nreturn 'PUNC_MIN';\ncase 16482:\nreturn 'PUNC_MIN_MIN';\ncase 49251:\nreturn 'PUNC_MIN_EQ';\ncase 16484:\nreturn 'PUNC_MIN_MIN_GT';\ncase 16485:\nreturn 'PUNC_DOT';\ncase 16486:\nreturn 'PUNC_DOT_DOT_DOT';\ncase 82023:\nreturn 'PUNC_DIV';\ncase 49256:\nreturn 'PUNC_DIV_EQ';\ncase 16489:\nreturn 'PUNC_COLON';\ncase 16490:\nreturn 'PUNC_SEMI';\ncase 82027:\nreturn 'PUNC_LT';\ncase 82028:\nreturn 'PUNC_LT_LT';\ncase 82029:\nreturn 'PUNC_LT_EQ';\ncase 49262:\nreturn 'PUNC_LT_LT_EQ';\ncase 16495:\nreturn 'PUNC_LT_EXCL_MIN_MIN';\ncase 49264:\nreturn 'PUNC_EQ';\ncase 82033:\nreturn 'PUNC_EQ_EQ';\ncase 82034:\nreturn 'PUNC_EQ_EQ_EQ';\ncase 16499:\nreturn 'PUNC_EQ_GT';\ncase 82036:\nreturn 'PUNC_GT';\ncase 82037:\nreturn 'PUNC_GT_GT';\ncase 82038:\nreturn 'PUNC_GT_GT_GT';\ncase 82039:\nreturn 'PUNC_GT_EQ';\ncase 49272:\nreturn 'PUNC_GT_GT_EQ';\ncase 49273:\nreturn 'PUNC_GT_GT_GT_EQ';\ncase 16506:\nreturn 'PUNC_QMARK';\ncase 82043:\nreturn 'QMARK_DOT';\ncase 82044:\nreturn 'QMARK_QMARK';\ncase 16509:\nreturn 'PUNC_BRACKET_OPEN';\ncase 16510:\nreturn 'PUNC_BRACKET_CLOSE';\ncase 82047:\nreturn 'PUNC_CARET';\ncase 49280:\nreturn 'PUNC_CARET_EQ';\ncase 16513:\nreturn 'PUNC_CURLY_OPEN';\ncase 82050:\nreturn 'PUNC_OR';\ncase 82051:\nreturn 'PUNC_OR_OR';\ncase 49284:\nreturn 'PUNC_OR_EQ';\ncase 16517:\nreturn 'PUNC_CURLY_CLOSE';\ncase 16518:\nreturn 'PUNC_TILDE';\ncase 262157:\nreturn 'REGEXN';\ncase 262158:\nreturn 'REGEXU';\ncase 131087:\nreturn 'STRING_SINGLE';\ncase 131088:\nreturn 'STRING_DOUBLE';\ncase 524305:\nreturn 'TICK_HEAD';\ncase 524306:\nreturn 'TICK_BODY';\ncase 524307:\nreturn 'TICK_TAIL';\ncase 524308:\nreturn 'TICK_PURE';\ncase 1572881:\nreturn 'TICK_BAD_HEAD';\ncase 1572882:\nreturn 'TICK_BAD_BODY';\ncase 1572883:\nreturn 'TICK_BAD_TAIL';\ncase 1572884:\nreturn 'TICK_BAD_PURE';\ncase 2097173:\nreturn 'EOF';\ncase 2097174:\nreturn 'ASI';\ncase 2097175:\nreturn 'ERROR';\n}\nif (ignoreUnknown) return ('UNKNOWN[' + ((((typeof type) === 'object')? type.type : type))) + ']';\nthrow new Error(('toktypeToString: UNKNOWN[' + JSON.stringify(type)) + ']');\n}\nlet MAX_START_VALUE = 26;\nlet __$flag_start = 0;\nlet tokenStartJumpTable = [26, 26, 26, 26, 26, 26, 26, 26, 26, 1, 4, 1, 1, 5, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 1, 16, 6, 26, 2, 17, 18, 6, 16471, 16472, 19, 12, 16480, 13, 8, 11, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 16489, 16490, 21, 10, 22, 25, 26, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 16509, 24, 16510, 20, 2, 15, 3, 3, 3, 3, 3, 3, 3, 2, 3, 2, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 2, 3, 2, 16513, 23, 9, 16518];\nlet stringScanTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\nlet identScanTable = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1];\nlet regexAtomEscapeStartJumpTable = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 1, 1, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 0, 1, 11, 11, 11, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 6, 11, 11, 0, 11, 11, 11, 0, 11, 11, 11, 0, 0, 0, 0, 11, 1, 11, 11, 5, 0, 11, 0, 11, 11, 11, 11, 9, 11, 11, 0, 11, 6, 11, 0, 0, 0, 2, 0, 0, 3, 11, 11, 0, 0, 0, 1];\nlet regexClassEscapeStartJumpTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 18, 18, 18, 18, 0, 19, 18, 18, 15, 16, 16, 16, 16, 16, 16, 16, 17, 17, 0, 0, 0, 0, 0, 18, 0, 0, 7, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 18, 18, 18, 18, 0, 0, 0, 6, 4, 13, 0, 8, 0, 0, 0, 0, 5, 0, 0, 9, 0, 14, 0, 10, 13, 11, 2, 12, 13, 3, 0, 0, 18, 18, 18, 0];\nlet hexValueJumpTable = [16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 16, 16, 16, 16, 16, 16, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 10, 11, 12, 13, 14, 15];\nlet regexAtomJumpTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 3, 4, 2, 2, 0, 0, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 14, 13, 0];\nlet stringEscapeStartJumpTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 8, 0, 7, 4, 15, 0, 5, 0, 0, 0, 0, 0, 0];\nfunction getTokenStart(c) {\nlet s = tokenStartJumpTable[c];\nreturn s;\n}\nfunction getStringPart(c) {\nif (c > 0x7e) return 3;\nlet s = stringScanTable[c];\nreturn s;\n}\nfunction getIdentPart(c) {\nif (c > 0x7e) return 3;\nlet s = identScanTable[c];\nreturn s;\n}\nfunction getHexValue(c) {\nif (c > 0x66) return 16;\nlet v = hexValueJumpTable[c];\nreturn v;\n}\nfunction T(type) {\nreturn ('T<' + toktypeToString(type)) + '>';\n}\n// </tokentype>\n\n// <lexerflags>\nlet __$flag_lf = 0;\nfunction L(flags) {\nlet bak = flags;\nlet s = [];\nif (!flags) {\ns.push('LF_NO_FLAGS');\n}\nif (flags & 8192) {\nflags ^= 8192;\ns.push('LF_STRICT_MODE');\n}\nif (flags & 4) {\nflags ^= 4;\ns.push('LF_FOR_REGEX');\n}\nif (flags & 2048) {\nflags ^= 2048;\ns.push('LF_IN_TEMPLATE');\n}\nif (flags & 8) {\nflags ^= 8;\ns.push('LF_IN_ASYNC');\n}\nif (flags & 128) {\nflags ^= 128;\ns.push('LF_IN_GENERATOR');\n}\nif (flags & 16) {\nflags ^= 16;\ns.push('LF_IN_CONSTRUCTOR');\n}\nif (flags & 64) {\nflags ^= 64;\ns.push('LF_IN_FUNC_ARGS');\n}\nif (flags & 256) {\nflags ^= 256;\ns.push('LF_IN_GLOBAL');\n}\nif (flags & 512) {\nflags ^= 512;\ns.push('LF_IN_ITERATION');\n}\nif (flags & 1024) {\nflags ^= 1024;\ns.push('LF_IN_SWITCH');\n}\nif (flags & 2) {\nflags ^= 2;\ns.push('LF_CAN_NEW_DOT_TARGET');\n}\nif (flags & 32) {\nflags ^= 32;\ns.push('LF_IN_FOR_LHS');\n}\nif (flags & 4096) {\nflags ^= 4096;\ns.push('LF_NO_ASI');\n}\nif (flags & 16384) {\nflags ^= 16384;\ns.push('LF_SUPER_CALL');\n}\nif (flags & 32768) {\nflags ^= 32768;\ns.push('LF_SUPER_PROP');\n}\nif (flags & 65536) {\nflags ^= 65536;\ns.push('LF_NOT_KEYWORD');\n}\nif (flags) {\nthrow new Error(((((('UNKNOWN_FLAGS: ' + flags.toString(2)) + ' (was: ') + bak.toString(2)) + '), so far: [') + s.join('|')) + ']');\n}\nreturn 'L:' + s.join('|');\n}\n// </lexerflags>\n\n// <enum_lexer>\nconst GOAL_MODULE = true;\nconst GOAL_SCRIPT = false;\nconst COLLECT_TOKENS_NONE = 0;\nconst COLLECT_TOKENS_SOLID = 1;\nconst COLLECT_TOKENS_ALL = 2;\nconst COLLECT_TOKENS_TYPES = 3;\nconst WEB_COMPAT_OFF = false;\nconst WEB_COMPAT_ON = true;\n// </enum_lexer>\n\n// <enum_parser>\nconst VERSION_EXPONENTIATION = 7;\nconst VERSION_WHATEVER = Infinity;\nfunction DEVONLY() {\nlet dev = false;\nreturn dev;\n}\nfunction copyPiggies(output, input) {\nreturn output | (input & 1984);\n}\nfunction P(f, arr) {\nif (f & 256) {\narr.push('PIGGY_BACK_WAS_CONSTRUCTOR');\nf ^= 256;\n}\nif (f & 512) {\narr.push('PIGGY_BACK_WAS_PROTO');\nf ^= 512;\n}\nif (f & 64) {\narr.push('PIGGY_BACK_SAW_AWAIT');\nf ^= 64;\n}\nif (f & 128) {\narr.push('PIGGY_BACK_SAW_YIELD');\nf ^= 128;\n}\nif (f & 1024) {\narr.push('PIGGY_BACK_WAS_ARROW');\nf ^= 1024;\n}\nreturn f;\n}\n// </enum_parser>\n\n// <lexer>\nconst TABLE_NONBIN_UNI_PROPS = ',General_Category,gc,Script,sc,Script_Extensions,scx,';\nconst TABLE_BIN_UNI_PROPS = ',ASCII,ASCII_Hex_Digit,AHex,Alphabetic,Alpha,Any,Assigned,Bidi_Control,Bidi_C,Bidi_Mirrored,Bidi_M,Case_Ignorable,CI,Cased,Changes_When_Casefolded,CWCF,Changes_When_Casemapped,CWCM,Changes_When_Lowercased,CWL,Changes_When_NFKC_Casefolded,CWKCF,Changes_When_Titlecased,CWT,Changes_When_Uppercased,CWU,Dash,Default_Ignorable_Code_Point,DI,Deprecated,Dep,Diacritic,Dia,Emoji,Emoji_Component,Emoji_Modifier,Emoji_Modifier_Base,Emoji_Presentation,Extended_Pictographic,Extender,Ext,Grapheme_Base,Gr_Base,Grapheme_Extend,Gr_Ext,Hex_Digit,Hex,IDS_Binary_Operator,IDSB,IDS_Trinary_Operator,IDST,ID_Continue,IDC,ID_Start,IDS,Ideographic,Ideo,Join_Control,Join_C,Logical_Order_Exception,LOE,Lowercase,Lower,Math,Noncharacter_Code_Point,NChar,Pattern_Syntax,Pat_Syn,Pattern_White_Space,Pat_WS,Quotation_Mark,QMark,Radical,Regional_Indicator,RI,Sentence_Terminal,STerm,Soft_Dotted,SD,Terminal_Punctuation,Term,Unified_Ideograph,UIdeo,Uppercase,Upper,Variation_Selector,VS,White_Space,space,XID_Continue,XIDC,XID_Start,XIDS,';\nconst TABLE_GEN_CAT_VALUES = ',Cased_Letter,LC,Close_Punctuation,Pe,Connector_Punctuation,Pc,Control,Cc,cntrl,Currency_Symbol,Sc,Dash_Punctuation,Pd,Decimal_Number,Nd,digit,Enclosing_Mark,Me,Final_Punctuation,Pf,Format,Cf,Initial_Punctuation,Pi,Letter,L,Letter_Number,Nl,Line_Separator,Zl,Lowercase_Letter,Ll,Mark,M,Combining_Mark,Math_Symbol,Sm,Modifier_Letter,Lm,Modifier_Symbol,Sk,Nonspacing_Mark,Mn,Number,N,Open_Punctuation,Ps,Other,C,Other_Letter,Lo,Other_Number,No,Other_Punctuation,Po,Other_Symbol,So,Paragraph_Separator,Zp,Private_Use,Co,Punctuation,P,punct,Separator,Z,Space_Separator,Zs,Spacing_Mark,Mc,Surrogate,Cs,Symbol,S,Titlecase_Letter,Lt,Unassigned,Cn,Uppercase_Letter,Lu,';\nconst TABLE_SCRIPT_VALUES = ',Adlam,Adlm,Ahom,Anatolian_Hieroglyphs,Hluw,Arabic,Arab,Armenian,Armn,Avestan,Avst,Balinese,Bali,Bamum,Bamu,Bassa_Vah,Bass,Batak,Batk,Bengali,Beng,Bhaiksuki,Bhks,Bopomofo,Bopo,Brahmi,Brah,Braille,Brai,Buginese,Bugi,Buhid,Buhd,Canadian_Aboriginal,Cans,Carian,Cari,Caucasian_Albanian,Aghb,Chakma,Cakm,Cham,Cherokee,Cher,Common,Zyyy,Coptic,Copt,Qaac,Cuneiform,Xsux,Cypriot,Cprt,Cyrillic,Cyrl,Deseret,Dsrt,Devanagari,Deva,Dogra,Dogr,Duployan,Dupl,Egyptian_Hieroglyphs,Egyp,Elbasan,Elba,Elymaic,Elym,Ethiopic,Ethi,Georgian,Geor,Glagolitic,Glag,Gothic,Goth,Grantha,Gran,Greek,Grek,Gujarati,Gujr,Gunjala_Gondi,Gong,Gurmukhi,Guru,Han,Hani,Hangul,Hang,Hanifi_Rohingya,Rohg,Hanunoo,Hano,Hatran,Hatr,Hebrew,Hebr,Hiragana,Hira,Imperial_Aramaic,Armi,Inherited,Zinh,Qaai,Inscriptional_Pahlavi,Phli,Inscriptional_Parthian,Prti,Javanese,Java,Kaithi,Kthi,Kannada,Knda,Katakana,Kana,Kayah_Li,Kali,Kharoshthi,Khar,Khmer,Khmr,Khojki,Khoj,Khudawadi,Sind,Lao,Laoo,Latin,Latn,Lepcha,Lepc,Limbu,Limb,Linear_A,Lina,Linear_B,Linb,Lisu,Lycian,Lyci,Lydian,Lydi,Mahajani,Mahj,Makasar,Maka,Malayalam,Mlym,Mandaic,Mand,Manichaean,Mani,Marchen,Marc,Medefaidrin,Medf,Masaram_Gondi,Gonm,Meetei_Mayek,Mtei,Mende_Kikakui,Mend,Meroitic_Cursive,Merc,Meroitic_Hieroglyphs,Mero,Miao,Plrd,Modi,Mongolian,Mong,Mro,Mroo,Multani,Mult,Myanmar,Mymr,Nabataean,Nbat,Nandinagari,Nand,New_Tai_Lue,Talu,Newa,Nko,Nkoo,Nushu,Nshu,Nyiakeng_Puachue_Hmong,Hmnp,Ogham,Ogam,Ol_Chiki,Olck,Old_Hungarian,Hung,Old_Italic,Ital,Old_North_Arabian,Narb,Old_Permic,Perm,Old_Persian,Xpeo,Old_Sogdian,Sogo,Old_South_Arabian,Sarb,Old_Turkic,Orkh,Oriya,Orya,Osage,Osge,Osmanya,Osma,Pahawh_Hmong,Hmng,Palmyrene,Palm,Pau_Cin_Hau,Pauc,Phags_Pa,Phag,Phoenician,Phnx,Psalter_Pahlavi,Phlp,Rejang,Rjng,Runic,Runr,Samaritan,Samr,Saurashtra,Saur,Sharada,Shrd,Shavian,Shaw,Siddham,Sidd,SignWriting,Sgnw,Sinhala,Sinh,Sogdian,Sogd,Sora_Sompeng,Sora,Soyombo,Soyo,Sundanese,Sund,Syloti_Nagri,Sylo,Syriac,Syrc,Tagalog,Tglg,Tagbanwa,Tagb,Tai_Le,Tale,Tai_Tham,Lana,Tai_Viet,Tavt,Takri,Takr,Tamil,Taml,Tangut,Tang,Telugu,Telu,Thaana,Thaa,Thai,Tibetan,Tibt,Tifinagh,Tfng,Tirhuta,Tirh,Ugaritic,Ugar,Vai,Vaii,Wancho,Wcho,Warang_Citi,Wara,Yi,Yiii,Zanabazar_Square,Zanb,';\nlet ID_START_REGEX = undefined;\nfunction getIdStartRegexSuperSlow() {\nif (ID_START_REGEX) return ID_START_REGEX;\nreturn ID_START_REGEX = createUnicodeRegex('^\\\\p{ID_Start}$');\n}\nlet ID_CONTINUE_REGEX = undefined;\nfunction getIdRestRegexSuperSlow() {\nif (ID_CONTINUE_REGEX) return ID_CONTINUE_REGEX;\nreturn ID_CONTINUE_REGEX = createUnicodeRegex('^\\\\p{ID_Continue}$');\n}\nfunction createUnicodeRegex(pattern) {\ntry {\nreturn new RegExp(pattern, 'u');\n} catch (e) {\nconsole.warn(('Tenko: Current nodejs version does not suppport unicode regexes or regex property escapes; Input contains unicode that requires it so Tenko is unable to properly parse input (' + e.message) + ')');\nreturn /|/;\n}\n}\nfunction Lexer(input, options) {\nconst {targetEsVersion = Infinity, parsingGoal = true, collectTokens = 0, returnTokens = 3, webCompat = true, gracefulErrors = false, tokenStorageExternal, babelTokenCompat = false, errorCodeFrame = true, truncCodeFrame = false, $log = console.log, $warn = console.warn, $error = console.error} = options;\nconst tokenStorage = (tokenStorageExternal || (((collectTokens !== 0)? [] : undefined)));\nconst supportRegexPropertyEscapes = ((targetEsVersion >= 9) || (targetEsVersion === Infinity));\nconst supportRegexLookbehinds = ((targetEsVersion >= 9) || (targetEsVersion === Infinity));\nconst supportRegexDotallFlag = ((targetEsVersion >= 9) || (targetEsVersion === Infinity));\nconst supportRegexNamedGroups = ((targetEsVersion >= 9) || (targetEsVersion === Infinity));\nconst supportBigInt = ((targetEsVersion === 11) || (targetEsVersion === Infinity));\nconst supportNullishCoalescing = ((targetEsVersion === 11) || (targetEsVersion === Infinity));\nconst supportOptionalChaining = ((targetEsVersion === 11) || (targetEsVersion === Infinity));\nlet pointer = 0;\nlet len = input.length;\nlet consumedNewlinesBeforeSolid = false;\nlet nlwas = false;\nlet finished = false;\nlet lastOffset = pointer;\nlet startForError = 0;\nlet lastType = 0;\nlet lastStart = 0;\nlet lastStop = 0;\nlet lastLine = 0;\nlet lastColumn = 0;\nlet lastCanonizedInput = '';\nlet lastCanonizedInputLen = 0;\nlet lastPotentialRegexError = '';\nlet lastReportableLexerError = '';\nlet currentLine = 1;\nlet currentColOffset = 0;\nlet prevTokenEndColumn = 0;\nlet prevTokenEndLine = 0;\nlet prevTokenEndPointer = 0;\nlet prevTokenSolid = true;\nlet stale = false;\nlet cache = input.charCodeAt(0);\nlet anyTokenCount = 0;\nlet solidTokenCount = 0;\nfunction peek() {\nreturn cache;\n}\nfunction _readCache() {\nreturn cache;\n}\nfunction peekd(delta) {\nreturn input.charCodeAt(pointer + delta);\n}\nfunction peeky(ord) {\nreturn cache === ord;\n}\nfunction slice(from, to) {\nreturn input.slice(from, to);\n}\nfunction skipPeek() {\nreturn cache = input.charCodeAt(++pointer);\n}\nfunction skip() {\nlet p = ++pointer;\nif (pointer >= len) {\ncache = 0;\nreturn;\n}\ncache = input.charCodeAt(p);\n}\nfunction skipFastWithoutUpdatingCache() {\n++pointer;\n}\nfunction eof() {\nreturn pointer >= len;\n}\nfunction eofd(d) {\nreturn pointer >= (len - d);\n}\nfunction neof() {\nreturn pointer < len;\n}\nfunction neofd(d) {\nreturn pointer <= (len - d);\n}\nfunction nextToken(lexerFlags) {\nif (prevTokenSolid) {\nprevTokenEndColumn = pointer - currentColOffset;\nprevTokenEndLine = currentLine;\nprevTokenEndPointer = pointer;\nprevTokenSolid = false;\n}\nlastPotentialRegexError = '';\nlastReportableLexerError = '';\ndo {\n++anyTokenCount;\nlet startCol = pointer - currentColOffset;\nlet startRow = currentLine;\nlastCanonizedInput = '';\nlastCanonizedInputLen = 0;\nnlwas = consumedNewlinesBeforeSolid;\nif (pointer >= len) {\ncreateToken(2097173, pointer, pointer, startCol, startRow);\nfinished = true;\nreturn returnSolidToken(2097173, pointer, pointer, startCol, startRow);\n}\nlet start = startForError = pointer;\nlet consumedTokenType = jumpTableLexer(lexerFlags);\nif (!isWhiteToken(consumedTokenType)) {\ncreateToken(consumedTokenType, start, pointer, startCol, startRow);\nreturn returnSolidToken(consumedTokenType, start, pointer, startCol, startRow);\n}\nif (isCommentToken(consumedTokenType)) {\nif (returnTokens === 2) {\ncreateToken(consumedTokenType, start, pointer, startCol, startRow);\nreturn returnCommentToken(consumedTokenType, start, pointer, startCol, startRow);\n}\n}\nif (((collectTokens === 2) || (collectTokens === 3))) {\ncreateToken(consumedTokenType, start, pointer, startCol, startRow);\ntokenStorage.push(((collectTokens === 3)? consumedTokenType : createBaseToken(consumedTokenType, start, pointer, startCol, startRow, false)));\n}\nif (returnTokens === 1) {\nreturn createToken(consumedTokenType, start, pointer, startCol, startRow);\n}\nif (consumedTokenType === 1285) {\nif (((collectTokens !== 2) && (collectTokens !== 3))) skipNewlinesWithoutTokens();\n}\nif (nlwas === true) {\nif (((collectTokens !== 2) && (collectTokens !== 3))) skipSpacesWithoutTokens();\n}\n} while (true);\n}\nfunction returnCommentToken(consumedTokenType, start, pointer, startCol, startRow) {\nif (((collectTokens === 2) || (collectTokens === 3))) {\ntokenStorage.push(((collectTokens === 3)? consumedTokenType : createBaseToken(consumedTokenType, start, pointer, startCol, startRow, false)));\n}\n}\nfunction returnSolidToken(consumedTokenType, start, pointer, startCol, startRow) {\n++solidTokenCount;\nif (collectTokens !== 0) {\ntokenStorage.push(((collectTokens === 3)? consumedTokenType : createBaseToken(consumedTokenType, start, pointer, startCol, startRow, consumedNewlinesBeforeSolid)));\n}\nconsumedNewlinesBeforeSolid = false;\nprevTokenSolid = true;\n}\nfunction skipSpacesWithoutTokens() {\nwhile (pointer < len) {\nlet c = cache;\nif (((c !== 0x20) && (c !== 0x09))) return;\nskip();\n}\n}\nfunction skipNewlinesWithoutTokens() {\nwhile (pointer < len) {\nlet c = cache;\nif (c === 0x0A) {\nskip();\nincrementLine();\n} else if (c === 0x0D) {\nskip();\nparseCR();\n} else {\nreturn;\n}\n}\n}\nfunction jumpTableLexer(lexerFlags) {\nlet c = cache;\nskip();\nif (c > 0x7e) {\nreturn parseOtherUnicode(c);\n}\nlet s = getTokenStart(c);\nif (s > MAX_START_VALUE) {\nreturn s;\n}\nswitch (s) {\ncase 1:\nreturn parseSpace();\ncase 2:\nreturn parseIdentifierRest(String.fromCharCode(c), 1);\ncase 3:\nif ((lexerFlags & 65536) === 65536) return parseIdentifierRest(String.fromCharCode(c), 1);\nreturn parsePotentialKeywordTrieMap(c);\ncase 4:\nreturn parseNewlineSolo();\ncase 5:\nreturn parseCR();\ncase 6:\nreturn parseAnyString(c, lexerFlags);\ncase 7:\nreturn parseDecimal();\ncase 8:\nreturn parseLeadingDot();\ncase 9:\nif ((lexerFlags & 2048) === 2048) return parseTemplateString(lexerFlags, false);\nreturn 16517;\ncase 10:\nreturn parseEqual();\ncase 11:\nreturn parseFwdSlash(lexerFlags);\ncase 12:\nreturn parseSameOrCompound(0x2b);\ncase 13:\nreturn parseDash();\ncase 14:\nreturn parseLeadingZero(lexerFlags);\ncase 15:\nreturn parseTemplateString(lexerFlags, true);\ncase 16:\nreturn parseExcl();\ncase 17:\nreturn parseCompoundAssignment(0x25);\ncase 18:\nreturn parseSameOrCompound(0x26);\ncase 19:\nreturn parseStar();\ncase 20:\nreturn parseCompoundAssignment(0x5e);\ncase 21:\nreturn parseLt();\ncase 22:\nreturn parseGtPunctuator();\ncase 23:\nreturn parseSameOrCompound(0x7c);\ncase 24:\nreturn parseBackslash();\ncase 25:\nreturn parseQmark();\n}\nTHROW('Unknown input', pointer - 1, pointer);\n}\nfunction incrementLine() {\nconsumedNewlinesBeforeSolid = true;\n++currentLine;\ncurrentColOffset = pointer;\n}\nfunction addAsi() {\nif (collectTokens !== 0) {\ntokenStorage.push(((collectTokens === 3)? 2097174 : createBaseToken(2097174, pointer, pointer, pointer - currentColOffset, currentLine, false)), tokenStorage.pop());\n}\n++anyTokenCount;\n++solidTokenCount;\nprevTokenSolid = true;\n}\nfunction createToken(type, start, stop, column, line) {\nlastType = type;\nlastStart = start;\nlastStop = stop;\nlastLine = line;\nlastColumn = column;\n}\nfunction createBaseToken(type, start, stop, column, line, nl) {\nif (babelTokenCompat) {\nreturn {type, start, stop, loc:{start:{line:line, column:column}, end:{line:currentLine, column:currentColOffset}}, column, line};\n}\nreturn {type, start, stop, column, line, nl};\n}\nfunction parseLeadingDot() {\nif (pointer >= len) return 16485;\nlet c = cache;\nif (c === 0x2e) {\nreturn parseTripleDot();\n}\nif (isAsciiNumber(c)) {\nreturn parseNumberFromDot(c);\n}\nreturn 16485;\n}\nfunction parseTripleDot() {\nif (peekd(1) === 0x2e) {\nskip();\nskip();\nreturn 16486;\n}\nreturn 16486;\n}\nfunction parseNumberFromDot(c) {\nskip();\nif (pointer < len) {\nlet d = skipDigits();\nparseExponentMaybe(d);\n}\nverifyCharAfterNumber();\nreturn 4105;\n}\nfunction parseSpace() {\nreturn 257;\n}\nfunction parseCR() {\nif ((pointer < len && (cache === 0x0A))) {\nskip();\nincrementLine();\nreturn 772;\n}\nincrementLine();\nreturn 771;\n}\nfunction parseAnyString(marker, lexerFlags) {\nlet pointerOffset = pointer;\nlet badEscape = false;\nlet hadNewline = false;\nwhile (pointer < len) {\nlet c = cache;\nlet s = getStringPart(c);\nif (s <= MAX_START_VALUE) {\nswitch (s) {\ncase 0:\nskip();\nbreak;\ncase 1:\nskip();\nif (c === marker) {\nif (badEscape) {\nif (!lastReportableLexerError) lastReportableLexerError = 'String had an illegal escape';\nreturn 2097175;\n}\nif (hadNewline) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Encountered newline in string which is not allowed';\nreturn 2097175;\n}\nlastCanonizedInput += slice(pointerOffset, pointer - 1);\nlastCanonizedInputLen += (pointer - 1) - pointerOffset;\nreturn ((marker === 0x22)? 131088 : 131087);\n}\nbreak;\ncase 2:\nlastCanonizedInput += slice(pointerOffset, pointer);\nlastCanonizedInputLen += pointer - pointerOffset;\nbadEscape = ((parseStringOrTemplateEscape(lexerFlags, false) === true) || badEscape);\npointerOffset = pointer;\nbreak;\ncase 3:\nskip();\nif (((c <= 0x2029) && (c >= 0x2028))) {\nincrementLine();\n}\nbreak;\ncase 4:\nskip();\nhadNewline = true;\nbreak;\n;\n}\n}\n}\nif (!lastReportableLexerError) lastReportableLexerError = 'Unclosed string at EOF';\nreturn 2097175;\n}\nfunction parseStringOrTemplateEscape(lexerFlags, forTemplate) {\nskip();\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Backslash at end of input';\nreturn true;\n}\nlet c = cache;\nskip();\nlet s = ((c > 0x7e)? 6 : stringEscapeStartJumpTable[c]);\nswitch (s) {\ncase 0:\nlastCanonizedInput += String.fromCharCode(c);\n++lastCanonizedInputLen;\nreturn false;\ncase 1:\nlastCanonizedInput += '\\n';\n++lastCanonizedInputLen;\nreturn false;\ncase 2:\nlastCanonizedInput += '\\'';\n++lastCanonizedInputLen;\nreturn false;\ncase 3:\nlastCanonizedInput += '\"';\n++lastCanonizedInputLen;\nreturn false;\ncase 4:\n{\nif (pointer >= len) return true;\nlet r = parseUnicodeEscapeForNonRegex();\nif (r === 0x110000) return true;\nlastCanonizedInput += ((r > 0xffff)? String.fromCodePoint(r) : String.fromCharCode(r));\nlastCanonizedInputLen += ((r > 0xffff)? 2 : 1);\nreturn false;\n}\ncase 5:\nreturn parseStringEscapeHex();\ncase 6:\nif (((c === 0x2028) || (c === 0x2029))) {\nincrementLine();\nreturn false;\n}\nlastCanonizedInput += String.fromCharCode(c);\n++lastCanonizedInputLen;\nreturn false;\ncase 7:\nlastCanonizedInput += '\\t';\n++lastCanonizedInputLen;\nreturn false;\ncase 8:\nlastCanonizedInput += '\\r';\n++lastCanonizedInputLen;\nreturn false;\ncase 9:\nif ((pointer < len && (cache === 0x0A))) skip();\nincrementLine();\nreturn false;\ncase 10:\nincrementLine();\nreturn false;\ncase 11:\n\ncase 12:\nreturn parseStringEscapeOctalOrDigit(c, forTemplate, lexerFlags);\ncase 13:\nlastCanonizedInput += '\\b';\n++lastCanonizedInputLen;\nreturn false;\ncase 14:\nlastCanonizedInput += '\\f';\n++lastCanonizedInputLen;\nreturn false;\ncase 15:\nlastCanonizedInput += '\\v';\n++lastCanonizedInputLen;\nreturn false;\n;\n}\n}\nfunction skipZeroes() {\nlet c = cache;\nwhile (c === 0x30) {\nskip();\nif (pointer >= len) return 0;\nc = cache;\n}\nreturn c;\n}\nfunction parseStringEscapeHex() {\nif (eofd(1)) {\nif (pointer >= len) return false;\nif (!lastReportableLexerError) lastReportableLexerError = 'Not enough of input left to create valid hex escape';\nreturn true;\n}\nlet a = cache;\nlet b = peekd(1);\nlet va = getHexValue(a);\nlet vb = getHexValue(b);\nif ((va | vb) >= 16) {\nlastCanonizedInput += 'x';\n++lastCanonizedInputLen;\nif (!lastReportableLexerError) lastReportableLexerError = 'At least one of the two hex characters were not hex character (0-9a-f)';\nreturn true;\n}\nskip();\nskip();\nlastCanonizedInput += String.fromCharCode((va << 4) | vb);\n++lastCanonizedInputLen;\nreturn false;\n}\nfunction parseStringEscapeOctalOrDigit(a, forTemplate, lexerFlags) {\nif (((a === 0x38) || (a === 0x39))) {\nif (!lastReportableLexerError) lastReportableLexerError = 'The grammar does not allow to escape the 8 or the 9 character';\nreturn true;\n}\nif (pointer >= len) return false;\nlet b = cache;\nif (((((webCompat === false) || forTemplate)) || ((lexerFlags & 8192) === 8192))) {\nif (((a === 0x30) && (((b < 0x30) || (b > 0x39))))) {\nlastCanonizedInput += '\\0';\n++lastCanonizedInputLen;\nreturn false;\n}\nif (forTemplate) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Illegal legacy octal escape in template, where octal escapes are never allowed';\n} else if ((lexerFlags & 8192) === 8192) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Illegal legacy octal escape in strict mode';\n} else {\nif (!lastReportableLexerError) lastReportableLexerError = 'Octal escapes are only allowed in sloppy mode with web compat enabled';\n}\nreturn true;\n}\nif (((a === 0x30) && (((b < 0x30) || (b > 0x37))))) {\nlastCanonizedInput += '\\0';\n++lastCanonizedInputLen;\nreturn false;\n}\nif (((b < 0x30) || (b > 0x37))) {\nlastCanonizedInput += String.fromCharCode(parseInt(String.fromCharCode(a), 8));\n++lastCanonizedInputLen;\nreturn false;\n}\nskip();\nif (pointer >= len) return false;\nif (a > 0x33) {\nlastCanonizedInput += String.fromCharCode(parseInt(String.fromCharCode(a, b), 8));\n++lastCanonizedInputLen;\nreturn false;\n}\nlet c = cache;\nif (((c < 0x30) || (c > 0x37))) {\nlastCanonizedInput += String.fromCharCode(parseInt(String.fromCharCode(a, b), 8));\n++lastCanonizedInputLen;\nreturn false;\n}\nskip();\nlastCanonizedInput += String.fromCharCode(parseInt(String.fromCharCode(a, b, c), 8));\n++lastCanonizedInputLen;\nreturn false;\n}\nfunction parseDash() {\nif (((((((((parsingGoal === false) && (webCompat === true))) && (!eofd(1)))) && (cache === 0x2d))) && (peekd(1) === 0x3e))) {\nif (consumedNewlinesBeforeSolid === true) {\nreturn parseCommentHtmlClose();\n} else {\n\n}\n}\nreturn parseSameOrCompound(0x2d);\n}\nfunction parseSameOrCompound(c) {\nif (pointer < len) {\nlet d = cache;\nif (d === c) {\nskip();\nswitch (c) {\ncase 0x2b:\nreturn 16478;\ncase 0x2d:\nreturn 16482;\ncase 0x26:\nreturn 82005;\ncase 0x7c:\nreturn 82051;\n;\n}\n}\nif (d === 0x3d) {\nskip();\nswitch (c) {\ncase 0x2b:\nreturn 49247;\ncase 0x2d:\nreturn 49251;\ncase 0x26:\nreturn 49238;\ncase 0x7c:\nreturn 49284;\n;\n}\n}\n}\nswitch (c) {\ncase 0x2b:\nreturn 82013;\ncase 0x2d:\nreturn 82017;\ncase 0x26:\nreturn 82004;\ncase 0x7c:\nreturn 82050;\n;\n}\n}\nfunction parseTemplateString(lexerFlags, fromTick) {\nlastOffset = pointer;\nlet badEscapes = false;\nwhile (pointer < len) {\nlet c = cache;\nwhile (c === 0x24) {\nskip();\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Unclosed template string';\nlastCanonizedInput += slice(lastOffset, pointer);\nlastCanonizedInputLen += pointer - lastOffset;\nreturn 2097175;\n}\nc = cache;\nif (c === 0x7b) {\nlastCanonizedInput += slice(lastOffset, pointer - 1);\nlastCanonizedInputLen += (pointer - 1) - lastOffset;\nskip();\nreturn (badEscapes? ((fromTick? 1572881 : 1572882)) : ((fromTick? 524305 : 524306)));\n}\n}\nif (c === 0x60) {\nlastCanonizedInput += slice(lastOffset, pointer);\nlastCanonizedInputLen += pointer - lastOffset;\nskip();\nreturn (badEscapes? ((fromTick? 1572884 : 1572883)) : ((fromTick? 524308 : 524307)));\n}\nif (c === 0x0D) {\nskip();\nif ((pointer < len && (cache === 0x0A))) {\nskip();\n}\nincrementLine();\n} else if (isLfPsLs(c)) {\nskip();\nincrementLine();\n} else if (c === 0x5c) {\nlastCanonizedInput += slice(lastOffset, pointer);\nlastCanonizedInputLen += pointer - lastOffset;\nbadEscapes = ((parseStringOrTemplateEscape(lexerFlags, true) === true) || badEscapes);\nlastOffset = pointer;\n} else {\nskip();\n}\n}\nlastCanonizedInput += slice(lastOffset, pointer);\nlastCanonizedInputLen += pointer - lastOffset;\nif (!lastReportableLexerError) lastReportableLexerError = 'Unclosed template literal';\nreturn 2097175;\n}\nfunction verifyCharAfterNumber() {\nif (pointer >= len) return;\nlet c = cache;\nif (((isIdentStart(c, 0) !== (-1)) || (((c >= 0x30) && (c <= 0x39))))) {\nreturn THROW(('Found `' + String.fromCharCode(c)) + '`. It is not legal for an ident or number token to start after a number token without some form of separation', pointer, pointer);\n}\n}\nfunction parseLeadingZero(lexerFlags) {\nlet r = _parseLeadingZero(lexerFlags);\nif (r !== 2097175) verifyCharAfterNumber();\nreturn r;\n}\nfunction _parseLeadingZero(lexerFlags) {\nif (pointer >= len) return 4105;\nlet c = cache;\nif (isAsciiNumber(c)) {\nskip();\nif (pointer < len) skipDigits();\nif ((lexerFlags & 8192) === 8192) {\nif (!lastReportableLexerError) lastReportableLexerError = '\"Illegal\" octal escape in strict mode';\nreturn 2097175;\n}\nif (pointer < len) {\nlet e = cache;\nif (((e === 0x45) || (e === 0x65))) {\nif (!lastReportableLexerError) lastReportableLexerError = 'An exponent is not allowed after a legacy octal number and an ident after number must be separated by some whitespace so this is an error';\nreturn 2097175;\n}\nif (e === 0x6E) {\nif (!supportBigInt) {\nreturn THROW('BigInt suffix is not supported on legacy octals; use the `0o` prefix notation for that', startForError, pointer + 1);\n}\n}\n}\nreturn 4108;\n}\nif (c === 0x2e) {\nparseFromFractionDot();\nreturn 4105;\n}\nif (((c === 0x78) || (c === 0x58))) {\nskip();\nreturn parseHex();\n}\nif (((c === 0x6F) || (c === 0x4F))) {\nskip();\nreturn parseOctal();\n}\nif (((c === 0x62) || (c === 0x42))) {\nskip();\nreturn parseBinary();\n}\nif (((c === 0x65) || (c === 0x45))) {\nparseExponentMaybe(c);\nreturn 4105;\n}\nif (c === 0x6E) {\nif (!supportBigInt) {\nreturn THROW(('The BigInt syntax is supported in ES11+ / ES2020 (currently parsing ES' + targetEsVersion) + ')', startForError, pointer + 1);\n}\nskip();\nreturn 12297;\n}\nreturn 4105;\n}\nfunction parseDecimal() {\nif (pointer >= len) {\nreturn 4105;\n}\nlet c = skipDigits();\nif (pointer >= len) {\nreturn 4105;\n}\nif (c === 0x2e) {\nparseFromFractionDot();\nverifyCharAfterNumber();\nreturn 4105;\n}\nif (c === 0x6E) {\nif (!supportBigInt) {\nreturn THROW(('The BigInt syntax is supported in ES11+ / ES2020 (currently parsing ES' + targetEsVersion) + ')', startForError, pointer);\n}\nskip();\nverifyCharAfterNumber();\nreturn 12297;\n}\nparseExponentMaybe(c);\nverifyCharAfterNumber();\nreturn 4105;\n}\nfunction skipDigits() {\nlet c = cache;\nwhile (isAsciiNumber(c)) {\nskip();\nif (pointer >= len) return 0;\nc = cache;\n}\nreturn c;\n}\nfunction parseExponentMaybe(c) {\nif (((c !== 0x65) && (c !== 0x45))) return;\nif (eofd(1)) return;\nlet d = peekd(1);\nif (((d === 0x2d) || (d === 0x2b))) {\nif (eofd(2)) return;\nlet e = peekd(2);\nif (!isAsciiNumber(e)) return;\nskipFastWithoutUpdatingCache();\nskipFastWithoutUpdatingCache();\nskip();\nif (pointer >= len) return;\nskipDigits();\nreturn;\n}\nif (!isAsciiNumber(d)) return;\nskipFastWithoutUpdatingCache();\nskip();\nif (pointer >= len) return;\nskipDigits();\n}\nfunction parseFromFractionDot() {\nskip();\nif (pointer >= len) return;\nlet c = skipDigits();\nparseExponentMaybe(c);\n}\nfunction parseHex() {\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0x` is illegal without a digit';\nreturn 2097175;\n}\nlet c = cache;\nlet cv = getHexValue(c);\nif (cv === 16) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0x` is illegal without a digit';\nreturn 2097175;\n}\nskip();\ndo {\nif (pointer >= len) return 4104;\nc = cache;\ncv = getHexValue(c);\nif (cv === 16) {\nbreak;\n}\nskip();\n} while (true);\nif (c === 0x6E) {\nif (!supportBigInt) {\nreturn THROW(('The BigInt syntax is supported in ES11+ / ES2020 (currently parsing ES' + targetEsVersion) + ')', startForError, pointer + 1);\n}\nskip();\nreturn 12296;\n}\nreturn 4104;\n}\nfunction parseOctal() {\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0o` is illegal without a digit';\nreturn 2097175;\n}\nlet c = cache;\nif (!isOctal(c)) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0o` is illegal without a digit';\nreturn 2097175;\n}\nskip();\ndo {\nif (pointer >= len) return 4107;\nc = cache;\nif (!isOctal(c)) break;\nskip();\n} while (true);\nif (c === 0x6E) {\nif (!supportBigInt) {\nreturn THROW(('The BigInt syntax is supported in ES11+ / ES2020 (currently parsing ES' + targetEsVersion) + ')', startForError, pointer + 1);\n}\nskip();\nreturn 12299;\n}\nreturn 4107;\n}\nfunction parseBinary() {\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0b` is illegal without a digit';\nreturn 2097175;\n}\nlet c = cache;\nif (!isBinary(c)) {\nif (!lastReportableLexerError) lastReportableLexerError = '`0b` is illegal without a digit';\nreturn 2097175;\n}\nskip();\ndo {\nif (pointer >= len) return 4106;\nc = cache;\nif (!isBinary(c)) break;\nskip();\n} while (true);\nif (c === 0x6E) {\nif (!supportBigInt) {\nreturn THROW(('The BigInt syntax is supported in ES11+ / ES2020 (currently parsing ES' + targetEsVersion) + ')', startForError, pointer + 1);\n}\nskip();\nreturn 12297;\n}\nreturn 4106;\n}\nfunction isBinary(ord) {\nreturn ((ord === 0x30) || (ord === 0x31));\n}\nfunction parseExcl() {\nif (pointer >= len) return 16463;\nif ((cache === 0x3d)) {\nskip();\nif ((pointer < len && (cache === 0x3d))) {\nskip();\nreturn 82001;\n}\nreturn 82000;\n}\nreturn 16463;\n}\nfunction parseStar() {\nif (pointer < len) {\nlet c = cache;\nif (c === 0x2a) {\nskip();\nif ((pointer < len && (cache === 0x3d))) {\nskip();\nreturn 49244;\n}\nreturn 82010;\n} else if (c === 0x3d) {\nskip();\nreturn 49243;\n}\n}\nreturn 82009;\n}\nfunction parseIdentRestNotKeywordObjTrie(d, n, start) {\npointer = n - 1;\ncache = d;\nreturn parseIdentifierRest(slice(start, n - 1), (n - 1) - start);\n}\nfunction parsePotentialKeywordTrieMap(c) {\nlet trieObjlit = KEYWORD_TRIE_OBJLIT[c - 0x61];\nlet start = pointer - 1;\nlet n = start + 1;\ndo {\nif (n >= len) return eofAfterPotentialKeywordTrieMap(trieObjlit, n, start);\nlet d = input.charCodeAt(n++);\nif (((d < 0x61) || (d > 0x7a))) {\nreturn endOfPotentialKeywordTrieMap(trieObjlit, d, n, start);\n}\ntrieObjlit = trieObjlit[d - 0x61];\nif (trieObjlit === undefined) return parseIdentRestNotKeywordObjTrie(d, n, start);\n} while (true);\n}\nfunction endOfPotentialKeywordTrieMap(trieObjlit, d, n, start) {\nlet hit = trieObjlit.hit;\nif (d > 0x7e) {\npointer = n - 1;\ncache = d;\nlet wide = isIdentRestChr(d, n - 1);\nif (wide === (-1)) {\nlastCanonizedInputLen = (n - 1) - start;\nif (hit === undefined) {\nlastCanonizedInput = slice(start, n - 1);\nreturn 2048;\n}\nlet canon = trieObjlit.canon;\nlastCanonizedInput = canon;\nreturn hit;\n}\nreturn parseIdentifierRest(slice(start, n - 1), (n - 1) - start);\n}\nlet s = getTokenStart(d);\nif (((((s === 2) || (s === 7))) || (s === 14))) {\npointer = n - 1;\ncache = d;\nreturn parseIdentifierRest(slice(start, n - 1), (n - 1) - start);\n}\nif (s === 24) {\npointer = n - 1;\ncache = d;\nreturn parseIdentifierRest(slice(start, n - 1), (n - 1) - start);\n}\nif (hit !== undefined) {\npointer = n - 1;\ncache = d;\nlastCanonizedInputLen = (n - 1) - start;\nlet canon = trieObjlit.canon;\nlastCanonizedInput = canon;\nreturn hit;\n}\nlastCanonizedInput = slice(start, n - 1);\nlastCanonizedInputLen = (n - 1) - start;\npointer = n - 1;\ncache = d;\nreturn 2048;\n}\nfunction eofAfterPotentialKeywordTrieMap(trieObjlit, n, start) {\npointer = n - 1;\nskip();\nlastCanonizedInputLen = n - start;\nlet hit = trieObjlit.hit;\nif (hit !== undefined) {\nlet canon = trieObjlit.canon;\nlastCanonizedInput = canon;\nreturn hit;\n}\nlastCanonizedInput = slice(start, n);\nreturn 2048;\n}\nfunction parseIdentifierRest(prevStr, prevLen) {\nlet start = pointer;\nwhile (pointer < len) {\nlet c = cache;\nlet s = getIdentPart(c);\nswitch (s) {\ncase 0:\nskip();\nbreak;\ncase 1:\nlastCanonizedInput = prevStr + slice(start, pointer);\nlastCanonizedInputLen = prevLen + (pointer - start);\nreturn 2048;\ncase 2:\nlet x = prevStr + slice(start, pointer);\nlet xlen = prevLen + (pointer - start);\nskip();\nreturn parseIdentFromUnicodeEscape(false, x, xlen);\ncase 3:\nlet wide = isIdentRestChrUnicode(c, pointer);\nif (wide === (-1)) {\nlastCanonizedInput = prevStr + slice(start, pointer);\nlastCanonizedInputLen = prevLen + (pointer - start);\nreturn 2048;\n}\nif (wide === (-3)) {\nskipFastWithoutUpdatingCache();\n}\nskip();\nbreak;\n;\n}\n}\nlastCanonizedInput = prevStr + slice(start, pointer);\nlastCanonizedInputLen = prevLen + (pointer - start);\nreturn 2048;\n}\nfunction parseIdentFromUnicodeEscape(fromStart, prevStr, prevLen) {\nif (pointer >= len) {\nlastCanonizedInput = prevStr;\nlastCanonizedInputLen = prevLen;\nif (!lastReportableLexerError) lastReportableLexerError = 'Encountered a backslash at end of input';\nreturn 2097175;\n}\nif (!(cache === 0x75)) {\nreturn THROW('Only unicode escapes are supported in identifier escapes', startForError, pointer + 1);\n}\nskip();\nif (pointer >= len) {\nif (!lastReportableLexerError) lastReportableLexerError = 'Reached end of input before closing the current ident escape';\nreturn 2097175;\n}\nlet r = parseUnicodeEscapeForNonRegex();\nif (r === 0x110000) {\nparseIdentifierRest(prevStr, prevLen);\nlastCanonizedInput = prevStr;\nlastCanonizedInputLen = prevLen;\nif (!lastReportableLexerError) lastReportableLexerError = 'Only _unicode_ escapes are supported in identifiers';\nreturn 2097175;\n}\nif (r > 0xffff) {\nprevStr += String.fromCodePoint(r);\nprevLen += 2;\n} else {\nprevStr += String.fromCharCode(r);\n++prevLen;\n}\nif (((fromStart === true) && (isIdentStart(r, -1) !== (-1)))) {\nreturn parseIdentifierRest(prevStr, prevLen);\n}\nif (((fromStart === false) && (isIdentRestChr(r, -1) !== (-1)))) {\nreturn parseIdentifierRest(prevStr, prevLen);\n}\nlastCanonizedInput = prevStr;\nlastCanonizedInputLen = prevLen;\nif (!lastReportableLexerError) lastReportableLexerError = 'Identifier escape did not yield a valid identifier character';\nreturn 2097175;\n}\nfunction toStringExpensive(c) {\nreturn String.fromCodePoi