diff --git a/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js b/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js new file mode 100644 index 0000000..ddfde4a --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js @@ -0,0 +1,308 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509014, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.readCodePoint = readCodePoint; +exports.readInt = readInt; +exports.readStringContents = readStringContents; +var _isDigit = function isDigit(code) { + return code >= 48 && code <= 57; +}; +const forbiddenNumericSeparatorSiblings = { + decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]), + hex: new Set([46, 88, 95, 120]) +}; +const isAllowedNumericSeparatorSibling = { + bin: ch => ch === 48 || ch === 49, + oct: ch => ch >= 48 && ch <= 55, + dec: ch => ch >= 48 && ch <= 57, + hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102 +}; +function readStringContents(type, input, pos, lineStart, curLine, errors) { + const initialPos = pos; + const initialLineStart = lineStart; + const initialCurLine = curLine; + let out = ""; + let firstInvalidLoc = null; + let chunkStart = pos; + const { + length + } = input; + for (;;) { + if (pos >= length) { + errors.unterminated(initialPos, initialLineStart, initialCurLine); + out += input.slice(chunkStart, pos); + break; + } + const ch = input.charCodeAt(pos); + if (isStringEnd(type, ch, input, pos)) { + out += input.slice(chunkStart, pos); + break; + } + if (ch === 92) { + out += input.slice(chunkStart, pos); + const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors); + if (res.ch === null && !firstInvalidLoc) { + firstInvalidLoc = { + pos, + lineStart, + curLine + }; + } else { + out += res.ch; + } + ({ + pos, + lineStart, + curLine + } = res); + chunkStart = pos; + } else if (ch === 8232 || ch === 8233) { + ++pos; + ++curLine; + lineStart = pos; + } else if (ch === 10 || ch === 13) { + if (type === "template") { + out += input.slice(chunkStart, pos) + "\n"; + ++pos; + if (ch === 13 && input.charCodeAt(pos) === 10) { + ++pos; + } + ++curLine; + chunkStart = lineStart = pos; + } else { + errors.unterminated(initialPos, initialLineStart, initialCurLine); + } + } else { + ++pos; + } + } + return { + pos, + str: out, + firstInvalidLoc, + lineStart, + curLine, + containsInvalid: !!firstInvalidLoc + }; +} +function isStringEnd(type, ch, input, pos) { + if (type === "template") { + return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123; + } + return ch === (type === "double" ? 34 : 39); +} +function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) { + const throwOnInvalid = !inTemplate; + pos++; + const res = ch => ({ + pos, + ch, + lineStart, + curLine + }); + const ch = input.charCodeAt(pos++); + switch (ch) { + case 110: + return res("\n"); + case 114: + return res("\r"); + case 120: + { + let code; + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors)); + return res(code === null ? null : String.fromCharCode(code)); + } + case 117: + { + let code; + ({ + code, + pos + } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors)); + return res(code === null ? null : String.fromCodePoint(code)); + } + case 116: + return res("\t"); + case 98: + return res("\b"); + case 118: + return res("\u000b"); + case 102: + return res("\f"); + case 13: + if (input.charCodeAt(pos) === 10) { + ++pos; + } + case 10: + lineStart = pos; + ++curLine; + case 8232: + case 8233: + return res(""); + case 56: + case 57: + if (inTemplate) { + return res(null); + } else { + errors.strictNumericEscape(pos - 1, lineStart, curLine); + } + default: + if (ch >= 48 && ch <= 55) { + const startPos = pos - 1; + const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2)); + let octalStr = match[0]; + let octal = parseInt(octalStr, 8); + if (octal > 255) { + octalStr = octalStr.slice(0, -1); + octal = parseInt(octalStr, 8); + } + pos += octalStr.length - 1; + const next = input.charCodeAt(pos); + if (octalStr !== "0" || next === 56 || next === 57) { + if (inTemplate) { + return res(null); + } else { + errors.strictNumericEscape(startPos, lineStart, curLine); + } + } + return res(String.fromCharCode(octal)); + } + return res(String.fromCharCode(ch)); + } +} +function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) { + const initialPos = pos; + let n; + ({ + n, + pos + } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid)); + if (n === null) { + if (throwOnInvalid) { + errors.invalidEscapeSequence(initialPos, lineStart, curLine); + } else { + pos = initialPos - 1; + } + } + return { + code: n, + pos + }; +} +function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) { + const start = pos; + const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct; + const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin; + let invalid = false; + let total = 0; + for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) { + const code = input.charCodeAt(pos); + let val; + if (code === 95 && allowNumSeparator !== "bail") { + const prev = input.charCodeAt(pos - 1); + const next = input.charCodeAt(pos + 1); + if (!allowNumSeparator) { + if (bailOnError) return { + n: null, + pos + }; + errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine); + } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) { + if (bailOnError) return { + n: null, + pos + }; + errors.unexpectedNumericSeparator(pos, lineStart, curLine); + } + ++pos; + continue; + } + if (code >= 97) { + val = code - 97 + 10; + } else if (code >= 65) { + val = code - 65 + 10; + } else if (_isDigit(code)) { + val = code - 48; + } else { + val = Infinity; + } + if (val >= radix) { + if (val <= 9 && bailOnError) { + return { + n: null, + pos + }; + } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) { + val = 0; + } else if (forceLen) { + val = 0; + invalid = true; + } else { + break; + } + } + ++pos; + total = total * radix + val; + } + if (pos === start || len != null && pos - start !== len || invalid) { + return { + n: null, + pos + }; + } + return { + n: total, + pos + }; +} +function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) { + const ch = input.charCodeAt(pos); + let code; + if (ch === 123) { + ++pos; + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors)); + ++pos; + if (code !== null && code > 0x10ffff) { + if (throwOnInvalid) { + errors.invalidCodePoint(pos, lineStart, curLine); + } else { + return { + code: null, + pos + }; + } + } + } else { + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors)); + } + return { + code, + pos + }; +} + +//# sourceMappingURL=index.js.map + +}, function(modId) {var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509014); +})() +//miniprogram-npm-outsideDeps=[] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js.map b/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js.map new file mode 100644 index 0000000..7adf785 --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/helper-string-parser/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.readCodePoint = readCodePoint;\nexports.readInt = readInt;\nexports.readStringContents = readStringContents;\nvar _isDigit = function isDigit(code) {\n return code >= 48 && code <= 57;\n};\nconst forbiddenNumericSeparatorSiblings = {\n decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),\n hex: new Set([46, 88, 95, 120])\n};\nconst isAllowedNumericSeparatorSibling = {\n bin: ch => ch === 48 || ch === 49,\n oct: ch => ch >= 48 && ch <= 55,\n dec: ch => ch >= 48 && ch <= 57,\n hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102\n};\nfunction readStringContents(type, input, pos, lineStart, curLine, errors) {\n const initialPos = pos;\n const initialLineStart = lineStart;\n const initialCurLine = curLine;\n let out = \"\";\n let firstInvalidLoc = null;\n let chunkStart = pos;\n const {\n length\n } = input;\n for (;;) {\n if (pos >= length) {\n errors.unterminated(initialPos, initialLineStart, initialCurLine);\n out += input.slice(chunkStart, pos);\n break;\n }\n const ch = input.charCodeAt(pos);\n if (isStringEnd(type, ch, input, pos)) {\n out += input.slice(chunkStart, pos);\n break;\n }\n if (ch === 92) {\n out += input.slice(chunkStart, pos);\n const res = readEscapedChar(input, pos, lineStart, curLine, type === \"template\", errors);\n if (res.ch === null && !firstInvalidLoc) {\n firstInvalidLoc = {\n pos,\n lineStart,\n curLine\n };\n } else {\n out += res.ch;\n }\n ({\n pos,\n lineStart,\n curLine\n } = res);\n chunkStart = pos;\n } else if (ch === 8232 || ch === 8233) {\n ++pos;\n ++curLine;\n lineStart = pos;\n } else if (ch === 10 || ch === 13) {\n if (type === \"template\") {\n out += input.slice(chunkStart, pos) + \"\\n\";\n ++pos;\n if (ch === 13 && input.charCodeAt(pos) === 10) {\n ++pos;\n }\n ++curLine;\n chunkStart = lineStart = pos;\n } else {\n errors.unterminated(initialPos, initialLineStart, initialCurLine);\n }\n } else {\n ++pos;\n }\n }\n return {\n pos,\n str: out,\n firstInvalidLoc,\n lineStart,\n curLine,\n containsInvalid: !!firstInvalidLoc\n };\n}\nfunction isStringEnd(type, ch, input, pos) {\n if (type === \"template\") {\n return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;\n }\n return ch === (type === \"double\" ? 34 : 39);\n}\nfunction readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {\n const throwOnInvalid = !inTemplate;\n pos++;\n const res = ch => ({\n pos,\n ch,\n lineStart,\n curLine\n });\n const ch = input.charCodeAt(pos++);\n switch (ch) {\n case 110:\n return res(\"\\n\");\n case 114:\n return res(\"\\r\");\n case 120:\n {\n let code;\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));\n return res(code === null ? null : String.fromCharCode(code));\n }\n case 117:\n {\n let code;\n ({\n code,\n pos\n } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));\n return res(code === null ? null : String.fromCodePoint(code));\n }\n case 116:\n return res(\"\\t\");\n case 98:\n return res(\"\\b\");\n case 118:\n return res(\"\\u000b\");\n case 102:\n return res(\"\\f\");\n case 13:\n if (input.charCodeAt(pos) === 10) {\n ++pos;\n }\n case 10:\n lineStart = pos;\n ++curLine;\n case 8232:\n case 8233:\n return res(\"\");\n case 56:\n case 57:\n if (inTemplate) {\n return res(null);\n } else {\n errors.strictNumericEscape(pos - 1, lineStart, curLine);\n }\n default:\n if (ch >= 48 && ch <= 55) {\n const startPos = pos - 1;\n const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));\n let octalStr = match[0];\n let octal = parseInt(octalStr, 8);\n if (octal > 255) {\n octalStr = octalStr.slice(0, -1);\n octal = parseInt(octalStr, 8);\n }\n pos += octalStr.length - 1;\n const next = input.charCodeAt(pos);\n if (octalStr !== \"0\" || next === 56 || next === 57) {\n if (inTemplate) {\n return res(null);\n } else {\n errors.strictNumericEscape(startPos, lineStart, curLine);\n }\n }\n return res(String.fromCharCode(octal));\n }\n return res(String.fromCharCode(ch));\n }\n}\nfunction readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {\n const initialPos = pos;\n let n;\n ({\n n,\n pos\n } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));\n if (n === null) {\n if (throwOnInvalid) {\n errors.invalidEscapeSequence(initialPos, lineStart, curLine);\n } else {\n pos = initialPos - 1;\n }\n }\n return {\n code: n,\n pos\n };\n}\nfunction readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {\n const start = pos;\n const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;\n const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;\n let invalid = false;\n let total = 0;\n for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n const code = input.charCodeAt(pos);\n let val;\n if (code === 95 && allowNumSeparator !== \"bail\") {\n const prev = input.charCodeAt(pos - 1);\n const next = input.charCodeAt(pos + 1);\n if (!allowNumSeparator) {\n if (bailOnError) return {\n n: null,\n pos\n };\n errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);\n } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {\n if (bailOnError) return {\n n: null,\n pos\n };\n errors.unexpectedNumericSeparator(pos, lineStart, curLine);\n }\n ++pos;\n continue;\n }\n if (code >= 97) {\n val = code - 97 + 10;\n } else if (code >= 65) {\n val = code - 65 + 10;\n } else if (_isDigit(code)) {\n val = code - 48;\n } else {\n val = Infinity;\n }\n if (val >= radix) {\n if (val <= 9 && bailOnError) {\n return {\n n: null,\n pos\n };\n } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {\n val = 0;\n } else if (forceLen) {\n val = 0;\n invalid = true;\n } else {\n break;\n }\n }\n ++pos;\n total = total * radix + val;\n }\n if (pos === start || len != null && pos - start !== len || invalid) {\n return {\n n: null,\n pos\n };\n }\n return {\n n: total,\n pos\n };\n}\nfunction readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {\n const ch = input.charCodeAt(pos);\n let code;\n if (ch === 123) {\n ++pos;\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, input.indexOf(\"}\", pos) - pos, true, throwOnInvalid, errors));\n ++pos;\n if (code !== null && code > 0x10ffff) {\n if (throwOnInvalid) {\n errors.invalidCodePoint(pos, lineStart, curLine);\n } else {\n return {\n code: null,\n pos\n };\n }\n }\n } else {\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));\n }\n return {\n code,\n pos\n };\n}\n\n//# sourceMappingURL=index.js.map\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js b/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js new file mode 100644 index 0000000..d4cf9ae --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js @@ -0,0 +1,181 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509015, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "isIdentifierChar", { + enumerable: true, + get: function () { + return _identifier.isIdentifierChar; + } +}); +Object.defineProperty(exports, "isIdentifierName", { + enumerable: true, + get: function () { + return _identifier.isIdentifierName; + } +}); +Object.defineProperty(exports, "isIdentifierStart", { + enumerable: true, + get: function () { + return _identifier.isIdentifierStart; + } +}); +Object.defineProperty(exports, "isKeyword", { + enumerable: true, + get: function () { + return _keyword.isKeyword; + } +}); +Object.defineProperty(exports, "isReservedWord", { + enumerable: true, + get: function () { + return _keyword.isReservedWord; + } +}); +Object.defineProperty(exports, "isStrictBindOnlyReservedWord", { + enumerable: true, + get: function () { + return _keyword.isStrictBindOnlyReservedWord; + } +}); +Object.defineProperty(exports, "isStrictBindReservedWord", { + enumerable: true, + get: function () { + return _keyword.isStrictBindReservedWord; + } +}); +Object.defineProperty(exports, "isStrictReservedWord", { + enumerable: true, + get: function () { + return _keyword.isStrictReservedWord; + } +}); +var _identifier = require("./identifier.js"); +var _keyword = require("./keyword.js"); + +//# sourceMappingURL=index.js.map + +}, function(modId) {var map = {"./identifier.js":1771034509016,"./keyword.js":1771034509017}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509016, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isIdentifierChar = isIdentifierChar; +exports.isIdentifierName = isIdentifierName; +exports.isIdentifierStart = isIdentifierStart; +let nonASCIIidentifierStartChars = "\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\u0560-\u0588\u05d0-\u05ea\u05ef-\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\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\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\u09fc\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\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\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-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\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-\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-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\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-\uab69\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"; +let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65"; +const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); +const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); +nonASCIIidentifierStartChars = nonASCIIidentifierChars = null; +const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489]; +const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; +function isInAstralSet(code, set) { + let pos = 0x10000; + for (let i = 0, length = set.length; i < length; i += 2) { + pos += set[i]; + if (pos > code) return false; + pos += set[i + 1]; + if (pos >= code) return true; + } + return false; +} +function isIdentifierStart(code) { + if (code < 65) return code === 36; + if (code <= 90) return true; + if (code < 97) return code === 95; + if (code <= 122) return true; + if (code <= 0xffff) { + return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); + } + return isInAstralSet(code, astralIdentifierStartCodes); +} +function isIdentifierChar(code) { + if (code < 48) return code === 36; + if (code < 58) return true; + if (code < 65) return false; + if (code <= 90) return true; + if (code < 97) return code === 95; + if (code <= 122) return true; + if (code <= 0xffff) { + return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); + } + return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes); +} +function isIdentifierName(name) { + let isFirst = true; + for (let i = 0; i < name.length; i++) { + let cp = name.charCodeAt(i); + if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) { + const trail = name.charCodeAt(++i); + if ((trail & 0xfc00) === 0xdc00) { + cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff); + } + } + if (isFirst) { + isFirst = false; + if (!isIdentifierStart(cp)) { + return false; + } + } else if (!isIdentifierChar(cp)) { + return false; + } + } + return !isFirst; +} + +//# sourceMappingURL=identifier.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509017, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isKeyword = isKeyword; +exports.isReservedWord = isReservedWord; +exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord; +exports.isStrictBindReservedWord = isStrictBindReservedWord; +exports.isStrictReservedWord = isStrictReservedWord; +const reservedWords = { + keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"], + strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"], + strictBind: ["eval", "arguments"] +}; +const keywords = new Set(reservedWords.keyword); +const reservedWordsStrictSet = new Set(reservedWords.strict); +const reservedWordsStrictBindSet = new Set(reservedWords.strictBind); +function isReservedWord(word, inModule) { + return inModule && word === "await" || word === "enum"; +} +function isStrictReservedWord(word, inModule) { + return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word); +} +function isStrictBindOnlyReservedWord(word) { + return reservedWordsStrictBindSet.has(word); +} +function isStrictBindReservedWord(word, inModule) { + return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word); +} +function isKeyword(word) { + return keywords.has(word); +} + +//# sourceMappingURL=keyword.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509015); +})() +//miniprogram-npm-outsideDeps=[] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js.map b/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js.map new file mode 100644 index 0000000..c9a45b3 --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/helper-validator-identifier/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js","identifier.js","keyword.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA,AENA;ADIA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nObject.defineProperty(exports, \"isIdentifierChar\", {\n enumerable: true,\n get: function () {\n return _identifier.isIdentifierChar;\n }\n});\nObject.defineProperty(exports, \"isIdentifierName\", {\n enumerable: true,\n get: function () {\n return _identifier.isIdentifierName;\n }\n});\nObject.defineProperty(exports, \"isIdentifierStart\", {\n enumerable: true,\n get: function () {\n return _identifier.isIdentifierStart;\n }\n});\nObject.defineProperty(exports, \"isKeyword\", {\n enumerable: true,\n get: function () {\n return _keyword.isKeyword;\n }\n});\nObject.defineProperty(exports, \"isReservedWord\", {\n enumerable: true,\n get: function () {\n return _keyword.isReservedWord;\n }\n});\nObject.defineProperty(exports, \"isStrictBindOnlyReservedWord\", {\n enumerable: true,\n get: function () {\n return _keyword.isStrictBindOnlyReservedWord;\n }\n});\nObject.defineProperty(exports, \"isStrictBindReservedWord\", {\n enumerable: true,\n get: function () {\n return _keyword.isStrictBindReservedWord;\n }\n});\nObject.defineProperty(exports, \"isStrictReservedWord\", {\n enumerable: true,\n get: function () {\n return _keyword.isStrictReservedWord;\n }\n});\nvar _identifier = require(\"./identifier.js\");\nvar _keyword = require(\"./keyword.js\");\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isIdentifierChar = isIdentifierChar;\nexports.isIdentifierName = isIdentifierName;\nexports.isIdentifierStart = isIdentifierStart;\nlet nonASCIIidentifierStartChars = \"\\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\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\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\\u0860-\\u086a\\u0870-\\u0887\\u0889-\\u088f\\u08a0-\\u08c9\\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\\u09fc\\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\\u0c5c\\u0c5d\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cdc-\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\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-\\u1711\\u171f-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4c\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c8a\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\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-\\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-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7dc\\ua7f1-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\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-\\uab69\\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\";\nlet nonASCIIidentifierChars = \"\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u0897-\\u089f\\u08ca-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3c\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0cf3\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ece\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1add\\u1ae0-\\u1aeb\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1dff\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\u30fb\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\\uff65\";\nconst nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nconst nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\nconst astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];\nconst astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];\nfunction isInAstralSet(code, set) {\n let pos = 0x10000;\n for (let i = 0, length = set.length; i < length; i += 2) {\n pos += set[i];\n if (pos > code) return false;\n pos += set[i + 1];\n if (pos >= code) return true;\n }\n return false;\n}\nfunction isIdentifierStart(code) {\n if (code < 65) return code === 36;\n if (code <= 90) return true;\n if (code < 97) return code === 95;\n if (code <= 122) return true;\n if (code <= 0xffff) {\n return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n }\n return isInAstralSet(code, astralIdentifierStartCodes);\n}\nfunction isIdentifierChar(code) {\n if (code < 48) return code === 36;\n if (code < 58) return true;\n if (code < 65) return false;\n if (code <= 90) return true;\n if (code < 97) return code === 95;\n if (code <= 122) return true;\n if (code <= 0xffff) {\n return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n }\n return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n}\nfunction isIdentifierName(name) {\n let isFirst = true;\n for (let i = 0; i < name.length; i++) {\n let cp = name.charCodeAt(i);\n if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {\n const trail = name.charCodeAt(++i);\n if ((trail & 0xfc00) === 0xdc00) {\n cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n }\n }\n if (isFirst) {\n isFirst = false;\n if (!isIdentifierStart(cp)) {\n return false;\n }\n } else if (!isIdentifierChar(cp)) {\n return false;\n }\n }\n return !isFirst;\n}\n\n//# sourceMappingURL=identifier.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isKeyword = isKeyword;\nexports.isReservedWord = isReservedWord;\nexports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;\nexports.isStrictBindReservedWord = isStrictBindReservedWord;\nexports.isStrictReservedWord = isStrictReservedWord;\nconst reservedWords = {\n keyword: [\"break\", \"case\", \"catch\", \"continue\", \"debugger\", \"default\", \"do\", \"else\", \"finally\", \"for\", \"function\", \"if\", \"return\", \"switch\", \"throw\", \"try\", \"var\", \"const\", \"while\", \"with\", \"new\", \"this\", \"super\", \"class\", \"extends\", \"export\", \"import\", \"null\", \"true\", \"false\", \"in\", \"instanceof\", \"typeof\", \"void\", \"delete\"],\n strict: [\"implements\", \"interface\", \"let\", \"package\", \"private\", \"protected\", \"public\", \"static\", \"yield\"],\n strictBind: [\"eval\", \"arguments\"]\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\nfunction isReservedWord(word, inModule) {\n return inModule && word === \"await\" || word === \"enum\";\n}\nfunction isStrictReservedWord(word, inModule) {\n return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\nfunction isStrictBindOnlyReservedWord(word) {\n return reservedWordsStrictBindSet.has(word);\n}\nfunction isStrictBindReservedWord(word, inModule) {\n return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);\n}\nfunction isKeyword(word) {\n return keywords.has(word);\n}\n\n//# sourceMappingURL=keyword.js.map\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/parser/index.js b/miniapp/miniprogram_npm/@babel/parser/index.js new file mode 100644 index 0000000..8db633e --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/parser/index.js @@ -0,0 +1,14595 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509018, function(require, module, exports) { + + +Object.defineProperty(exports, '__esModule', { + value: true +}); +function _objectWithoutPropertiesLoose(r, e) { + if (null == r) return {}; + var t = {}; + for (var n in r) if ({}.hasOwnProperty.call(r, n)) { + if (-1 !== e.indexOf(n)) continue; + t[n] = r[n]; + } + return t; +} +class Position { + constructor(line, col, index) { + this.line = void 0; + this.column = void 0; + this.index = void 0; + this.line = line; + this.column = col; + this.index = index; + } +} +class SourceLocation { + constructor(start, end) { + this.start = void 0; + this.end = void 0; + this.filename = void 0; + this.identifierName = void 0; + this.start = start; + this.end = end; + } +} +function createPositionWithColumnOffset(position, columnOffset) { + const { + line, + column, + index + } = position; + return new Position(line, column + columnOffset, index + columnOffset); +} +const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"; +var ModuleErrors = { + ImportMetaOutsideModule: { + message: `import.meta may appear only with 'sourceType: "module"'`, + code + }, + ImportOutsideModule: { + message: `'import' and 'export' may appear only with 'sourceType: "module"'`, + code + } +}; +const NodeDescriptions = { + ArrayPattern: "array destructuring pattern", + AssignmentExpression: "assignment expression", + AssignmentPattern: "assignment expression", + ArrowFunctionExpression: "arrow function expression", + ConditionalExpression: "conditional expression", + CatchClause: "catch clause", + ForOfStatement: "for-of statement", + ForInStatement: "for-in statement", + ForStatement: "for-loop", + FormalParameters: "function parameter list", + Identifier: "identifier", + ImportSpecifier: "import specifier", + ImportDefaultSpecifier: "import default specifier", + ImportNamespaceSpecifier: "import namespace specifier", + ObjectPattern: "object destructuring pattern", + ParenthesizedExpression: "parenthesized expression", + RestElement: "rest element", + UpdateExpression: { + true: "prefix operation", + false: "postfix operation" + }, + VariableDeclarator: "variable declaration", + YieldExpression: "yield expression" +}; +const toNodeDescription = node => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type]; +var StandardErrors = { + AccessorIsGenerator: ({ + kind + }) => `A ${kind}ter cannot be a generator.`, + ArgumentsInClass: "'arguments' is only allowed in functions and class methods.", + AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.", + AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.", + AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.", + AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.", + AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.", + AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.", + BadGetterArity: "A 'get' accessor must not have any formal parameters.", + BadSetterArity: "A 'set' accessor must have exactly one formal parameter.", + BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.", + ConstructorClassField: "Classes may not have a field named 'constructor'.", + ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.", + ConstructorIsAccessor: "Class constructor may not be an accessor.", + ConstructorIsAsync: "Constructor can't be an async function.", + ConstructorIsGenerator: "Constructor can't be a generator.", + DeclarationMissingInitializer: ({ + kind + }) => `Missing initializer in ${kind} declaration.`, + DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.", + DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.", + DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.", + DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?", + DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.", + DecoratorSemicolon: "Decorators must not be followed by a semicolon.", + DecoratorStaticBlock: "Decorators can't be used with a static block.", + DeferImportRequiresNamespace: 'Only `import defer * as x from "./module"` is valid.', + DeletePrivateField: "Deleting a private field is not allowed.", + DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.", + DuplicateConstructor: "Duplicate constructor in the same class.", + DuplicateDefaultExport: "Only one default export allowed per module.", + DuplicateExport: ({ + exportName + }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`, + DuplicateProto: "Redefinition of __proto__ property.", + DuplicateRegExpFlags: "Duplicate regular expression flag.", + ElementAfterRest: "Rest element must be last element.", + EscapedCharNotAnIdentifier: "Invalid Unicode escape.", + ExportBindingIsString: ({ + localName, + exportName + }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`, + ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.", + ForInOfLoopInitializer: ({ + type + }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`, + ForInUsing: "For-in loop may not start with 'using' declaration.", + ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.", + ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.", + GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.", + IllegalBreakContinue: ({ + type + }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`, + IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.", + IllegalReturn: "'return' outside of function.", + ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.", + ImportBindingIsString: ({ + importName + }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`, + ImportCallArity: `\`import()\` requires exactly one or two arguments.`, + ImportCallNotNewExpression: "Cannot use new with import(...).", + ImportCallSpreadArgument: "`...` is not allowed in `import()`.", + ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.", + ImportReflectionHasAssertion: "`import module x` cannot have assertions.", + ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.', + IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.", + InvalidBigIntLiteral: "Invalid BigIntLiteral.", + InvalidCodePoint: "Code point out of bounds.", + InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.", + InvalidCoverInitializedName: "Invalid shorthand property initializer.", + InvalidDecimal: "Invalid decimal.", + InvalidDigit: ({ + radix + }) => `Expected number in radix ${radix}.`, + InvalidEscapeSequence: "Bad character escape sequence.", + InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.", + InvalidEscapedReservedWord: ({ + reservedWord + }) => `Escape sequence in keyword ${reservedWord}.`, + InvalidIdentifier: ({ + identifierName + }) => `Invalid identifier ${identifierName}.`, + InvalidLhs: ({ + ancestor + }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`, + InvalidLhsBinding: ({ + ancestor + }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`, + InvalidLhsOptionalChaining: ({ + ancestor + }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`, + InvalidNumber: "Invalid number.", + InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.", + InvalidOrUnexpectedToken: ({ + unexpected + }) => `Unexpected character '${unexpected}'.`, + InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.", + InvalidPrivateFieldResolution: ({ + identifierName + }) => `Private name #${identifierName} is not defined.`, + InvalidPropertyBindingPattern: "Binding member expression.", + InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.", + InvalidRestAssignmentPattern: "Invalid rest operator's argument.", + LabelRedeclaration: ({ + labelName + }) => `Label '${labelName}' is already declared.`, + LetInLexicalBinding: "'let' is disallowed as a lexically bound name.", + LineTerminatorBeforeArrow: "No line break is allowed before '=>'.", + MalformedRegExpFlags: "Invalid regular expression flag.", + MissingClassName: "A class name is required.", + MissingEqInAssignment: "Only '=' operator can be used for specifying default value.", + MissingSemicolon: "Missing semicolon.", + MissingPlugin: ({ + missingPlugin + }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`, + MissingOneOfPlugins: ({ + missingPlugin + }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`, + MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.", + MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.", + ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.", + ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.", + ModuleAttributesWithDuplicateKeys: ({ + key + }) => `Duplicate key "${key}" is not allowed in module attributes.`, + ModuleExportNameHasLoneSurrogate: ({ + surrogateCharCode + }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`, + ModuleExportUndefined: ({ + localName + }) => `Export '${localName}' is not defined.`, + MultipleDefaultsInSwitch: "Multiple default clauses.", + NewlineAfterThrow: "Illegal newline after throw.", + NoCatchOrFinally: "Missing catch or finally clause.", + NumberIdentifier: "Identifier directly after number.", + NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.", + ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.", + OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.", + OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.", + OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.", + ParamDupe: "Argument name clash.", + PatternHasAccessor: "Object pattern can't contain getter or setter.", + PatternHasMethod: "Object pattern can't contain methods.", + PrivateInExpectedIn: ({ + identifierName + }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`, + PrivateNameRedeclaration: ({ + identifierName + }) => `Duplicate private name #${identifierName}.`, + RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", + RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", + RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.", + RecordNoProto: "'__proto__' is not allowed in Record expressions.", + RestTrailingComma: "Unexpected trailing comma after rest element.", + SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.", + SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.", + SourcePhaseImportRequiresDefault: 'Only `import source x from "./module"` is valid.', + StaticPrototype: "Classes may not have static property named prototype.", + SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?", + SuperPrivateField: "Private fields can't be accessed on super.", + TrailingDecorator: "Decorators must be attached to a class element.", + TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", + TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", + TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.", + UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.", + UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.', + UnexpectedDigitAfterHash: "Unexpected digit after hash token.", + UnexpectedImportExport: "'import' and 'export' may only appear at the top level.", + UnexpectedKeyword: ({ + keyword + }) => `Unexpected keyword '${keyword}'.`, + UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.", + UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.", + UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.", + UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.", + UnexpectedPrivateField: "Unexpected private name.", + UnexpectedReservedWord: ({ + reservedWord + }) => `Unexpected reserved word '${reservedWord}'.`, + UnexpectedSuper: "'super' is only allowed in object methods and classes.", + UnexpectedToken: ({ + expected, + unexpected + }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`, + UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.", + UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.", + UnexpectedVoidPattern: "Unexpected void binding.", + UnsupportedBind: "Binding should be performed on object property.", + UnsupportedDecoratorExport: "A decorated export must export a class declaration.", + UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.", + UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.", + UnsupportedMetaProperty: ({ + target, + onlyValidPropertyName + }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`, + UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.", + UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.", + UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).", + UnterminatedComment: "Unterminated comment.", + UnterminatedRegExp: "Unterminated regular expression.", + UnterminatedString: "Unterminated string constant.", + UnterminatedTemplate: "Unterminated template.", + UsingDeclarationExport: "Using declaration cannot be exported.", + UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.", + VarRedeclaration: ({ + identifierName + }) => `Identifier '${identifierName}' has already been declared.`, + VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.", + VoidPatternInitializer: "A void binding may not have an initializer.", + YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.", + YieldInParameter: "Yield expression is not allowed in formal parameters.", + YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.", + ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0." +}; +var StrictModeErrors = { + StrictDelete: "Deleting local variable in strict mode.", + StrictEvalArguments: ({ + referenceName + }) => `Assigning to '${referenceName}' in strict mode.`, + StrictEvalArgumentsBinding: ({ + bindingName + }) => `Binding '${bindingName}' in strict mode.`, + StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.", + StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.", + StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.", + StrictWith: "'with' in strict mode." +}; +var ParseExpressionErrors = { + ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.", + ParseExpressionExpectsEOF: ({ + unexpected + }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.` +}; +const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]); +var PipelineOperatorErrors = Object.assign({ + PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.", + PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.', + PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.", + PipeTopicUnconfiguredToken: ({ + token + }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`, + PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.", + PipeUnparenthesizedBody: ({ + type + }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ + type + })}; please wrap it in parentheses.` +}, { + PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.', + PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.", + PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.", + PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.", + PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.", + PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.' +}); +const _excluded = ["message"]; +function defineHidden(obj, key, value) { + Object.defineProperty(obj, key, { + enumerable: false, + configurable: true, + value + }); +} +function toParseErrorConstructor({ + toMessage, + code, + reasonCode, + syntaxPlugin +}) { + const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins"; + const oldReasonCodes = { + AccessorCannotDeclareThisParameter: "AccesorCannotDeclareThisParameter", + AccessorCannotHaveTypeParameters: "AccesorCannotHaveTypeParameters", + ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference", + SetAccessorCannotHaveOptionalParameter: "SetAccesorCannotHaveOptionalParameter", + SetAccessorCannotHaveRestParameter: "SetAccesorCannotHaveRestParameter", + SetAccessorCannotHaveReturnType: "SetAccesorCannotHaveReturnType" + }; + if (oldReasonCodes[reasonCode]) { + reasonCode = oldReasonCodes[reasonCode]; + } + return function constructor(loc, details) { + const error = new SyntaxError(); + error.code = code; + error.reasonCode = reasonCode; + error.loc = loc; + error.pos = loc.index; + error.syntaxPlugin = syntaxPlugin; + if (hasMissingPlugin) { + error.missingPlugin = details.missingPlugin; + } + defineHidden(error, "clone", function clone(overrides = {}) { + var _overrides$loc; + const { + line, + column, + index + } = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc; + return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details)); + }); + defineHidden(error, "details", details); + Object.defineProperty(error, "message", { + configurable: true, + get() { + const message = `${toMessage(details)} (${loc.line}:${loc.column})`; + this.message = message; + return message; + }, + set(value) { + Object.defineProperty(this, "message", { + value, + writable: true + }); + } + }); + return error; + }; +} +function ParseErrorEnum(argument, syntaxPlugin) { + if (Array.isArray(argument)) { + return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]); + } + const ParseErrorConstructors = {}; + for (const reasonCode of Object.keys(argument)) { + const template = argument[reasonCode]; + const _ref = typeof template === "string" ? { + message: () => template + } : typeof template === "function" ? { + message: template + } : template, + { + message + } = _ref, + rest = _objectWithoutPropertiesLoose(_ref, _excluded); + const toMessage = typeof message === "string" ? () => message : message; + ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({ + code: "BABEL_PARSER_SYNTAX_ERROR", + reasonCode, + toMessage + }, syntaxPlugin ? { + syntaxPlugin + } : {}, rest)); + } + return ParseErrorConstructors; +} +const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors)); +function createDefaultOptions() { + return { + sourceType: "script", + sourceFilename: undefined, + startIndex: 0, + startColumn: 0, + startLine: 1, + allowAwaitOutsideFunction: false, + allowReturnOutsideFunction: false, + allowNewTargetOutsideFunction: false, + allowImportExportEverywhere: false, + allowSuperOutsideMethod: false, + allowUndeclaredExports: false, + allowYieldOutsideFunction: false, + plugins: [], + strictMode: undefined, + ranges: false, + tokens: false, + createImportExpressions: false, + createParenthesizedExpressions: false, + errorRecovery: false, + attachComment: true, + annexB: true + }; +} +function getOptions(opts) { + const options = createDefaultOptions(); + if (opts == null) { + return options; + } + if (opts.annexB != null && opts.annexB !== false) { + throw new Error("The `annexB` option can only be set to `false`."); + } + for (const key of Object.keys(options)) { + if (opts[key] != null) options[key] = opts[key]; + } + if (options.startLine === 1) { + if (opts.startIndex == null && options.startColumn > 0) { + options.startIndex = options.startColumn; + } else if (opts.startColumn == null && options.startIndex > 0) { + options.startColumn = options.startIndex; + } + } else if (opts.startColumn == null || opts.startIndex == null) { + if (opts.startIndex != null) { + throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`."); + } + } + if (options.sourceType === "commonjs") { + if (opts.allowAwaitOutsideFunction != null) { + throw new Error("The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`."); + } + if (opts.allowReturnOutsideFunction != null) { + throw new Error("`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`."); + } + if (opts.allowNewTargetOutsideFunction != null) { + throw new Error("`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`."); + } + } + return options; +} +const { + defineProperty +} = Object; +const toUnenumerable = (object, key) => { + if (object) { + defineProperty(object, key, { + enumerable: false, + value: object[key] + }); + } +}; +function toESTreeLocation(node) { + toUnenumerable(node.loc.start, "index"); + toUnenumerable(node.loc.end, "index"); + return node; +} +var estree = superClass => class ESTreeParserMixin extends superClass { + parse() { + const file = toESTreeLocation(super.parse()); + if (this.optionFlags & 256) { + file.tokens = file.tokens.map(toESTreeLocation); + } + return file; + } + parseRegExpLiteral({ + pattern, + flags + }) { + let regex = null; + try { + regex = new RegExp(pattern, flags); + } catch (_) {} + const node = this.estreeParseLiteral(regex); + node.regex = { + pattern, + flags + }; + return node; + } + parseBigIntLiteral(value) { + let bigInt; + try { + bigInt = BigInt(value); + } catch (_unused) { + bigInt = null; + } + const node = this.estreeParseLiteral(bigInt); + node.bigint = String(node.value || value); + return node; + } + parseDecimalLiteral(value) { + const decimal = null; + const node = this.estreeParseLiteral(decimal); + node.decimal = String(node.value || value); + return node; + } + estreeParseLiteral(value) { + return this.parseLiteral(value, "Literal"); + } + parseStringLiteral(value) { + return this.estreeParseLiteral(value); + } + parseNumericLiteral(value) { + return this.estreeParseLiteral(value); + } + parseNullLiteral() { + return this.estreeParseLiteral(null); + } + parseBooleanLiteral(value) { + return this.estreeParseLiteral(value); + } + estreeParseChainExpression(node, endLoc) { + const chain = this.startNodeAtNode(node); + chain.expression = node; + return this.finishNodeAt(chain, "ChainExpression", endLoc); + } + directiveToStmt(directive) { + const expression = directive.value; + delete directive.value; + this.castNodeTo(expression, "Literal"); + expression.raw = expression.extra.raw; + expression.value = expression.extra.expressionValue; + const stmt = this.castNodeTo(directive, "ExpressionStatement"); + stmt.expression = expression; + stmt.directive = expression.extra.rawValue; + delete expression.extra; + return stmt; + } + fillOptionalPropertiesForTSESLint(node) {} + cloneEstreeStringLiteral(node) { + const { + start, + end, + loc, + range, + raw, + value + } = node; + const cloned = Object.create(node.constructor.prototype); + cloned.type = "Literal"; + cloned.start = start; + cloned.end = end; + cloned.loc = loc; + cloned.range = range; + cloned.raw = raw; + cloned.value = value; + return cloned; + } + initFunction(node, isAsync) { + super.initFunction(node, isAsync); + node.expression = false; + } + checkDeclaration(node) { + if (node != null && this.isObjectProperty(node)) { + this.checkDeclaration(node.value); + } else { + super.checkDeclaration(node); + } + } + getObjectOrClassMethodParams(method) { + return method.value.params; + } + isValidDirective(stmt) { + var _stmt$expression$extr; + return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized); + } + parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) { + super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse); + const directiveStatements = node.directives.map(d => this.directiveToStmt(d)); + node.body = directiveStatements.concat(node.body); + delete node.directives; + } + parsePrivateName() { + const node = super.parsePrivateName(); + if (!this.getPluginOption("estree", "classFeatures")) { + return node; + } + return this.convertPrivateNameToPrivateIdentifier(node); + } + convertPrivateNameToPrivateIdentifier(node) { + const name = super.getPrivateNameSV(node); + delete node.id; + node.name = name; + return this.castNodeTo(node, "PrivateIdentifier"); + } + isPrivateName(node) { + if (!this.getPluginOption("estree", "classFeatures")) { + return super.isPrivateName(node); + } + return node.type === "PrivateIdentifier"; + } + getPrivateNameSV(node) { + if (!this.getPluginOption("estree", "classFeatures")) { + return super.getPrivateNameSV(node); + } + return node.name; + } + parseLiteral(value, type) { + const node = super.parseLiteral(value, type); + node.raw = node.extra.raw; + delete node.extra; + return node; + } + parseFunctionBody(node, allowExpression, isMethod = false) { + super.parseFunctionBody(node, allowExpression, isMethod); + node.expression = node.body.type !== "BlockStatement"; + } + parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { + let funcNode = this.startNode(); + funcNode.kind = node.kind; + funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope); + delete funcNode.kind; + const { + typeParameters + } = node; + if (typeParameters) { + delete node.typeParameters; + funcNode.typeParameters = typeParameters; + this.resetStartLocationFromNode(funcNode, typeParameters); + } + const valueNode = this.castNodeTo(funcNode, "FunctionExpression"); + node.value = valueNode; + if (type === "ClassPrivateMethod") { + node.computed = false; + } + if (type === "ObjectMethod") { + if (node.kind === "method") { + node.kind = "init"; + } + node.shorthand = false; + return this.finishNode(node, "Property"); + } else { + return this.finishNode(node, "MethodDefinition"); + } + } + nameIsConstructor(key) { + if (key.type === "Literal") return key.value === "constructor"; + return super.nameIsConstructor(key); + } + parseClassProperty(...args) { + const propertyNode = super.parseClassProperty(...args); + if (!this.getPluginOption("estree", "classFeatures")) { + return propertyNode; + } + this.castNodeTo(propertyNode, "PropertyDefinition"); + return propertyNode; + } + parseClassPrivateProperty(...args) { + const propertyNode = super.parseClassPrivateProperty(...args); + if (!this.getPluginOption("estree", "classFeatures")) { + return propertyNode; + } + this.castNodeTo(propertyNode, "PropertyDefinition"); + propertyNode.computed = false; + return propertyNode; + } + parseClassAccessorProperty(node) { + const accessorPropertyNode = super.parseClassAccessorProperty(node); + if (!this.getPluginOption("estree", "classFeatures")) { + return accessorPropertyNode; + } + if (accessorPropertyNode.abstract && this.hasPlugin("typescript")) { + delete accessorPropertyNode.abstract; + this.castNodeTo(accessorPropertyNode, "TSAbstractAccessorProperty"); + } else { + this.castNodeTo(accessorPropertyNode, "AccessorProperty"); + } + return accessorPropertyNode; + } + parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) { + const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors); + if (node) { + node.kind = "init"; + this.castNodeTo(node, "Property"); + } + return node; + } + finishObjectProperty(node) { + node.kind = "init"; + return this.finishNode(node, "Property"); + } + isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) { + return type === "Property" ? "value" : super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding); + } + isAssignable(node, isBinding) { + if (node != null && this.isObjectProperty(node)) { + return this.isAssignable(node.value, isBinding); + } + return super.isAssignable(node, isBinding); + } + toAssignable(node, isLHS = false) { + if (node != null && this.isObjectProperty(node)) { + const { + key, + value + } = node; + if (this.isPrivateName(key)) { + this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); + } + this.toAssignable(value, isLHS); + } else { + super.toAssignable(node, isLHS); + } + } + toAssignableObjectExpressionProp(prop, isLast, isLHS) { + if (prop.type === "Property" && (prop.kind === "get" || prop.kind === "set")) { + this.raise(Errors.PatternHasAccessor, prop.key); + } else if (prop.type === "Property" && prop.method) { + this.raise(Errors.PatternHasMethod, prop.key); + } else { + super.toAssignableObjectExpressionProp(prop, isLast, isLHS); + } + } + finishCallExpression(unfinished, optional) { + const node = super.finishCallExpression(unfinished, optional); + if (node.callee.type === "Import") { + var _ref, _ref2; + this.castNodeTo(node, "ImportExpression"); + node.source = node.arguments[0]; + node.options = (_ref = node.arguments[1]) != null ? _ref : null; + node.attributes = (_ref2 = node.arguments[1]) != null ? _ref2 : null; + delete node.arguments; + delete node.callee; + } else if (node.type === "OptionalCallExpression") { + this.castNodeTo(node, "CallExpression"); + } else { + node.optional = false; + } + return node; + } + toReferencedArguments(node) { + if (node.type === "ImportExpression") { + return; + } + super.toReferencedArguments(node); + } + parseExport(unfinished, decorators) { + const exportStartLoc = this.state.lastTokStartLoc; + const node = super.parseExport(unfinished, decorators); + switch (node.type) { + case "ExportAllDeclaration": + node.exported = null; + break; + case "ExportNamedDeclaration": + if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") { + this.castNodeTo(node, "ExportAllDeclaration"); + node.exported = node.specifiers[0].exported; + delete node.specifiers; + } + case "ExportDefaultDeclaration": + { + var _declaration$decorato; + const { + declaration + } = node; + if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) { + this.resetStartLocation(node, exportStartLoc); + } + } + break; + } + return node; + } + stopParseSubscript(base, state) { + const node = super.stopParseSubscript(base, state); + if (state.optionalChainMember) { + return this.estreeParseChainExpression(node, base.loc.end); + } + return node; + } + parseMember(base, startLoc, state, computed, optional) { + const node = super.parseMember(base, startLoc, state, computed, optional); + if (node.type === "OptionalMemberExpression") { + this.castNodeTo(node, "MemberExpression"); + } else { + node.optional = false; + } + return node; + } + isOptionalMemberExpression(node) { + if (node.type === "ChainExpression") { + return node.expression.type === "MemberExpression"; + } + return super.isOptionalMemberExpression(node); + } + hasPropertyAsPrivateName(node) { + if (node.type === "ChainExpression") { + node = node.expression; + } + return super.hasPropertyAsPrivateName(node); + } + isObjectProperty(node) { + return node.type === "Property" && node.kind === "init" && !node.method; + } + isObjectMethod(node) { + return node.type === "Property" && (node.method || node.kind === "get" || node.kind === "set"); + } + castNodeTo(node, type) { + const result = super.castNodeTo(node, type); + this.fillOptionalPropertiesForTSESLint(result); + return result; + } + cloneIdentifier(node) { + const cloned = super.cloneIdentifier(node); + this.fillOptionalPropertiesForTSESLint(cloned); + return cloned; + } + cloneStringLiteral(node) { + if (node.type === "Literal") { + return this.cloneEstreeStringLiteral(node); + } + return super.cloneStringLiteral(node); + } + finishNodeAt(node, type, endLoc) { + return toESTreeLocation(super.finishNodeAt(node, type, endLoc)); + } + finishNode(node, type) { + const result = super.finishNode(node, type); + this.fillOptionalPropertiesForTSESLint(result); + return result; + } + resetStartLocation(node, startLoc) { + super.resetStartLocation(node, startLoc); + toESTreeLocation(node); + } + resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { + super.resetEndLocation(node, endLoc); + toESTreeLocation(node); + } +}; +class TokContext { + constructor(token, preserveSpace) { + this.token = void 0; + this.preserveSpace = void 0; + this.token = token; + this.preserveSpace = !!preserveSpace; + } +} +const types = { + brace: new TokContext("{"), + j_oTag: new TokContext("...", true) +}; +types.template = new TokContext("`", true); +const beforeExpr = true; +const startsExpr = true; +const isLoop = true; +const isAssign = true; +const prefix = true; +const postfix = true; +class ExportedTokenType { + constructor(label, conf = {}) { + this.label = void 0; + this.keyword = void 0; + this.beforeExpr = void 0; + this.startsExpr = void 0; + this.rightAssociative = void 0; + this.isLoop = void 0; + this.isAssign = void 0; + this.prefix = void 0; + this.postfix = void 0; + this.binop = void 0; + this.label = label; + this.keyword = conf.keyword; + this.beforeExpr = !!conf.beforeExpr; + this.startsExpr = !!conf.startsExpr; + this.rightAssociative = !!conf.rightAssociative; + this.isLoop = !!conf.isLoop; + this.isAssign = !!conf.isAssign; + this.prefix = !!conf.prefix; + this.postfix = !!conf.postfix; + this.binop = conf.binop != null ? conf.binop : null; + this.updateContext = null; + } +} +const keywords$1 = new Map(); +function createKeyword(name, options = {}) { + options.keyword = name; + const token = createToken(name, options); + keywords$1.set(name, token); + return token; +} +function createBinop(name, binop) { + return createToken(name, { + beforeExpr, + binop + }); +} +let tokenTypeCounter = -1; +const tokenTypes = []; +const tokenLabels = []; +const tokenBinops = []; +const tokenBeforeExprs = []; +const tokenStartsExprs = []; +const tokenPrefixes = []; +function createToken(name, options = {}) { + var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix; + ++tokenTypeCounter; + tokenLabels.push(name); + tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1); + tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false); + tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false); + tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false); + tokenTypes.push(new ExportedTokenType(name, options)); + return tokenTypeCounter; +} +function createKeywordLike(name, options = {}) { + var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2; + ++tokenTypeCounter; + keywords$1.set(name, tokenTypeCounter); + tokenLabels.push(name); + tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1); + tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false); + tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false); + tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false); + tokenTypes.push(new ExportedTokenType("name", options)); + return tokenTypeCounter; +} +const tt = { + bracketL: createToken("[", { + beforeExpr, + startsExpr + }), + bracketHashL: createToken("#[", { + beforeExpr, + startsExpr + }), + bracketBarL: createToken("[|", { + beforeExpr, + startsExpr + }), + bracketR: createToken("]"), + bracketBarR: createToken("|]"), + braceL: createToken("{", { + beforeExpr, + startsExpr + }), + braceBarL: createToken("{|", { + beforeExpr, + startsExpr + }), + braceHashL: createToken("#{", { + beforeExpr, + startsExpr + }), + braceR: createToken("}"), + braceBarR: createToken("|}"), + parenL: createToken("(", { + beforeExpr, + startsExpr + }), + parenR: createToken(")"), + comma: createToken(",", { + beforeExpr + }), + semi: createToken(";", { + beforeExpr + }), + colon: createToken(":", { + beforeExpr + }), + doubleColon: createToken("::", { + beforeExpr + }), + dot: createToken("."), + question: createToken("?", { + beforeExpr + }), + questionDot: createToken("?."), + arrow: createToken("=>", { + beforeExpr + }), + template: createToken("template"), + ellipsis: createToken("...", { + beforeExpr + }), + backQuote: createToken("`", { + startsExpr + }), + dollarBraceL: createToken("${", { + beforeExpr, + startsExpr + }), + templateTail: createToken("...`", { + startsExpr + }), + templateNonTail: createToken("...${", { + beforeExpr, + startsExpr + }), + at: createToken("@"), + hash: createToken("#", { + startsExpr + }), + interpreterDirective: createToken("#!..."), + eq: createToken("=", { + beforeExpr, + isAssign + }), + assign: createToken("_=", { + beforeExpr, + isAssign + }), + slashAssign: createToken("_=", { + beforeExpr, + isAssign + }), + xorAssign: createToken("_=", { + beforeExpr, + isAssign + }), + moduloAssign: createToken("_=", { + beforeExpr, + isAssign + }), + incDec: createToken("++/--", { + prefix, + postfix, + startsExpr + }), + bang: createToken("!", { + beforeExpr, + prefix, + startsExpr + }), + tilde: createToken("~", { + beforeExpr, + prefix, + startsExpr + }), + doubleCaret: createToken("^^", { + startsExpr + }), + doubleAt: createToken("@@", { + startsExpr + }), + pipeline: createBinop("|>", 0), + nullishCoalescing: createBinop("??", 1), + logicalOR: createBinop("||", 1), + logicalAND: createBinop("&&", 2), + bitwiseOR: createBinop("|", 3), + bitwiseXOR: createBinop("^", 4), + bitwiseAND: createBinop("&", 5), + equality: createBinop("==/!=/===/!==", 6), + lt: createBinop("/<=/>=", 7), + gt: createBinop("/<=/>=", 7), + relational: createBinop("/<=/>=", 7), + bitShift: createBinop("<>/>>>", 8), + bitShiftL: createBinop("<>/>>>", 8), + bitShiftR: createBinop("<>/>>>", 8), + plusMin: createToken("+/-", { + beforeExpr, + binop: 9, + prefix, + startsExpr + }), + modulo: createToken("%", { + binop: 10, + startsExpr + }), + star: createToken("*", { + binop: 10 + }), + slash: createBinop("/", 10), + exponent: createToken("**", { + beforeExpr, + binop: 11, + rightAssociative: true + }), + _in: createKeyword("in", { + beforeExpr, + binop: 7 + }), + _instanceof: createKeyword("instanceof", { + beforeExpr, + binop: 7 + }), + _break: createKeyword("break"), + _case: createKeyword("case", { + beforeExpr + }), + _catch: createKeyword("catch"), + _continue: createKeyword("continue"), + _debugger: createKeyword("debugger"), + _default: createKeyword("default", { + beforeExpr + }), + _else: createKeyword("else", { + beforeExpr + }), + _finally: createKeyword("finally"), + _function: createKeyword("function", { + startsExpr + }), + _if: createKeyword("if"), + _return: createKeyword("return", { + beforeExpr + }), + _switch: createKeyword("switch"), + _throw: createKeyword("throw", { + beforeExpr, + prefix, + startsExpr + }), + _try: createKeyword("try"), + _var: createKeyword("var"), + _const: createKeyword("const"), + _with: createKeyword("with"), + _new: createKeyword("new", { + beforeExpr, + startsExpr + }), + _this: createKeyword("this", { + startsExpr + }), + _super: createKeyword("super", { + startsExpr + }), + _class: createKeyword("class", { + startsExpr + }), + _extends: createKeyword("extends", { + beforeExpr + }), + _export: createKeyword("export"), + _import: createKeyword("import", { + startsExpr + }), + _null: createKeyword("null", { + startsExpr + }), + _true: createKeyword("true", { + startsExpr + }), + _false: createKeyword("false", { + startsExpr + }), + _typeof: createKeyword("typeof", { + beforeExpr, + prefix, + startsExpr + }), + _void: createKeyword("void", { + beforeExpr, + prefix, + startsExpr + }), + _delete: createKeyword("delete", { + beforeExpr, + prefix, + startsExpr + }), + _do: createKeyword("do", { + isLoop, + beforeExpr + }), + _for: createKeyword("for", { + isLoop + }), + _while: createKeyword("while", { + isLoop + }), + _as: createKeywordLike("as", { + startsExpr + }), + _assert: createKeywordLike("assert", { + startsExpr + }), + _async: createKeywordLike("async", { + startsExpr + }), + _await: createKeywordLike("await", { + startsExpr + }), + _defer: createKeywordLike("defer", { + startsExpr + }), + _from: createKeywordLike("from", { + startsExpr + }), + _get: createKeywordLike("get", { + startsExpr + }), + _let: createKeywordLike("let", { + startsExpr + }), + _meta: createKeywordLike("meta", { + startsExpr + }), + _of: createKeywordLike("of", { + startsExpr + }), + _sent: createKeywordLike("sent", { + startsExpr + }), + _set: createKeywordLike("set", { + startsExpr + }), + _source: createKeywordLike("source", { + startsExpr + }), + _static: createKeywordLike("static", { + startsExpr + }), + _using: createKeywordLike("using", { + startsExpr + }), + _yield: createKeywordLike("yield", { + startsExpr + }), + _asserts: createKeywordLike("asserts", { + startsExpr + }), + _checks: createKeywordLike("checks", { + startsExpr + }), + _exports: createKeywordLike("exports", { + startsExpr + }), + _global: createKeywordLike("global", { + startsExpr + }), + _implements: createKeywordLike("implements", { + startsExpr + }), + _intrinsic: createKeywordLike("intrinsic", { + startsExpr + }), + _infer: createKeywordLike("infer", { + startsExpr + }), + _is: createKeywordLike("is", { + startsExpr + }), + _mixins: createKeywordLike("mixins", { + startsExpr + }), + _proto: createKeywordLike("proto", { + startsExpr + }), + _require: createKeywordLike("require", { + startsExpr + }), + _satisfies: createKeywordLike("satisfies", { + startsExpr + }), + _keyof: createKeywordLike("keyof", { + startsExpr + }), + _readonly: createKeywordLike("readonly", { + startsExpr + }), + _unique: createKeywordLike("unique", { + startsExpr + }), + _abstract: createKeywordLike("abstract", { + startsExpr + }), + _declare: createKeywordLike("declare", { + startsExpr + }), + _enum: createKeywordLike("enum", { + startsExpr + }), + _module: createKeywordLike("module", { + startsExpr + }), + _namespace: createKeywordLike("namespace", { + startsExpr + }), + _interface: createKeywordLike("interface", { + startsExpr + }), + _type: createKeywordLike("type", { + startsExpr + }), + _opaque: createKeywordLike("opaque", { + startsExpr + }), + name: createToken("name", { + startsExpr + }), + placeholder: createToken("%%", { + startsExpr + }), + string: createToken("string", { + startsExpr + }), + num: createToken("num", { + startsExpr + }), + bigint: createToken("bigint", { + startsExpr + }), + decimal: createToken("decimal", { + startsExpr + }), + regexp: createToken("regexp", { + startsExpr + }), + privateName: createToken("#name", { + startsExpr + }), + eof: createToken("eof"), + jsxName: createToken("jsxName"), + jsxText: createToken("jsxText", { + beforeExpr + }), + jsxTagStart: createToken("jsxTagStart", { + startsExpr + }), + jsxTagEnd: createToken("jsxTagEnd") +}; +function tokenIsIdentifier(token) { + return token >= 93 && token <= 133; +} +function tokenKeywordOrIdentifierIsKeyword(token) { + return token <= 92; +} +function tokenIsKeywordOrIdentifier(token) { + return token >= 58 && token <= 133; +} +function tokenIsLiteralPropertyName(token) { + return token >= 58 && token <= 137; +} +function tokenComesBeforeExpression(token) { + return tokenBeforeExprs[token]; +} +function tokenCanStartExpression(token) { + return tokenStartsExprs[token]; +} +function tokenIsAssignment(token) { + return token >= 29 && token <= 33; +} +function tokenIsFlowInterfaceOrTypeOrOpaque(token) { + return token >= 129 && token <= 131; +} +function tokenIsLoop(token) { + return token >= 90 && token <= 92; +} +function tokenIsKeyword(token) { + return token >= 58 && token <= 92; +} +function tokenIsOperator(token) { + return token >= 39 && token <= 59; +} +function tokenIsPostfix(token) { + return token === 34; +} +function tokenIsPrefix(token) { + return tokenPrefixes[token]; +} +function tokenIsTSTypeOperator(token) { + return token >= 121 && token <= 123; +} +function tokenIsTSDeclarationStart(token) { + return token >= 124 && token <= 130; +} +function tokenLabelName(token) { + return tokenLabels[token]; +} +function tokenOperatorPrecedence(token) { + return tokenBinops[token]; +} +function tokenIsRightAssociative(token) { + return token === 57; +} +function tokenIsTemplate(token) { + return token >= 24 && token <= 25; +} +function getExportedToken(token) { + return tokenTypes[token]; +} +tokenTypes[8].updateContext = context => { + context.pop(); +}; +tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => { + context.push(types.brace); +}; +tokenTypes[22].updateContext = context => { + if (context[context.length - 1] === types.template) { + context.pop(); + } else { + context.push(types.template); + } +}; +tokenTypes[143].updateContext = context => { + context.push(types.j_expr, types.j_oTag); +}; +let nonASCIIidentifierStartChars = "\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\u0560-\u0588\u05d0-\u05ea\u05ef-\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\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\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\u09fc\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\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\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-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\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-\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-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\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-\uab69\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"; +let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65"; +const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); +const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); +nonASCIIidentifierStartChars = nonASCIIidentifierChars = null; +const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489]; +const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; +function isInAstralSet(code, set) { + let pos = 0x10000; + for (let i = 0, length = set.length; i < length; i += 2) { + pos += set[i]; + if (pos > code) return false; + pos += set[i + 1]; + if (pos >= code) return true; + } + return false; +} +function isIdentifierStart(code) { + if (code < 65) return code === 36; + if (code <= 90) return true; + if (code < 97) return code === 95; + if (code <= 122) return true; + if (code <= 0xffff) { + return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); + } + return isInAstralSet(code, astralIdentifierStartCodes); +} +function isIdentifierChar(code) { + if (code < 48) return code === 36; + if (code < 58) return true; + if (code < 65) return false; + if (code <= 90) return true; + if (code < 97) return code === 95; + if (code <= 122) return true; + if (code <= 0xffff) { + return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); + } + return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes); +} +const reservedWords = { + keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"], + strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"], + strictBind: ["eval", "arguments"] +}; +const keywords = new Set(reservedWords.keyword); +const reservedWordsStrictSet = new Set(reservedWords.strict); +const reservedWordsStrictBindSet = new Set(reservedWords.strictBind); +function isReservedWord(word, inModule) { + return inModule && word === "await" || word === "enum"; +} +function isStrictReservedWord(word, inModule) { + return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word); +} +function isStrictBindOnlyReservedWord(word) { + return reservedWordsStrictBindSet.has(word); +} +function isStrictBindReservedWord(word, inModule) { + return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word); +} +function isKeyword(word) { + return keywords.has(word); +} +function isIteratorStart(current, next, next2) { + return current === 64 && next === 64 && isIdentifierStart(next2); +} +const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]); +function canBeReservedWord(word) { + return reservedWordLikeSet.has(word); +} +class Scope { + constructor(flags) { + this.flags = 0; + this.names = new Map(); + this.firstLexicalName = ""; + this.flags = flags; + } +} +class ScopeHandler { + constructor(parser, inModule) { + this.parser = void 0; + this.scopeStack = []; + this.inModule = void 0; + this.undefinedExports = new Map(); + this.parser = parser; + this.inModule = inModule; + } + get inTopLevel() { + return (this.currentScope().flags & 1) > 0; + } + get inFunction() { + return (this.currentVarScopeFlags() & 2) > 0; + } + get allowSuper() { + return (this.currentThisScopeFlags() & 16) > 0; + } + get allowDirectSuper() { + return (this.currentThisScopeFlags() & 32) > 0; + } + get allowNewTarget() { + return (this.currentThisScopeFlags() & 512) > 0; + } + get inClass() { + return (this.currentThisScopeFlags() & 64) > 0; + } + get inClassAndNotInNonArrowFunction() { + const flags = this.currentThisScopeFlags(); + return (flags & 64) > 0 && (flags & 2) === 0; + } + get inStaticBlock() { + for (let i = this.scopeStack.length - 1;; i--) { + const { + flags + } = this.scopeStack[i]; + if (flags & 128) { + return true; + } + if (flags & (1667 | 64)) { + return false; + } + } + } + get inNonArrowFunction() { + return (this.currentThisScopeFlags() & 2) > 0; + } + get inBareCaseStatement() { + return (this.currentScope().flags & 256) > 0; + } + get treatFunctionsAsVar() { + return this.treatFunctionsAsVarInScope(this.currentScope()); + } + createScope(flags) { + return new Scope(flags); + } + enter(flags) { + this.scopeStack.push(this.createScope(flags)); + } + exit() { + const scope = this.scopeStack.pop(); + return scope.flags; + } + treatFunctionsAsVarInScope(scope) { + return !!(scope.flags & (2 | 128) || !this.parser.inModule && scope.flags & 1); + } + declareName(name, bindingType, loc) { + let scope = this.currentScope(); + if (bindingType & 8 || bindingType & 16) { + this.checkRedeclarationInScope(scope, name, bindingType, loc); + let type = scope.names.get(name) || 0; + if (bindingType & 16) { + type = type | 4; + } else { + if (!scope.firstLexicalName) { + scope.firstLexicalName = name; + } + type = type | 2; + } + scope.names.set(name, type); + if (bindingType & 8) { + this.maybeExportDefined(scope, name); + } + } else if (bindingType & 4) { + for (let i = this.scopeStack.length - 1; i >= 0; --i) { + scope = this.scopeStack[i]; + this.checkRedeclarationInScope(scope, name, bindingType, loc); + scope.names.set(name, (scope.names.get(name) || 0) | 1); + this.maybeExportDefined(scope, name); + if (scope.flags & 1667) break; + } + } + if (this.parser.inModule && scope.flags & 1) { + this.undefinedExports.delete(name); + } + } + maybeExportDefined(scope, name) { + if (this.parser.inModule && scope.flags & 1) { + this.undefinedExports.delete(name); + } + } + checkRedeclarationInScope(scope, name, bindingType, loc) { + if (this.isRedeclaredInScope(scope, name, bindingType)) { + this.parser.raise(Errors.VarRedeclaration, loc, { + identifierName: name + }); + } + } + isRedeclaredInScope(scope, name, bindingType) { + if (!(bindingType & 1)) return false; + if (bindingType & 8) { + return scope.names.has(name); + } + const type = scope.names.get(name) || 0; + if (bindingType & 16) { + return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope) && (type & 1) > 0; + } + return (type & 2) > 0 && !(scope.flags & 8 && scope.firstLexicalName === name) || !this.treatFunctionsAsVarInScope(scope) && (type & 4) > 0; + } + checkLocalExport(id) { + const { + name + } = id; + const topLevelScope = this.scopeStack[0]; + if (!topLevelScope.names.has(name)) { + this.undefinedExports.set(name, id.loc.start); + } + } + currentScope() { + return this.scopeStack[this.scopeStack.length - 1]; + } + currentVarScopeFlags() { + for (let i = this.scopeStack.length - 1;; i--) { + const { + flags + } = this.scopeStack[i]; + if (flags & 1667) { + return flags; + } + } + } + currentThisScopeFlags() { + for (let i = this.scopeStack.length - 1;; i--) { + const { + flags + } = this.scopeStack[i]; + if (flags & (1667 | 64) && !(flags & 4)) { + return flags; + } + } + } +} +class FlowScope extends Scope { + constructor(...args) { + super(...args); + this.declareFunctions = new Set(); + } +} +class FlowScopeHandler extends ScopeHandler { + createScope(flags) { + return new FlowScope(flags); + } + declareName(name, bindingType, loc) { + const scope = this.currentScope(); + if (bindingType & 2048) { + this.checkRedeclarationInScope(scope, name, bindingType, loc); + this.maybeExportDefined(scope, name); + scope.declareFunctions.add(name); + return; + } + super.declareName(name, bindingType, loc); + } + isRedeclaredInScope(scope, name, bindingType) { + if (super.isRedeclaredInScope(scope, name, bindingType)) return true; + if (bindingType & 2048 && !scope.declareFunctions.has(name)) { + const type = scope.names.get(name); + return (type & 4) > 0 || (type & 2) > 0; + } + return false; + } + checkLocalExport(id) { + if (!this.scopeStack[0].declareFunctions.has(id.name)) { + super.checkLocalExport(id); + } + } +} +const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]); +const FlowErrors = ParseErrorEnum`flow`({ + AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.", + AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.", + AssignReservedType: ({ + reservedType + }) => `Cannot overwrite reserved type ${reservedType}.`, + DeclareClassElement: "The `declare` modifier can only appear on class fields.", + DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.", + DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.", + EnumBooleanMemberNotInitialized: ({ + memberName, + enumName + }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`, + EnumDuplicateMemberName: ({ + memberName, + enumName + }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`, + EnumInconsistentMemberValues: ({ + enumName + }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`, + EnumInvalidExplicitType: ({ + invalidEnumType, + enumName + }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`, + EnumInvalidExplicitTypeUnknownSupplied: ({ + enumName + }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`, + EnumInvalidMemberInitializerPrimaryType: ({ + enumName, + memberName, + explicitType + }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`, + EnumInvalidMemberInitializerSymbolType: ({ + enumName, + memberName + }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`, + EnumInvalidMemberInitializerUnknownType: ({ + enumName, + memberName + }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`, + EnumInvalidMemberName: ({ + enumName, + memberName, + suggestion + }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`, + EnumNumberMemberNotInitialized: ({ + enumName, + memberName + }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`, + EnumStringMemberInconsistentlyInitialized: ({ + enumName + }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`, + GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.", + ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.", + ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.", + InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.", + InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.", + InexactVariance: "Explicit inexact syntax cannot have variance.", + InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.", + MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.", + NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.", + NestedFlowComment: "Cannot have a flow comment inside another flow comment.", + PatternIsOptional: Object.assign({ + message: "A binding pattern parameter cannot be optional in an implementation signature." + }, { + reasonCode: "OptionalBindingPattern" + }), + SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.", + SpreadVariance: "Spread properties cannot have variance.", + ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.", + ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.", + ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.", + ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.", + ThisParamNoDefault: "The `this` parameter may not have a default value.", + TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.", + TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.", + UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.", + UnexpectedReservedType: ({ + reservedType + }) => `Unexpected reserved type ${reservedType}.`, + UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.", + UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.", + UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.", + UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".', + UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.", + UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of ` async () => {}`, use `async () => {}`.", + UnsupportedDeclareExportKind: ({ + unsupportedExportKind, + suggestion + }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`, + UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.", + UnterminatedFlowComment: "Unterminated flow-comment." +}); +function isEsModuleType(bodyElement) { + return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration"); +} +function hasTypeImportKind(node) { + return node.importKind === "type" || node.importKind === "typeof"; +} +const exportSuggestions = { + const: "declare export var", + let: "declare export var", + type: "export type", + interface: "export interface" +}; +function partition(list, test) { + const list1 = []; + const list2 = []; + for (let i = 0; i < list.length; i++) { + (test(list[i], i, list) ? list1 : list2).push(list[i]); + } + return [list1, list2]; +} +const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/; +var flow = superClass => class FlowParserMixin extends superClass { + constructor(...args) { + super(...args); + this.flowPragma = undefined; + } + getScopeHandler() { + return FlowScopeHandler; + } + shouldParseTypes() { + return this.getPluginOption("flow", "all") || this.flowPragma === "flow"; + } + finishToken(type, val) { + if (type !== 134 && type !== 13 && type !== 28) { + if (this.flowPragma === undefined) { + this.flowPragma = null; + } + } + super.finishToken(type, val); + } + addComment(comment) { + if (this.flowPragma === undefined) { + const matches = FLOW_PRAGMA_REGEX.exec(comment.value); + if (!matches) ;else if (matches[1] === "flow") { + this.flowPragma = "flow"; + } else if (matches[1] === "noflow") { + this.flowPragma = "noflow"; + } else { + throw new Error("Unexpected flow pragma"); + } + } + super.addComment(comment); + } + flowParseTypeInitialiser(tok) { + const oldInType = this.state.inType; + this.state.inType = true; + this.expect(tok || 14); + const type = this.flowParseType(); + this.state.inType = oldInType; + return type; + } + flowParsePredicate() { + const node = this.startNode(); + const moduloLoc = this.state.startLoc; + this.next(); + this.expectContextual(110); + if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) { + this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc); + } + if (this.eat(10)) { + node.value = super.parseExpression(); + this.expect(11); + return this.finishNode(node, "DeclaredPredicate"); + } else { + return this.finishNode(node, "InferredPredicate"); + } + } + flowParseTypeAndPredicateInitialiser() { + const oldInType = this.state.inType; + this.state.inType = true; + this.expect(14); + let type = null; + let predicate = null; + if (this.match(54)) { + this.state.inType = oldInType; + predicate = this.flowParsePredicate(); + } else { + type = this.flowParseType(); + this.state.inType = oldInType; + if (this.match(54)) { + predicate = this.flowParsePredicate(); + } + } + return [type, predicate]; + } + flowParseDeclareClass(node) { + this.next(); + this.flowParseInterfaceish(node, true); + return this.finishNode(node, "DeclareClass"); + } + flowParseDeclareFunction(node) { + this.next(); + const id = node.id = this.parseIdentifier(); + const typeNode = this.startNode(); + const typeContainer = this.startNode(); + if (this.match(47)) { + typeNode.typeParameters = this.flowParseTypeParameterDeclaration(); + } else { + typeNode.typeParameters = null; + } + this.expect(10); + const tmp = this.flowParseFunctionTypeParams(); + typeNode.params = tmp.params; + typeNode.rest = tmp.rest; + typeNode.this = tmp._this; + this.expect(11); + [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); + typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation"); + id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation"); + this.resetEndLocation(id); + this.semicolon(); + this.scope.declareName(node.id.name, 2048, node.id.loc.start); + return this.finishNode(node, "DeclareFunction"); + } + flowParseDeclare(node, insideModule) { + if (this.match(80)) { + return this.flowParseDeclareClass(node); + } else if (this.match(68)) { + return this.flowParseDeclareFunction(node); + } else if (this.match(74)) { + return this.flowParseDeclareVariable(node); + } else if (this.eatContextual(127)) { + if (this.match(16)) { + return this.flowParseDeclareModuleExports(node); + } else { + if (insideModule) { + this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc); + } + return this.flowParseDeclareModule(node); + } + } else if (this.isContextual(130)) { + return this.flowParseDeclareTypeAlias(node); + } else if (this.isContextual(131)) { + return this.flowParseDeclareOpaqueType(node); + } else if (this.isContextual(129)) { + return this.flowParseDeclareInterface(node); + } else if (this.match(82)) { + return this.flowParseDeclareExportDeclaration(node, insideModule); + } + throw this.unexpected(); + } + flowParseDeclareVariable(node) { + this.next(); + node.id = this.flowParseTypeAnnotatableIdentifier(true); + this.scope.declareName(node.id.name, 5, node.id.loc.start); + this.semicolon(); + return this.finishNode(node, "DeclareVariable"); + } + flowParseDeclareModule(node) { + this.scope.enter(0); + if (this.match(134)) { + node.id = super.parseExprAtom(); + } else { + node.id = this.parseIdentifier(); + } + const bodyNode = node.body = this.startNode(); + const body = bodyNode.body = []; + this.expect(5); + while (!this.match(8)) { + const bodyNode = this.startNode(); + if (this.match(83)) { + this.next(); + if (!this.isContextual(130) && !this.match(87)) { + this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc); + } + body.push(super.parseImport(bodyNode)); + } else { + this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule); + body.push(this.flowParseDeclare(bodyNode, true)); + } + } + this.scope.exit(); + this.expect(8); + this.finishNode(bodyNode, "BlockStatement"); + let kind = null; + let hasModuleExport = false; + body.forEach(bodyElement => { + if (isEsModuleType(bodyElement)) { + if (kind === "CommonJS") { + this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement); + } + kind = "ES"; + } else if (bodyElement.type === "DeclareModuleExports") { + if (hasModuleExport) { + this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement); + } + if (kind === "ES") { + this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement); + } + kind = "CommonJS"; + hasModuleExport = true; + } + }); + node.kind = kind || "CommonJS"; + return this.finishNode(node, "DeclareModule"); + } + flowParseDeclareExportDeclaration(node, insideModule) { + this.expect(82); + if (this.eat(65)) { + if (this.match(68) || this.match(80)) { + node.declaration = this.flowParseDeclare(this.startNode()); + } else { + node.declaration = this.flowParseType(); + this.semicolon(); + } + node.default = true; + return this.finishNode(node, "DeclareExportDeclaration"); + } else { + if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) { + const label = this.state.value; + throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, { + unsupportedExportKind: label, + suggestion: exportSuggestions[label] + }); + } + if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) { + node.declaration = this.flowParseDeclare(this.startNode()); + node.default = false; + return this.finishNode(node, "DeclareExportDeclaration"); + } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) { + node = this.parseExport(node, null); + if (node.type === "ExportNamedDeclaration") { + node.default = false; + delete node.exportKind; + return this.castNodeTo(node, "DeclareExportDeclaration"); + } else { + return this.castNodeTo(node, "DeclareExportAllDeclaration"); + } + } + } + throw this.unexpected(); + } + flowParseDeclareModuleExports(node) { + this.next(); + this.expectContextual(111); + node.typeAnnotation = this.flowParseTypeAnnotation(); + this.semicolon(); + return this.finishNode(node, "DeclareModuleExports"); + } + flowParseDeclareTypeAlias(node) { + this.next(); + const finished = this.flowParseTypeAlias(node); + this.castNodeTo(finished, "DeclareTypeAlias"); + return finished; + } + flowParseDeclareOpaqueType(node) { + this.next(); + const finished = this.flowParseOpaqueType(node, true); + this.castNodeTo(finished, "DeclareOpaqueType"); + return finished; + } + flowParseDeclareInterface(node) { + this.next(); + this.flowParseInterfaceish(node, false); + return this.finishNode(node, "DeclareInterface"); + } + flowParseInterfaceish(node, isClass) { + node.id = this.flowParseRestrictedIdentifier(!isClass, true); + this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } else { + node.typeParameters = null; + } + node.extends = []; + if (this.eat(81)) { + do { + node.extends.push(this.flowParseInterfaceExtends()); + } while (!isClass && this.eat(12)); + } + if (isClass) { + node.implements = []; + node.mixins = []; + if (this.eatContextual(117)) { + do { + node.mixins.push(this.flowParseInterfaceExtends()); + } while (this.eat(12)); + } + if (this.eatContextual(113)) { + do { + node.implements.push(this.flowParseInterfaceExtends()); + } while (this.eat(12)); + } + } + node.body = this.flowParseObjectType({ + allowStatic: isClass, + allowExact: false, + allowSpread: false, + allowProto: isClass, + allowInexact: false + }); + } + flowParseInterfaceExtends() { + const node = this.startNode(); + node.id = this.flowParseQualifiedTypeIdentifier(); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterInstantiation(); + } else { + node.typeParameters = null; + } + return this.finishNode(node, "InterfaceExtends"); + } + flowParseInterface(node) { + this.flowParseInterfaceish(node, false); + return this.finishNode(node, "InterfaceDeclaration"); + } + checkNotUnderscore(word) { + if (word === "_") { + this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc); + } + } + checkReservedType(word, startLoc, declaration) { + if (!reservedTypes.has(word)) return; + this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, { + reservedType: word + }); + } + flowParseRestrictedIdentifier(liberal, declaration) { + this.checkReservedType(this.state.value, this.state.startLoc, declaration); + return this.parseIdentifier(liberal); + } + flowParseTypeAlias(node) { + node.id = this.flowParseRestrictedIdentifier(false, true); + this.scope.declareName(node.id.name, 8201, node.id.loc.start); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } else { + node.typeParameters = null; + } + node.right = this.flowParseTypeInitialiser(29); + this.semicolon(); + return this.finishNode(node, "TypeAlias"); + } + flowParseOpaqueType(node, declare) { + this.expectContextual(130); + node.id = this.flowParseRestrictedIdentifier(true, true); + this.scope.declareName(node.id.name, 8201, node.id.loc.start); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } else { + node.typeParameters = null; + } + node.supertype = null; + if (this.match(14)) { + node.supertype = this.flowParseTypeInitialiser(14); + } + node.impltype = null; + if (!declare) { + node.impltype = this.flowParseTypeInitialiser(29); + } + this.semicolon(); + return this.finishNode(node, "OpaqueType"); + } + flowParseTypeParameter(requireDefault = false) { + const nodeStartLoc = this.state.startLoc; + const node = this.startNode(); + const variance = this.flowParseVariance(); + const ident = this.flowParseTypeAnnotatableIdentifier(); + node.name = ident.name; + node.variance = variance; + node.bound = ident.typeAnnotation; + if (this.match(29)) { + this.eat(29); + node.default = this.flowParseType(); + } else { + if (requireDefault) { + this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc); + } + } + return this.finishNode(node, "TypeParameter"); + } + flowParseTypeParameterDeclaration() { + const oldInType = this.state.inType; + const node = this.startNode(); + node.params = []; + this.state.inType = true; + if (this.match(47) || this.match(143)) { + this.next(); + } else { + this.unexpected(); + } + let defaultRequired = false; + do { + const typeParameter = this.flowParseTypeParameter(defaultRequired); + node.params.push(typeParameter); + if (typeParameter.default) { + defaultRequired = true; + } + if (!this.match(48)) { + this.expect(12); + } + } while (!this.match(48)); + this.expect(48); + this.state.inType = oldInType; + return this.finishNode(node, "TypeParameterDeclaration"); + } + flowInTopLevelContext(cb) { + if (this.curContext() !== types.brace) { + const oldContext = this.state.context; + this.state.context = [oldContext[0]]; + try { + return cb(); + } finally { + this.state.context = oldContext; + } + } else { + return cb(); + } + } + flowParseTypeParameterInstantiationInExpression() { + if (this.reScan_lt() !== 47) return; + return this.flowParseTypeParameterInstantiation(); + } + flowParseTypeParameterInstantiation() { + const node = this.startNode(); + const oldInType = this.state.inType; + this.state.inType = true; + node.params = []; + this.flowInTopLevelContext(() => { + this.expect(47); + const oldNoAnonFunctionType = this.state.noAnonFunctionType; + this.state.noAnonFunctionType = false; + while (!this.match(48)) { + node.params.push(this.flowParseType()); + if (!this.match(48)) { + this.expect(12); + } + } + this.state.noAnonFunctionType = oldNoAnonFunctionType; + }); + this.state.inType = oldInType; + if (!this.state.inType && this.curContext() === types.brace) { + this.reScan_lt_gt(); + } + this.expect(48); + return this.finishNode(node, "TypeParameterInstantiation"); + } + flowParseTypeParameterInstantiationCallOrNew() { + if (this.reScan_lt() !== 47) return null; + const node = this.startNode(); + const oldInType = this.state.inType; + node.params = []; + this.state.inType = true; + this.expect(47); + while (!this.match(48)) { + node.params.push(this.flowParseTypeOrImplicitInstantiation()); + if (!this.match(48)) { + this.expect(12); + } + } + this.expect(48); + this.state.inType = oldInType; + return this.finishNode(node, "TypeParameterInstantiation"); + } + flowParseInterfaceType() { + const node = this.startNode(); + this.expectContextual(129); + node.extends = []; + if (this.eat(81)) { + do { + node.extends.push(this.flowParseInterfaceExtends()); + } while (this.eat(12)); + } + node.body = this.flowParseObjectType({ + allowStatic: false, + allowExact: false, + allowSpread: false, + allowProto: false, + allowInexact: false + }); + return this.finishNode(node, "InterfaceTypeAnnotation"); + } + flowParseObjectPropertyKey() { + return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(true); + } + flowParseObjectTypeIndexer(node, isStatic, variance) { + node.static = isStatic; + if (this.lookahead().type === 14) { + node.id = this.flowParseObjectPropertyKey(); + node.key = this.flowParseTypeInitialiser(); + } else { + node.id = null; + node.key = this.flowParseType(); + } + this.expect(3); + node.value = this.flowParseTypeInitialiser(); + node.variance = variance; + return this.finishNode(node, "ObjectTypeIndexer"); + } + flowParseObjectTypeInternalSlot(node, isStatic) { + node.static = isStatic; + node.id = this.flowParseObjectPropertyKey(); + this.expect(3); + this.expect(3); + if (this.match(47) || this.match(10)) { + node.method = true; + node.optional = false; + node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start)); + } else { + node.method = false; + if (this.eat(17)) { + node.optional = true; + } + node.value = this.flowParseTypeInitialiser(); + } + return this.finishNode(node, "ObjectTypeInternalSlot"); + } + flowParseObjectTypeMethodish(node) { + node.params = []; + node.rest = null; + node.typeParameters = null; + node.this = null; + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } + this.expect(10); + if (this.match(78)) { + node.this = this.flowParseFunctionTypeParam(true); + node.this.name = null; + if (!this.match(11)) { + this.expect(12); + } + } + while (!this.match(11) && !this.match(21)) { + node.params.push(this.flowParseFunctionTypeParam(false)); + if (!this.match(11)) { + this.expect(12); + } + } + if (this.eat(21)) { + node.rest = this.flowParseFunctionTypeParam(false); + } + this.expect(11); + node.returnType = this.flowParseTypeInitialiser(); + return this.finishNode(node, "FunctionTypeAnnotation"); + } + flowParseObjectTypeCallProperty(node, isStatic) { + const valueNode = this.startNode(); + node.static = isStatic; + node.value = this.flowParseObjectTypeMethodish(valueNode); + return this.finishNode(node, "ObjectTypeCallProperty"); + } + flowParseObjectType({ + allowStatic, + allowExact, + allowSpread, + allowProto, + allowInexact + }) { + const oldInType = this.state.inType; + this.state.inType = true; + const nodeStart = this.startNode(); + nodeStart.callProperties = []; + nodeStart.properties = []; + nodeStart.indexers = []; + nodeStart.internalSlots = []; + let endDelim; + let exact; + let inexact = false; + if (allowExact && this.match(6)) { + this.expect(6); + endDelim = 9; + exact = true; + } else { + this.expect(5); + endDelim = 8; + exact = false; + } + nodeStart.exact = exact; + while (!this.match(endDelim)) { + let isStatic = false; + let protoStartLoc = null; + let inexactStartLoc = null; + const node = this.startNode(); + if (allowProto && this.isContextual(118)) { + const lookahead = this.lookahead(); + if (lookahead.type !== 14 && lookahead.type !== 17) { + this.next(); + protoStartLoc = this.state.startLoc; + allowStatic = false; + } + } + if (allowStatic && this.isContextual(106)) { + const lookahead = this.lookahead(); + if (lookahead.type !== 14 && lookahead.type !== 17) { + this.next(); + isStatic = true; + } + } + const variance = this.flowParseVariance(); + if (this.eat(0)) { + if (protoStartLoc != null) { + this.unexpected(protoStartLoc); + } + if (this.eat(0)) { + if (variance) { + this.unexpected(variance.loc.start); + } + nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic)); + } else { + nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance)); + } + } else if (this.match(10) || this.match(47)) { + if (protoStartLoc != null) { + this.unexpected(protoStartLoc); + } + if (variance) { + this.unexpected(variance.loc.start); + } + nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic)); + } else { + let kind = "init"; + if (this.isContextual(99) || this.isContextual(104)) { + const lookahead = this.lookahead(); + if (tokenIsLiteralPropertyName(lookahead.type)) { + kind = this.state.value; + this.next(); + } + } + const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact); + if (propOrInexact === null) { + inexact = true; + inexactStartLoc = this.state.lastTokStartLoc; + } else { + nodeStart.properties.push(propOrInexact); + } + } + this.flowObjectTypeSemicolon(); + if (inexactStartLoc && !this.match(8) && !this.match(9)) { + this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc); + } + } + this.expect(endDelim); + if (allowSpread) { + nodeStart.inexact = inexact; + } + const out = this.finishNode(nodeStart, "ObjectTypeAnnotation"); + this.state.inType = oldInType; + return out; + } + flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) { + if (this.eat(21)) { + const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9); + if (isInexactToken) { + if (!allowSpread) { + this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc); + } else if (!allowInexact) { + this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc); + } + if (variance) { + this.raise(FlowErrors.InexactVariance, variance); + } + return null; + } + if (!allowSpread) { + this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc); + } + if (protoStartLoc != null) { + this.unexpected(protoStartLoc); + } + if (variance) { + this.raise(FlowErrors.SpreadVariance, variance); + } + node.argument = this.flowParseType(); + return this.finishNode(node, "ObjectTypeSpreadProperty"); + } else { + node.key = this.flowParseObjectPropertyKey(); + node.static = isStatic; + node.proto = protoStartLoc != null; + node.kind = kind; + let optional = false; + if (this.match(47) || this.match(10)) { + node.method = true; + if (protoStartLoc != null) { + this.unexpected(protoStartLoc); + } + if (variance) { + this.unexpected(variance.loc.start); + } + node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start)); + if (kind === "get" || kind === "set") { + this.flowCheckGetterSetterParams(node); + } + if (!allowSpread && node.key.name === "constructor" && node.value.this) { + this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this); + } + } else { + if (kind !== "init") this.unexpected(); + node.method = false; + if (this.eat(17)) { + optional = true; + } + node.value = this.flowParseTypeInitialiser(); + node.variance = variance; + } + node.optional = optional; + return this.finishNode(node, "ObjectTypeProperty"); + } + } + flowCheckGetterSetterParams(property) { + const paramCount = property.kind === "get" ? 0 : 1; + const length = property.value.params.length + (property.value.rest ? 1 : 0); + if (property.value.this) { + this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this); + } + if (length !== paramCount) { + this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, property); + } + if (property.kind === "set" && property.value.rest) { + this.raise(Errors.BadSetterRestParameter, property); + } + } + flowObjectTypeSemicolon() { + if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) { + this.unexpected(); + } + } + flowParseQualifiedTypeIdentifier(startLoc, id) { + startLoc != null ? startLoc : startLoc = this.state.startLoc; + let node = id || this.flowParseRestrictedIdentifier(true); + while (this.eat(16)) { + const node2 = this.startNodeAt(startLoc); + node2.qualification = node; + node2.id = this.flowParseRestrictedIdentifier(true); + node = this.finishNode(node2, "QualifiedTypeIdentifier"); + } + return node; + } + flowParseGenericType(startLoc, id) { + const node = this.startNodeAt(startLoc); + node.typeParameters = null; + node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterInstantiation(); + } + return this.finishNode(node, "GenericTypeAnnotation"); + } + flowParseTypeofType() { + const node = this.startNode(); + this.expect(87); + node.argument = this.flowParsePrimaryType(); + return this.finishNode(node, "TypeofTypeAnnotation"); + } + flowParseTupleType() { + const node = this.startNode(); + node.types = []; + this.expect(0); + while (this.state.pos < this.length && !this.match(3)) { + node.types.push(this.flowParseType()); + if (this.match(3)) break; + this.expect(12); + } + this.expect(3); + return this.finishNode(node, "TupleTypeAnnotation"); + } + flowParseFunctionTypeParam(first) { + let name = null; + let optional = false; + let typeAnnotation = null; + const node = this.startNode(); + const lh = this.lookahead(); + const isThis = this.state.type === 78; + if (lh.type === 14 || lh.type === 17) { + if (isThis && !first) { + this.raise(FlowErrors.ThisParamMustBeFirst, node); + } + name = this.parseIdentifier(isThis); + if (this.eat(17)) { + optional = true; + if (isThis) { + this.raise(FlowErrors.ThisParamMayNotBeOptional, node); + } + } + typeAnnotation = this.flowParseTypeInitialiser(); + } else { + typeAnnotation = this.flowParseType(); + } + node.name = name; + node.optional = optional; + node.typeAnnotation = typeAnnotation; + return this.finishNode(node, "FunctionTypeParam"); + } + reinterpretTypeAsFunctionTypeParam(type) { + const node = this.startNodeAt(type.loc.start); + node.name = null; + node.optional = false; + node.typeAnnotation = type; + return this.finishNode(node, "FunctionTypeParam"); + } + flowParseFunctionTypeParams(params = []) { + let rest = null; + let _this = null; + if (this.match(78)) { + _this = this.flowParseFunctionTypeParam(true); + _this.name = null; + if (!this.match(11)) { + this.expect(12); + } + } + while (!this.match(11) && !this.match(21)) { + params.push(this.flowParseFunctionTypeParam(false)); + if (!this.match(11)) { + this.expect(12); + } + } + if (this.eat(21)) { + rest = this.flowParseFunctionTypeParam(false); + } + return { + params, + rest, + _this + }; + } + flowIdentToTypeAnnotation(startLoc, node, id) { + switch (id.name) { + case "any": + return this.finishNode(node, "AnyTypeAnnotation"); + case "bool": + case "boolean": + return this.finishNode(node, "BooleanTypeAnnotation"); + case "mixed": + return this.finishNode(node, "MixedTypeAnnotation"); + case "empty": + return this.finishNode(node, "EmptyTypeAnnotation"); + case "number": + return this.finishNode(node, "NumberTypeAnnotation"); + case "string": + return this.finishNode(node, "StringTypeAnnotation"); + case "symbol": + return this.finishNode(node, "SymbolTypeAnnotation"); + default: + this.checkNotUnderscore(id.name); + return this.flowParseGenericType(startLoc, id); + } + } + flowParsePrimaryType() { + const startLoc = this.state.startLoc; + const node = this.startNode(); + let tmp; + let type; + let isGroupedType = false; + const oldNoAnonFunctionType = this.state.noAnonFunctionType; + switch (this.state.type) { + case 5: + return this.flowParseObjectType({ + allowStatic: false, + allowExact: false, + allowSpread: true, + allowProto: false, + allowInexact: true + }); + case 6: + return this.flowParseObjectType({ + allowStatic: false, + allowExact: true, + allowSpread: true, + allowProto: false, + allowInexact: false + }); + case 0: + this.state.noAnonFunctionType = false; + type = this.flowParseTupleType(); + this.state.noAnonFunctionType = oldNoAnonFunctionType; + return type; + case 47: + { + const node = this.startNode(); + node.typeParameters = this.flowParseTypeParameterDeclaration(); + this.expect(10); + tmp = this.flowParseFunctionTypeParams(); + node.params = tmp.params; + node.rest = tmp.rest; + node.this = tmp._this; + this.expect(11); + this.expect(19); + node.returnType = this.flowParseType(); + return this.finishNode(node, "FunctionTypeAnnotation"); + } + case 10: + { + const node = this.startNode(); + this.next(); + if (!this.match(11) && !this.match(21)) { + if (tokenIsIdentifier(this.state.type) || this.match(78)) { + const token = this.lookahead().type; + isGroupedType = token !== 17 && token !== 14; + } else { + isGroupedType = true; + } + } + if (isGroupedType) { + this.state.noAnonFunctionType = false; + type = this.flowParseType(); + this.state.noAnonFunctionType = oldNoAnonFunctionType; + if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) { + this.expect(11); + return type; + } else { + this.eat(12); + } + } + if (type) { + tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]); + } else { + tmp = this.flowParseFunctionTypeParams(); + } + node.params = tmp.params; + node.rest = tmp.rest; + node.this = tmp._this; + this.expect(11); + this.expect(19); + node.returnType = this.flowParseType(); + node.typeParameters = null; + return this.finishNode(node, "FunctionTypeAnnotation"); + } + case 134: + return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation"); + case 85: + case 86: + node.value = this.match(85); + this.next(); + return this.finishNode(node, "BooleanLiteralTypeAnnotation"); + case 53: + if (this.state.value === "-") { + this.next(); + if (this.match(135)) { + return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node); + } + if (this.match(136)) { + return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node); + } + throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc); + } + throw this.unexpected(); + case 135: + return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation"); + case 136: + return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation"); + case 88: + this.next(); + return this.finishNode(node, "VoidTypeAnnotation"); + case 84: + this.next(); + return this.finishNode(node, "NullLiteralTypeAnnotation"); + case 78: + this.next(); + return this.finishNode(node, "ThisTypeAnnotation"); + case 55: + this.next(); + return this.finishNode(node, "ExistsTypeAnnotation"); + case 87: + return this.flowParseTypeofType(); + default: + if (tokenIsKeyword(this.state.type)) { + const label = tokenLabelName(this.state.type); + this.next(); + return super.createIdentifier(node, label); + } else if (tokenIsIdentifier(this.state.type)) { + if (this.isContextual(129)) { + return this.flowParseInterfaceType(); + } + return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier()); + } + } + throw this.unexpected(); + } + flowParsePostfixType() { + const startLoc = this.state.startLoc; + let type = this.flowParsePrimaryType(); + let seenOptionalIndexedAccess = false; + while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) { + const node = this.startNodeAt(startLoc); + const optional = this.eat(18); + seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional; + this.expect(0); + if (!optional && this.match(3)) { + node.elementType = type; + this.next(); + type = this.finishNode(node, "ArrayTypeAnnotation"); + } else { + node.objectType = type; + node.indexType = this.flowParseType(); + this.expect(3); + if (seenOptionalIndexedAccess) { + node.optional = optional; + type = this.finishNode(node, "OptionalIndexedAccessType"); + } else { + type = this.finishNode(node, "IndexedAccessType"); + } + } + } + return type; + } + flowParsePrefixType() { + const node = this.startNode(); + if (this.eat(17)) { + node.typeAnnotation = this.flowParsePrefixType(); + return this.finishNode(node, "NullableTypeAnnotation"); + } else { + return this.flowParsePostfixType(); + } + } + flowParseAnonFunctionWithoutParens() { + const param = this.flowParsePrefixType(); + if (!this.state.noAnonFunctionType && this.eat(19)) { + const node = this.startNodeAt(param.loc.start); + node.params = [this.reinterpretTypeAsFunctionTypeParam(param)]; + node.rest = null; + node.this = null; + node.returnType = this.flowParseType(); + node.typeParameters = null; + return this.finishNode(node, "FunctionTypeAnnotation"); + } + return param; + } + flowParseIntersectionType() { + const node = this.startNode(); + this.eat(45); + const type = this.flowParseAnonFunctionWithoutParens(); + node.types = [type]; + while (this.eat(45)) { + node.types.push(this.flowParseAnonFunctionWithoutParens()); + } + return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation"); + } + flowParseUnionType() { + const node = this.startNode(); + this.eat(43); + const type = this.flowParseIntersectionType(); + node.types = [type]; + while (this.eat(43)) { + node.types.push(this.flowParseIntersectionType()); + } + return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation"); + } + flowParseType() { + const oldInType = this.state.inType; + this.state.inType = true; + const type = this.flowParseUnionType(); + this.state.inType = oldInType; + return type; + } + flowParseTypeOrImplicitInstantiation() { + if (this.state.type === 132 && this.state.value === "_") { + const startLoc = this.state.startLoc; + const node = this.parseIdentifier(); + return this.flowParseGenericType(startLoc, node); + } else { + return this.flowParseType(); + } + } + flowParseTypeAnnotation() { + const node = this.startNode(); + node.typeAnnotation = this.flowParseTypeInitialiser(); + return this.finishNode(node, "TypeAnnotation"); + } + flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) { + const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier(); + if (this.match(14)) { + ident.typeAnnotation = this.flowParseTypeAnnotation(); + this.resetEndLocation(ident); + } + return ident; + } + typeCastToParameter(node) { + node.expression.typeAnnotation = node.typeAnnotation; + this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); + return node.expression; + } + flowParseVariance() { + let variance = null; + if (this.match(53)) { + variance = this.startNode(); + if (this.state.value === "+") { + variance.kind = "plus"; + } else { + variance.kind = "minus"; + } + this.next(); + return this.finishNode(variance, "Variance"); + } + return variance; + } + parseFunctionBody(node, allowExpressionBody, isMethod = false) { + if (allowExpressionBody) { + this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod)); + return; + } + super.parseFunctionBody(node, false, isMethod); + } + parseFunctionBodyAndFinish(node, type, isMethod = false) { + if (this.match(14)) { + const typeNode = this.startNode(); + [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); + node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null; + } + return super.parseFunctionBodyAndFinish(node, type, isMethod); + } + parseStatementLike(flags) { + if (this.state.strict && this.isContextual(129)) { + const lookahead = this.lookahead(); + if (tokenIsKeywordOrIdentifier(lookahead.type)) { + const node = this.startNode(); + this.next(); + return this.flowParseInterface(node); + } + } else if (this.isContextual(126)) { + const node = this.startNode(); + this.next(); + return this.flowParseEnumDeclaration(node); + } + const stmt = super.parseStatementLike(flags); + if (this.flowPragma === undefined && !this.isValidDirective(stmt)) { + this.flowPragma = null; + } + return stmt; + } + parseExpressionStatement(node, expr, decorators) { + if (expr.type === "Identifier") { + if (expr.name === "declare") { + if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) { + return this.flowParseDeclare(node); + } + } else if (tokenIsIdentifier(this.state.type)) { + if (expr.name === "interface") { + return this.flowParseInterface(node); + } else if (expr.name === "type") { + return this.flowParseTypeAlias(node); + } else if (expr.name === "opaque") { + return this.flowParseOpaqueType(node, false); + } + } + } + return super.parseExpressionStatement(node, expr, decorators); + } + shouldParseExportDeclaration() { + const { + type + } = this.state; + if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) { + return !this.state.containsEsc; + } + return super.shouldParseExportDeclaration(); + } + isExportDefaultSpecifier() { + const { + type + } = this.state; + if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) { + return this.state.containsEsc; + } + return super.isExportDefaultSpecifier(); + } + parseExportDefaultExpression() { + if (this.isContextual(126)) { + const node = this.startNode(); + this.next(); + return this.flowParseEnumDeclaration(node); + } + return super.parseExportDefaultExpression(); + } + parseConditional(expr, startLoc, refExpressionErrors) { + if (!this.match(17)) return expr; + if (this.state.maybeInArrowParameters) { + const nextCh = this.lookaheadCharCode(); + if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) { + this.setOptionalParametersError(refExpressionErrors); + return expr; + } + } + this.expect(17); + const state = this.state.clone(); + const originalNoArrowAt = this.state.noArrowAt; + const node = this.startNodeAt(startLoc); + let { + consequent, + failed + } = this.tryParseConditionalConsequent(); + let [valid, invalid] = this.getArrowLikeExpressions(consequent); + if (failed || invalid.length > 0) { + const noArrowAt = [...originalNoArrowAt]; + if (invalid.length > 0) { + this.state = state; + this.state.noArrowAt = noArrowAt; + for (let i = 0; i < invalid.length; i++) { + noArrowAt.push(invalid[i].start); + } + ({ + consequent, + failed + } = this.tryParseConditionalConsequent()); + [valid, invalid] = this.getArrowLikeExpressions(consequent); + } + if (failed && valid.length > 1) { + this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc); + } + if (failed && valid.length === 1) { + this.state = state; + noArrowAt.push(valid[0].start); + this.state.noArrowAt = noArrowAt; + ({ + consequent, + failed + } = this.tryParseConditionalConsequent()); + } + } + this.getArrowLikeExpressions(consequent, true); + this.state.noArrowAt = originalNoArrowAt; + this.expect(14); + node.test = expr; + node.consequent = consequent; + node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined)); + return this.finishNode(node, "ConditionalExpression"); + } + tryParseConditionalConsequent() { + this.state.noArrowParamsConversionAt.push(this.state.start); + const consequent = this.parseMaybeAssignAllowIn(); + const failed = !this.match(14); + this.state.noArrowParamsConversionAt.pop(); + return { + consequent, + failed + }; + } + getArrowLikeExpressions(node, disallowInvalid) { + const stack = [node]; + const arrows = []; + while (stack.length !== 0) { + const node = stack.pop(); + if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") { + if (node.typeParameters || !node.returnType) { + this.finishArrowValidation(node); + } else { + arrows.push(node); + } + stack.push(node.body); + } else if (node.type === "ConditionalExpression") { + stack.push(node.consequent); + stack.push(node.alternate); + } + } + if (disallowInvalid) { + arrows.forEach(node => this.finishArrowValidation(node)); + return [arrows, []]; + } + return partition(arrows, node => node.params.every(param => this.isAssignable(param, true))); + } + finishArrowValidation(node) { + var _node$extra; + this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false); + this.scope.enter(514 | 4); + super.checkParams(node, false, true); + this.scope.exit(); + } + forwardNoArrowParamsConversionAt(node, parse) { + let result; + if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) { + this.state.noArrowParamsConversionAt.push(this.state.start); + result = parse(); + this.state.noArrowParamsConversionAt.pop(); + } else { + result = parse(); + } + return result; + } + parseParenItem(node, startLoc) { + const newNode = super.parseParenItem(node, startLoc); + if (this.eat(17)) { + newNode.optional = true; + this.resetEndLocation(node); + } + if (this.match(14)) { + const typeCastNode = this.startNodeAt(startLoc); + typeCastNode.expression = newNode; + typeCastNode.typeAnnotation = this.flowParseTypeAnnotation(); + return this.finishNode(typeCastNode, "TypeCastExpression"); + } + return newNode; + } + assertModuleNodeAllowed(node) { + if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") { + return; + } + super.assertModuleNodeAllowed(node); + } + parseExportDeclaration(node) { + if (this.isContextual(130)) { + node.exportKind = "type"; + const declarationNode = this.startNode(); + this.next(); + if (this.match(5)) { + node.specifiers = this.parseExportSpecifiers(true); + super.parseExportFrom(node); + return null; + } else { + return this.flowParseTypeAlias(declarationNode); + } + } else if (this.isContextual(131)) { + node.exportKind = "type"; + const declarationNode = this.startNode(); + this.next(); + return this.flowParseOpaqueType(declarationNode, false); + } else if (this.isContextual(129)) { + node.exportKind = "type"; + const declarationNode = this.startNode(); + this.next(); + return this.flowParseInterface(declarationNode); + } else if (this.isContextual(126)) { + node.exportKind = "value"; + const declarationNode = this.startNode(); + this.next(); + return this.flowParseEnumDeclaration(declarationNode); + } else { + return super.parseExportDeclaration(node); + } + } + eatExportStar(node) { + if (super.eatExportStar(node)) return true; + if (this.isContextual(130) && this.lookahead().type === 55) { + node.exportKind = "type"; + this.next(); + this.next(); + return true; + } + return false; + } + maybeParseExportNamespaceSpecifier(node) { + const { + startLoc + } = this.state; + const hasNamespace = super.maybeParseExportNamespaceSpecifier(node); + if (hasNamespace && node.exportKind === "type") { + this.unexpected(startLoc); + } + return hasNamespace; + } + parseClassId(node, isStatement, optionalId) { + super.parseClassId(node, isStatement, optionalId); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } + } + parseClassMember(classBody, member, state) { + const { + startLoc + } = this.state; + if (this.isContextual(125)) { + if (super.parseClassMemberFromModifier(classBody, member)) { + return; + } + member.declare = true; + } + super.parseClassMember(classBody, member, state); + if (member.declare) { + if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") { + this.raise(FlowErrors.DeclareClassElement, startLoc); + } else if (member.value) { + this.raise(FlowErrors.DeclareClassFieldInitializer, member.value); + } + } + } + isIterator(word) { + return word === "iterator" || word === "asyncIterator"; + } + readIterator() { + const word = super.readWord1(); + const fullWord = "@@" + word; + if (!this.isIterator(word) || !this.state.inType) { + this.raise(Errors.InvalidIdentifier, this.state.curPosition(), { + identifierName: fullWord + }); + } + this.finishToken(132, fullWord); + } + getTokenFromCode(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (code === 123 && next === 124) { + this.finishOp(6, 2); + } else if (this.state.inType && (code === 62 || code === 60)) { + this.finishOp(code === 62 ? 48 : 47, 1); + } else if (this.state.inType && code === 63) { + if (next === 46) { + this.finishOp(18, 2); + } else { + this.finishOp(17, 1); + } + } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) { + this.state.pos += 2; + this.readIterator(); + } else { + super.getTokenFromCode(code); + } + } + isAssignable(node, isBinding) { + if (node.type === "TypeCastExpression") { + return this.isAssignable(node.expression, isBinding); + } else { + return super.isAssignable(node, isBinding); + } + } + toAssignable(node, isLHS = false) { + if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") { + node.left = this.typeCastToParameter(node.left); + } + super.toAssignable(node, isLHS); + } + toAssignableList(exprList, trailingCommaLoc, isLHS) { + for (let i = 0; i < exprList.length; i++) { + const expr = exprList[i]; + if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") { + exprList[i] = this.typeCastToParameter(expr); + } + } + super.toAssignableList(exprList, trailingCommaLoc, isLHS); + } + toReferencedList(exprList, isParenthesizedExpr) { + for (let i = 0; i < exprList.length; i++) { + var _expr$extra; + const expr = exprList[i]; + if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) { + this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation); + } + } + return exprList; + } + parseArrayLike(close, isTuple, refExpressionErrors) { + const node = super.parseArrayLike(close, isTuple, refExpressionErrors); + if (refExpressionErrors != null && !this.state.maybeInArrowParameters) { + this.toReferencedList(node.elements); + } + return node; + } + isValidLVal(type, disallowCallExpression, isParenthesized, binding) { + return type === "TypeCastExpression" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding); + } + parseClassProperty(node) { + if (this.match(14)) { + node.typeAnnotation = this.flowParseTypeAnnotation(); + } + return super.parseClassProperty(node); + } + parseClassPrivateProperty(node) { + if (this.match(14)) { + node.typeAnnotation = this.flowParseTypeAnnotation(); + } + return super.parseClassPrivateProperty(node); + } + isClassMethod() { + return this.match(47) || super.isClassMethod(); + } + isClassProperty() { + return this.match(14) || super.isClassProperty(); + } + isNonstaticConstructor(method) { + return !this.match(14) && super.isNonstaticConstructor(method); + } + pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { + if (method.variance) { + this.unexpected(method.variance.loc.start); + } + delete method.variance; + if (this.match(47)) { + method.typeParameters = this.flowParseTypeParameterDeclaration(); + } + super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); + if (method.params && isConstructor) { + const params = method.params; + if (params.length > 0 && this.isThisParam(params[0])) { + this.raise(FlowErrors.ThisParamBannedInConstructor, method); + } + } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) { + const params = method.value.params; + if (params.length > 0 && this.isThisParam(params[0])) { + this.raise(FlowErrors.ThisParamBannedInConstructor, method); + } + } + } + pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { + if (method.variance) { + this.unexpected(method.variance.loc.start); + } + delete method.variance; + if (this.match(47)) { + method.typeParameters = this.flowParseTypeParameterDeclaration(); + } + super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); + } + parseClassSuper(node) { + super.parseClassSuper(node); + if (node.superClass && (this.match(47) || this.match(51))) { + node.superTypeParameters = this.flowParseTypeParameterInstantiationInExpression(); + } + if (this.isContextual(113)) { + this.next(); + const implemented = node.implements = []; + do { + const node = this.startNode(); + node.id = this.flowParseRestrictedIdentifier(true); + if (this.match(47)) { + node.typeParameters = this.flowParseTypeParameterInstantiation(); + } else { + node.typeParameters = null; + } + implemented.push(this.finishNode(node, "ClassImplements")); + } while (this.eat(12)); + } + } + checkGetterSetterParams(method) { + super.checkGetterSetterParams(method); + const params = this.getObjectOrClassMethodParams(method); + if (params.length > 0) { + const param = params[0]; + if (this.isThisParam(param) && method.kind === "get") { + this.raise(FlowErrors.GetterMayNotHaveThisParam, param); + } else if (this.isThisParam(param)) { + this.raise(FlowErrors.SetterMayNotHaveThisParam, param); + } + } + } + parsePropertyNamePrefixOperator(node) { + node.variance = this.flowParseVariance(); + } + parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { + if (prop.variance) { + this.unexpected(prop.variance.loc.start); + } + delete prop.variance; + let typeParameters; + if (this.match(47) && !isAccessor) { + typeParameters = this.flowParseTypeParameterDeclaration(); + if (!this.match(10)) this.unexpected(); + } + const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors); + if (typeParameters) { + (result.value || result).typeParameters = typeParameters; + } + return result; + } + parseFunctionParamType(param) { + if (this.eat(17)) { + if (param.type !== "Identifier") { + this.raise(FlowErrors.PatternIsOptional, param); + } + if (this.isThisParam(param)) { + this.raise(FlowErrors.ThisParamMayNotBeOptional, param); + } + param.optional = true; + } + if (this.match(14)) { + param.typeAnnotation = this.flowParseTypeAnnotation(); + } else if (this.isThisParam(param)) { + this.raise(FlowErrors.ThisParamAnnotationRequired, param); + } + if (this.match(29) && this.isThisParam(param)) { + this.raise(FlowErrors.ThisParamNoDefault, param); + } + this.resetEndLocation(param); + return param; + } + parseMaybeDefault(startLoc, left) { + const node = super.parseMaybeDefault(startLoc, left); + if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { + this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation); + } + return node; + } + checkImportReflection(node) { + super.checkImportReflection(node); + if (node.module && node.importKind !== "value") { + this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start); + } + } + parseImportSpecifierLocal(node, specifier, type) { + specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier(); + node.specifiers.push(this.finishImportSpecifier(specifier, type)); + } + isPotentialImportPhase(isExport) { + if (super.isPotentialImportPhase(isExport)) return true; + if (this.isContextual(130)) { + if (!isExport) return true; + const ch = this.lookaheadCharCode(); + return ch === 123 || ch === 42; + } + return !isExport && this.isContextual(87); + } + applyImportPhase(node, isExport, phase, loc) { + super.applyImportPhase(node, isExport, phase, loc); + if (isExport) { + if (!phase && this.match(65)) { + return; + } + node.exportKind = phase === "type" ? phase : "value"; + } else { + if (phase === "type" && this.match(55)) this.unexpected(); + node.importKind = phase === "type" || phase === "typeof" ? phase : "value"; + } + } + parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { + const firstIdent = specifier.imported; + let specifierTypeKind = null; + if (firstIdent.type === "Identifier") { + if (firstIdent.name === "type") { + specifierTypeKind = "type"; + } else if (firstIdent.name === "typeof") { + specifierTypeKind = "typeof"; + } + } + let isBinding = false; + if (this.isContextual(93) && !this.isLookaheadContextual("as")) { + const as_ident = this.parseIdentifier(true); + if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) { + specifier.imported = as_ident; + specifier.importKind = specifierTypeKind; + specifier.local = this.cloneIdentifier(as_ident); + } else { + specifier.imported = firstIdent; + specifier.importKind = null; + specifier.local = this.parseIdentifier(); + } + } else { + if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) { + specifier.imported = this.parseIdentifier(true); + specifier.importKind = specifierTypeKind; + } else { + if (importedIsString) { + throw this.raise(Errors.ImportBindingIsString, specifier, { + importName: firstIdent.value + }); + } + specifier.imported = firstIdent; + specifier.importKind = null; + } + if (this.eatContextual(93)) { + specifier.local = this.parseIdentifier(); + } else { + isBinding = true; + specifier.local = this.cloneIdentifier(specifier.imported); + } + } + const specifierIsTypeImport = hasTypeImportKind(specifier); + if (isInTypeOnlyImport && specifierIsTypeImport) { + this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier); + } + if (isInTypeOnlyImport || specifierIsTypeImport) { + this.checkReservedType(specifier.local.name, specifier.local.loc.start, true); + } + if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) { + this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true); + } + return this.finishImportSpecifier(specifier, "ImportSpecifier"); + } + parseBindingAtom() { + switch (this.state.type) { + case 78: + return this.parseIdentifier(true); + default: + return super.parseBindingAtom(); + } + } + parseFunctionParams(node, isConstructor) { + const kind = node.kind; + if (kind !== "get" && kind !== "set" && this.match(47)) { + node.typeParameters = this.flowParseTypeParameterDeclaration(); + } + super.parseFunctionParams(node, isConstructor); + } + parseVarId(decl, kind) { + super.parseVarId(decl, kind); + if (this.match(14)) { + decl.id.typeAnnotation = this.flowParseTypeAnnotation(); + this.resetEndLocation(decl.id); + } + } + parseAsyncArrowFromCallExpression(node, call) { + if (this.match(14)) { + const oldNoAnonFunctionType = this.state.noAnonFunctionType; + this.state.noAnonFunctionType = true; + node.returnType = this.flowParseTypeAnnotation(); + this.state.noAnonFunctionType = oldNoAnonFunctionType; + } + return super.parseAsyncArrowFromCallExpression(node, call); + } + shouldParseAsyncArrow() { + return this.match(14) || super.shouldParseAsyncArrow(); + } + parseMaybeAssign(refExpressionErrors, afterLeftParse) { + var _jsx; + let state = null; + let jsx; + if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) { + state = this.state.clone(); + jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); + if (!jsx.error) return jsx.node; + const { + context + } = this.state; + const currentContext = context[context.length - 1]; + if (currentContext === types.j_oTag || currentContext === types.j_expr) { + context.pop(); + } + } + if ((_jsx = jsx) != null && _jsx.error || this.match(47)) { + var _jsx2, _jsx3; + state = state || this.state.clone(); + let typeParameters; + const arrow = this.tryParse(abort => { + var _arrowExpression$extr; + typeParameters = this.flowParseTypeParameterDeclaration(); + const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => { + const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse); + this.resetStartLocationFromNode(result, typeParameters); + return result; + }); + if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort(); + const expr = this.maybeUnwrapTypeCastExpression(arrowExpression); + if (expr.type !== "ArrowFunctionExpression") abort(); + expr.typeParameters = typeParameters; + this.resetStartLocationFromNode(expr, typeParameters); + return arrowExpression; + }, state); + let arrowExpression = null; + if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") { + if (!arrow.error && !arrow.aborted) { + if (arrow.node.async) { + this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters); + } + return arrow.node; + } + arrowExpression = arrow.node; + } + if ((_jsx2 = jsx) != null && _jsx2.node) { + this.state = jsx.failState; + return jsx.node; + } + if (arrowExpression) { + this.state = arrow.failState; + return arrowExpression; + } + if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error; + if (arrow.thrown) throw arrow.error; + throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters); + } + return super.parseMaybeAssign(refExpressionErrors, afterLeftParse); + } + parseArrow(node) { + if (this.match(14)) { + const result = this.tryParse(() => { + const oldNoAnonFunctionType = this.state.noAnonFunctionType; + this.state.noAnonFunctionType = true; + const typeNode = this.startNode(); + [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); + this.state.noAnonFunctionType = oldNoAnonFunctionType; + if (this.canInsertSemicolon()) this.unexpected(); + if (!this.match(19)) this.unexpected(); + return typeNode; + }); + if (result.thrown) return null; + if (result.error) this.state = result.failState; + node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null; + } + return super.parseArrow(node); + } + shouldParseArrow(params) { + return this.match(14) || super.shouldParseArrow(params); + } + setArrowFunctionParameters(node, params) { + if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) { + node.params = params; + } else { + super.setArrowFunctionParameters(node, params); + } + } + checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { + if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) { + return; + } + for (let i = 0; i < node.params.length; i++) { + if (this.isThisParam(node.params[i]) && i > 0) { + this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]); + } + } + super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged); + } + parseParenAndDistinguishExpression(canBeArrow) { + return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start))); + } + parseSubscripts(base, startLoc, noCalls) { + if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.includes(startLoc.index)) { + this.next(); + const node = this.startNodeAt(startLoc); + node.callee = base; + node.arguments = super.parseCallExpressionArguments(); + base = this.finishNode(node, "CallExpression"); + } else if (base.type === "Identifier" && base.name === "async" && this.match(47)) { + const state = this.state.clone(); + const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state); + if (!arrow.error && !arrow.aborted) return arrow.node; + const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state); + if (result.node && !result.error) return result.node; + if (arrow.node) { + this.state = arrow.failState; + return arrow.node; + } + if (result.node) { + this.state = result.failState; + return result.node; + } + throw arrow.error || result.error; + } + return super.parseSubscripts(base, startLoc, noCalls); + } + parseSubscript(base, startLoc, noCalls, subscriptState) { + if (this.match(18) && this.isLookaheadToken_lt()) { + subscriptState.optionalChainMember = true; + if (noCalls) { + subscriptState.stop = true; + return base; + } + this.next(); + const node = this.startNodeAt(startLoc); + node.callee = base; + node.typeArguments = this.flowParseTypeParameterInstantiationInExpression(); + this.expect(10); + node.arguments = this.parseCallExpressionArguments(); + node.optional = true; + return this.finishCallExpression(node, true); + } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) { + const node = this.startNodeAt(startLoc); + node.callee = base; + const result = this.tryParse(() => { + node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew(); + this.expect(10); + node.arguments = super.parseCallExpressionArguments(); + if (subscriptState.optionalChainMember) { + node.optional = false; + } + return this.finishCallExpression(node, subscriptState.optionalChainMember); + }); + if (result.node) { + if (result.error) this.state = result.failState; + return result.node; + } + } + return super.parseSubscript(base, startLoc, noCalls, subscriptState); + } + parseNewCallee(node) { + super.parseNewCallee(node); + let targs = null; + if (this.shouldParseTypes() && this.match(47)) { + targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node; + } + node.typeArguments = targs; + } + parseAsyncArrowWithTypeParameters(startLoc) { + const node = this.startNodeAt(startLoc); + this.parseFunctionParams(node, false); + if (!this.parseArrow(node)) return; + return super.parseArrowExpression(node, undefined, true); + } + readToken_mult_modulo(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (code === 42 && next === 47 && this.state.hasFlowComment) { + this.state.hasFlowComment = false; + this.state.pos += 2; + this.nextToken(); + return; + } + super.readToken_mult_modulo(code); + } + readToken_pipe_amp(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (code === 124 && next === 125) { + this.finishOp(9, 2); + return; + } + super.readToken_pipe_amp(code); + } + parseTopLevel(file, program) { + const fileNode = super.parseTopLevel(file, program); + if (this.state.hasFlowComment) { + this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition()); + } + return fileNode; + } + skipBlockComment() { + if (this.hasPlugin("flowComments") && this.skipFlowComment()) { + if (this.state.hasFlowComment) { + throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc); + } + this.hasFlowCommentCompletion(); + const commentSkip = this.skipFlowComment(); + if (commentSkip) { + this.state.pos += commentSkip; + this.state.hasFlowComment = true; + } + return; + } + return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/"); + } + skipFlowComment() { + const { + pos + } = this.state; + let shiftToFirstNonWhiteSpace = 2; + while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) { + shiftToFirstNonWhiteSpace++; + } + const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos); + const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1); + if (ch2 === 58 && ch3 === 58) { + return shiftToFirstNonWhiteSpace + 2; + } + if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") { + return shiftToFirstNonWhiteSpace + 12; + } + if (ch2 === 58 && ch3 !== 58) { + return shiftToFirstNonWhiteSpace; + } + return false; + } + hasFlowCommentCompletion() { + const end = this.input.indexOf("*/", this.state.pos); + if (end === -1) { + throw this.raise(Errors.UnterminatedComment, this.state.curPosition()); + } + } + flowEnumErrorBooleanMemberNotInitialized(loc, { + enumName, + memberName + }) { + this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, { + memberName, + enumName + }); + } + flowEnumErrorInvalidMemberInitializer(loc, enumContext) { + return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext); + } + flowEnumErrorNumberMemberNotInitialized(loc, details) { + this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details); + } + flowEnumErrorStringMemberInconsistentlyInitialized(node, details) { + this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details); + } + flowEnumMemberInit() { + const startLoc = this.state.startLoc; + const endOfInit = () => this.match(12) || this.match(8); + switch (this.state.type) { + case 135: + { + const literal = this.parseNumericLiteral(this.state.value); + if (endOfInit()) { + return { + type: "number", + loc: literal.loc.start, + value: literal + }; + } + return { + type: "invalid", + loc: startLoc + }; + } + case 134: + { + const literal = this.parseStringLiteral(this.state.value); + if (endOfInit()) { + return { + type: "string", + loc: literal.loc.start, + value: literal + }; + } + return { + type: "invalid", + loc: startLoc + }; + } + case 85: + case 86: + { + const literal = this.parseBooleanLiteral(this.match(85)); + if (endOfInit()) { + return { + type: "boolean", + loc: literal.loc.start, + value: literal + }; + } + return { + type: "invalid", + loc: startLoc + }; + } + default: + return { + type: "invalid", + loc: startLoc + }; + } + } + flowEnumMemberRaw() { + const loc = this.state.startLoc; + const id = this.parseIdentifier(true); + const init = this.eat(29) ? this.flowEnumMemberInit() : { + type: "none", + loc + }; + return { + id, + init + }; + } + flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) { + const { + explicitType + } = context; + if (explicitType === null) { + return; + } + if (explicitType !== expectedType) { + this.flowEnumErrorInvalidMemberInitializer(loc, context); + } + } + flowEnumMembers({ + enumName, + explicitType + }) { + const seenNames = new Set(); + const members = { + booleanMembers: [], + numberMembers: [], + stringMembers: [], + defaultedMembers: [] + }; + let hasUnknownMembers = false; + while (!this.match(8)) { + if (this.eat(21)) { + hasUnknownMembers = true; + break; + } + const memberNode = this.startNode(); + const { + id, + init + } = this.flowEnumMemberRaw(); + const memberName = id.name; + if (memberName === "") { + continue; + } + if (/^[a-z]/.test(memberName)) { + this.raise(FlowErrors.EnumInvalidMemberName, id, { + memberName, + suggestion: memberName[0].toUpperCase() + memberName.slice(1), + enumName + }); + } + if (seenNames.has(memberName)) { + this.raise(FlowErrors.EnumDuplicateMemberName, id, { + memberName, + enumName + }); + } + seenNames.add(memberName); + const context = { + enumName, + explicitType, + memberName + }; + memberNode.id = id; + switch (init.type) { + case "boolean": + { + this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean"); + memberNode.init = init.value; + members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember")); + break; + } + case "number": + { + this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number"); + memberNode.init = init.value; + members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember")); + break; + } + case "string": + { + this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string"); + memberNode.init = init.value; + members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember")); + break; + } + case "invalid": + { + throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context); + } + case "none": + { + switch (explicitType) { + case "boolean": + this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context); + break; + case "number": + this.flowEnumErrorNumberMemberNotInitialized(init.loc, context); + break; + default: + members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember")); + } + } + } + if (!this.match(8)) { + this.expect(12); + } + } + return { + members, + hasUnknownMembers + }; + } + flowEnumStringMembers(initializedMembers, defaultedMembers, { + enumName + }) { + if (initializedMembers.length === 0) { + return defaultedMembers; + } else if (defaultedMembers.length === 0) { + return initializedMembers; + } else if (defaultedMembers.length > initializedMembers.length) { + for (const member of initializedMembers) { + this.flowEnumErrorStringMemberInconsistentlyInitialized(member, { + enumName + }); + } + return defaultedMembers; + } else { + for (const member of defaultedMembers) { + this.flowEnumErrorStringMemberInconsistentlyInitialized(member, { + enumName + }); + } + return initializedMembers; + } + } + flowEnumParseExplicitType({ + enumName + }) { + if (!this.eatContextual(102)) return null; + if (!tokenIsIdentifier(this.state.type)) { + throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, { + enumName + }); + } + const { + value + } = this.state; + this.next(); + if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") { + this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, { + enumName, + invalidEnumType: value + }); + } + return value; + } + flowEnumBody(node, id) { + const enumName = id.name; + const nameLoc = id.loc.start; + const explicitType = this.flowEnumParseExplicitType({ + enumName + }); + this.expect(5); + const { + members, + hasUnknownMembers + } = this.flowEnumMembers({ + enumName, + explicitType + }); + node.hasUnknownMembers = hasUnknownMembers; + switch (explicitType) { + case "boolean": + node.explicitType = true; + node.members = members.booleanMembers; + this.expect(8); + return this.finishNode(node, "EnumBooleanBody"); + case "number": + node.explicitType = true; + node.members = members.numberMembers; + this.expect(8); + return this.finishNode(node, "EnumNumberBody"); + case "string": + node.explicitType = true; + node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { + enumName + }); + this.expect(8); + return this.finishNode(node, "EnumStringBody"); + case "symbol": + node.members = members.defaultedMembers; + this.expect(8); + return this.finishNode(node, "EnumSymbolBody"); + default: + { + const empty = () => { + node.members = []; + this.expect(8); + return this.finishNode(node, "EnumStringBody"); + }; + node.explicitType = false; + const boolsLen = members.booleanMembers.length; + const numsLen = members.numberMembers.length; + const strsLen = members.stringMembers.length; + const defaultedLen = members.defaultedMembers.length; + if (!boolsLen && !numsLen && !strsLen && !defaultedLen) { + return empty(); + } else if (!boolsLen && !numsLen) { + node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { + enumName + }); + this.expect(8); + return this.finishNode(node, "EnumStringBody"); + } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) { + for (const member of members.defaultedMembers) { + this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, { + enumName, + memberName: member.id.name + }); + } + node.members = members.booleanMembers; + this.expect(8); + return this.finishNode(node, "EnumBooleanBody"); + } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) { + for (const member of members.defaultedMembers) { + this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, { + enumName, + memberName: member.id.name + }); + } + node.members = members.numberMembers; + this.expect(8); + return this.finishNode(node, "EnumNumberBody"); + } else { + this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, { + enumName + }); + return empty(); + } + } + } + } + flowParseEnumDeclaration(node) { + const id = this.parseIdentifier(); + node.id = id; + node.body = this.flowEnumBody(this.startNode(), id); + return this.finishNode(node, "EnumDeclaration"); + } + jsxParseOpeningElementAfterName(node) { + if (this.shouldParseTypes()) { + if (this.match(47) || this.match(51)) { + node.typeArguments = this.flowParseTypeParameterInstantiationInExpression(); + } + } + return super.jsxParseOpeningElementAfterName(node); + } + isLookaheadToken_lt() { + const next = this.nextTokenStart(); + if (this.input.charCodeAt(next) === 60) { + const afterNext = this.input.charCodeAt(next + 1); + return afterNext !== 60 && afterNext !== 61; + } + return false; + } + reScan_lt_gt() { + const { + type + } = this.state; + if (type === 47) { + this.state.pos -= 1; + this.readToken_lt(); + } else if (type === 48) { + this.state.pos -= 1; + this.readToken_gt(); + } + } + reScan_lt() { + const { + type + } = this.state; + if (type === 51) { + this.state.pos -= 2; + this.finishOp(47, 1); + return 47; + } + return type; + } + maybeUnwrapTypeCastExpression(node) { + return node.type === "TypeCastExpression" ? node.expression : node; + } +}; +const entities = { + __proto__: null, + quot: "\u0022", + amp: "&", + apos: "\u0027", + lt: "<", + gt: ">", + nbsp: "\u00A0", + iexcl: "\u00A1", + cent: "\u00A2", + pound: "\u00A3", + curren: "\u00A4", + yen: "\u00A5", + brvbar: "\u00A6", + sect: "\u00A7", + uml: "\u00A8", + copy: "\u00A9", + ordf: "\u00AA", + laquo: "\u00AB", + not: "\u00AC", + shy: "\u00AD", + reg: "\u00AE", + macr: "\u00AF", + deg: "\u00B0", + plusmn: "\u00B1", + sup2: "\u00B2", + sup3: "\u00B3", + acute: "\u00B4", + micro: "\u00B5", + para: "\u00B6", + middot: "\u00B7", + cedil: "\u00B8", + sup1: "\u00B9", + ordm: "\u00BA", + raquo: "\u00BB", + frac14: "\u00BC", + frac12: "\u00BD", + frac34: "\u00BE", + iquest: "\u00BF", + Agrave: "\u00C0", + Aacute: "\u00C1", + Acirc: "\u00C2", + Atilde: "\u00C3", + Auml: "\u00C4", + Aring: "\u00C5", + AElig: "\u00C6", + Ccedil: "\u00C7", + Egrave: "\u00C8", + Eacute: "\u00C9", + Ecirc: "\u00CA", + Euml: "\u00CB", + Igrave: "\u00CC", + Iacute: "\u00CD", + Icirc: "\u00CE", + Iuml: "\u00CF", + ETH: "\u00D0", + Ntilde: "\u00D1", + Ograve: "\u00D2", + Oacute: "\u00D3", + Ocirc: "\u00D4", + Otilde: "\u00D5", + Ouml: "\u00D6", + times: "\u00D7", + Oslash: "\u00D8", + Ugrave: "\u00D9", + Uacute: "\u00DA", + Ucirc: "\u00DB", + Uuml: "\u00DC", + Yacute: "\u00DD", + THORN: "\u00DE", + szlig: "\u00DF", + agrave: "\u00E0", + aacute: "\u00E1", + acirc: "\u00E2", + atilde: "\u00E3", + auml: "\u00E4", + aring: "\u00E5", + aelig: "\u00E6", + ccedil: "\u00E7", + egrave: "\u00E8", + eacute: "\u00E9", + ecirc: "\u00EA", + euml: "\u00EB", + igrave: "\u00EC", + iacute: "\u00ED", + icirc: "\u00EE", + iuml: "\u00EF", + eth: "\u00F0", + ntilde: "\u00F1", + ograve: "\u00F2", + oacute: "\u00F3", + ocirc: "\u00F4", + otilde: "\u00F5", + ouml: "\u00F6", + divide: "\u00F7", + oslash: "\u00F8", + ugrave: "\u00F9", + uacute: "\u00FA", + ucirc: "\u00FB", + uuml: "\u00FC", + yacute: "\u00FD", + thorn: "\u00FE", + yuml: "\u00FF", + OElig: "\u0152", + oelig: "\u0153", + Scaron: "\u0160", + scaron: "\u0161", + Yuml: "\u0178", + fnof: "\u0192", + circ: "\u02C6", + tilde: "\u02DC", + Alpha: "\u0391", + Beta: "\u0392", + Gamma: "\u0393", + Delta: "\u0394", + Epsilon: "\u0395", + Zeta: "\u0396", + Eta: "\u0397", + Theta: "\u0398", + Iota: "\u0399", + Kappa: "\u039A", + Lambda: "\u039B", + Mu: "\u039C", + Nu: "\u039D", + Xi: "\u039E", + Omicron: "\u039F", + Pi: "\u03A0", + Rho: "\u03A1", + Sigma: "\u03A3", + Tau: "\u03A4", + Upsilon: "\u03A5", + Phi: "\u03A6", + Chi: "\u03A7", + Psi: "\u03A8", + Omega: "\u03A9", + alpha: "\u03B1", + beta: "\u03B2", + gamma: "\u03B3", + delta: "\u03B4", + epsilon: "\u03B5", + zeta: "\u03B6", + eta: "\u03B7", + theta: "\u03B8", + iota: "\u03B9", + kappa: "\u03BA", + lambda: "\u03BB", + mu: "\u03BC", + nu: "\u03BD", + xi: "\u03BE", + omicron: "\u03BF", + pi: "\u03C0", + rho: "\u03C1", + sigmaf: "\u03C2", + sigma: "\u03C3", + tau: "\u03C4", + upsilon: "\u03C5", + phi: "\u03C6", + chi: "\u03C7", + psi: "\u03C8", + omega: "\u03C9", + thetasym: "\u03D1", + upsih: "\u03D2", + piv: "\u03D6", + ensp: "\u2002", + emsp: "\u2003", + thinsp: "\u2009", + zwnj: "\u200C", + zwj: "\u200D", + lrm: "\u200E", + rlm: "\u200F", + ndash: "\u2013", + mdash: "\u2014", + lsquo: "\u2018", + rsquo: "\u2019", + sbquo: "\u201A", + ldquo: "\u201C", + rdquo: "\u201D", + bdquo: "\u201E", + dagger: "\u2020", + Dagger: "\u2021", + bull: "\u2022", + hellip: "\u2026", + permil: "\u2030", + prime: "\u2032", + Prime: "\u2033", + lsaquo: "\u2039", + rsaquo: "\u203A", + oline: "\u203E", + frasl: "\u2044", + euro: "\u20AC", + image: "\u2111", + weierp: "\u2118", + real: "\u211C", + trade: "\u2122", + alefsym: "\u2135", + larr: "\u2190", + uarr: "\u2191", + rarr: "\u2192", + darr: "\u2193", + harr: "\u2194", + crarr: "\u21B5", + lArr: "\u21D0", + uArr: "\u21D1", + rArr: "\u21D2", + dArr: "\u21D3", + hArr: "\u21D4", + forall: "\u2200", + part: "\u2202", + exist: "\u2203", + empty: "\u2205", + nabla: "\u2207", + isin: "\u2208", + notin: "\u2209", + ni: "\u220B", + prod: "\u220F", + sum: "\u2211", + minus: "\u2212", + lowast: "\u2217", + radic: "\u221A", + prop: "\u221D", + infin: "\u221E", + ang: "\u2220", + and: "\u2227", + or: "\u2228", + cap: "\u2229", + cup: "\u222A", + int: "\u222B", + there4: "\u2234", + sim: "\u223C", + cong: "\u2245", + asymp: "\u2248", + ne: "\u2260", + equiv: "\u2261", + le: "\u2264", + ge: "\u2265", + sub: "\u2282", + sup: "\u2283", + nsub: "\u2284", + sube: "\u2286", + supe: "\u2287", + oplus: "\u2295", + otimes: "\u2297", + perp: "\u22A5", + sdot: "\u22C5", + lceil: "\u2308", + rceil: "\u2309", + lfloor: "\u230A", + rfloor: "\u230B", + lang: "\u2329", + rang: "\u232A", + loz: "\u25CA", + spades: "\u2660", + clubs: "\u2663", + hearts: "\u2665", + diams: "\u2666" +}; +const lineBreak = /\r\n|[\r\n\u2028\u2029]/; +const lineBreakG = new RegExp(lineBreak.source, "g"); +function isNewLine(code) { + switch (code) { + case 10: + case 13: + case 8232: + case 8233: + return true; + default: + return false; + } +} +function hasNewLine(input, start, end) { + for (let i = start; i < end; i++) { + if (isNewLine(input.charCodeAt(i))) { + return true; + } + } + return false; +} +const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; +const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g; +function isWhitespace(code) { + switch (code) { + case 0x0009: + case 0x000b: + case 0x000c: + case 32: + case 160: + case 5760: + case 0x2000: + case 0x2001: + case 0x2002: + case 0x2003: + case 0x2004: + case 0x2005: + case 0x2006: + case 0x2007: + case 0x2008: + case 0x2009: + case 0x200a: + case 0x202f: + case 0x205f: + case 0x3000: + case 0xfeff: + return true; + default: + return false; + } +} +const JsxErrors = ParseErrorEnum`jsx`({ + AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.", + MissingClosingTagElement: ({ + openingTagName + }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`, + MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.", + UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?", + UnexpectedToken: ({ + unexpected, + HTMLEntity + }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`, + UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.", + UnterminatedJsxContent: "Unterminated JSX contents.", + UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...?" +}); +function isFragment(object) { + return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false; +} +function getQualifiedJSXName(object) { + if (object.type === "JSXIdentifier") { + return object.name; + } + if (object.type === "JSXNamespacedName") { + return object.namespace.name + ":" + object.name.name; + } + if (object.type === "JSXMemberExpression") { + return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property); + } + throw new Error("Node had unexpected type: " + object.type); +} +var jsx = superClass => class JSXParserMixin extends superClass { + jsxReadToken() { + let out = ""; + let chunkStart = this.state.pos; + for (;;) { + if (this.state.pos >= this.length) { + throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc); + } + const ch = this.input.charCodeAt(this.state.pos); + switch (ch) { + case 60: + case 123: + if (this.state.pos === this.state.start) { + if (ch === 60 && this.state.canStartJSXElement) { + ++this.state.pos; + this.finishToken(143); + } else { + super.getTokenFromCode(ch); + } + return; + } + out += this.input.slice(chunkStart, this.state.pos); + this.finishToken(142, out); + return; + case 38: + out += this.input.slice(chunkStart, this.state.pos); + out += this.jsxReadEntity(); + chunkStart = this.state.pos; + break; + case 62: + case 125: + default: + if (isNewLine(ch)) { + out += this.input.slice(chunkStart, this.state.pos); + out += this.jsxReadNewLine(true); + chunkStart = this.state.pos; + } else { + ++this.state.pos; + } + } + } + } + jsxReadNewLine(normalizeCRLF) { + const ch = this.input.charCodeAt(this.state.pos); + let out; + ++this.state.pos; + if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) { + ++this.state.pos; + out = normalizeCRLF ? "\n" : "\r\n"; + } else { + out = String.fromCharCode(ch); + } + ++this.state.curLine; + this.state.lineStart = this.state.pos; + return out; + } + jsxReadString(quote) { + let out = ""; + let chunkStart = ++this.state.pos; + for (;;) { + if (this.state.pos >= this.length) { + throw this.raise(Errors.UnterminatedString, this.state.startLoc); + } + const ch = this.input.charCodeAt(this.state.pos); + if (ch === quote) break; + if (ch === 38) { + out += this.input.slice(chunkStart, this.state.pos); + out += this.jsxReadEntity(); + chunkStart = this.state.pos; + } else if (isNewLine(ch)) { + out += this.input.slice(chunkStart, this.state.pos); + out += this.jsxReadNewLine(false); + chunkStart = this.state.pos; + } else { + ++this.state.pos; + } + } + out += this.input.slice(chunkStart, this.state.pos++); + this.finishToken(134, out); + } + jsxReadEntity() { + const startPos = ++this.state.pos; + if (this.codePointAtPos(this.state.pos) === 35) { + ++this.state.pos; + let radix = 10; + if (this.codePointAtPos(this.state.pos) === 120) { + radix = 16; + ++this.state.pos; + } + const codePoint = this.readInt(radix, undefined, false, "bail"); + if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) { + ++this.state.pos; + return String.fromCodePoint(codePoint); + } + } else { + let count = 0; + let semi = false; + while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) { + ++this.state.pos; + } + if (semi) { + const desc = this.input.slice(startPos, this.state.pos); + const entity = entities[desc]; + ++this.state.pos; + if (entity) { + return entity; + } + } + } + this.state.pos = startPos; + return "&"; + } + jsxReadWord() { + let ch; + const start = this.state.pos; + do { + ch = this.input.charCodeAt(++this.state.pos); + } while (isIdentifierChar(ch) || ch === 45); + this.finishToken(141, this.input.slice(start, this.state.pos)); + } + jsxParseIdentifier() { + const node = this.startNode(); + if (this.match(141)) { + node.name = this.state.value; + } else if (tokenIsKeyword(this.state.type)) { + node.name = tokenLabelName(this.state.type); + } else { + this.unexpected(); + } + this.next(); + return this.finishNode(node, "JSXIdentifier"); + } + jsxParseNamespacedName() { + const startLoc = this.state.startLoc; + const name = this.jsxParseIdentifier(); + if (!this.eat(14)) return name; + const node = this.startNodeAt(startLoc); + node.namespace = name; + node.name = this.jsxParseIdentifier(); + return this.finishNode(node, "JSXNamespacedName"); + } + jsxParseElementName() { + const startLoc = this.state.startLoc; + let node = this.jsxParseNamespacedName(); + if (node.type === "JSXNamespacedName") { + return node; + } + while (this.eat(16)) { + const newNode = this.startNodeAt(startLoc); + newNode.object = node; + newNode.property = this.jsxParseIdentifier(); + node = this.finishNode(newNode, "JSXMemberExpression"); + } + return node; + } + jsxParseAttributeValue() { + let node; + switch (this.state.type) { + case 5: + node = this.startNode(); + this.setContext(types.brace); + this.next(); + node = this.jsxParseExpressionContainer(node, types.j_oTag); + if (node.expression.type === "JSXEmptyExpression") { + this.raise(JsxErrors.AttributeIsEmpty, node); + } + return node; + case 143: + case 134: + return this.parseExprAtom(); + default: + throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc); + } + } + jsxParseEmptyExpression() { + const node = this.startNodeAt(this.state.lastTokEndLoc); + return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc); + } + jsxParseSpreadChild(node) { + this.next(); + node.expression = this.parseExpression(); + this.setContext(types.j_expr); + this.state.canStartJSXElement = true; + this.expect(8); + return this.finishNode(node, "JSXSpreadChild"); + } + jsxParseExpressionContainer(node, previousContext) { + if (this.match(8)) { + node.expression = this.jsxParseEmptyExpression(); + } else { + const expression = this.parseExpression(); + node.expression = expression; + } + this.setContext(previousContext); + this.state.canStartJSXElement = true; + this.expect(8); + return this.finishNode(node, "JSXExpressionContainer"); + } + jsxParseAttribute() { + const node = this.startNode(); + if (this.match(5)) { + this.setContext(types.brace); + this.next(); + this.expect(21); + node.argument = this.parseMaybeAssignAllowIn(); + this.setContext(types.j_oTag); + this.state.canStartJSXElement = true; + this.expect(8); + return this.finishNode(node, "JSXSpreadAttribute"); + } + node.name = this.jsxParseNamespacedName(); + node.value = this.eat(29) ? this.jsxParseAttributeValue() : null; + return this.finishNode(node, "JSXAttribute"); + } + jsxParseOpeningElementAt(startLoc) { + const node = this.startNodeAt(startLoc); + if (this.eat(144)) { + return this.finishNode(node, "JSXOpeningFragment"); + } + node.name = this.jsxParseElementName(); + return this.jsxParseOpeningElementAfterName(node); + } + jsxParseOpeningElementAfterName(node) { + const attributes = []; + while (!this.match(56) && !this.match(144)) { + attributes.push(this.jsxParseAttribute()); + } + node.attributes = attributes; + node.selfClosing = this.eat(56); + this.expect(144); + return this.finishNode(node, "JSXOpeningElement"); + } + jsxParseClosingElementAt(startLoc) { + const node = this.startNodeAt(startLoc); + if (this.eat(144)) { + return this.finishNode(node, "JSXClosingFragment"); + } + node.name = this.jsxParseElementName(); + this.expect(144); + return this.finishNode(node, "JSXClosingElement"); + } + jsxParseElementAt(startLoc) { + const node = this.startNodeAt(startLoc); + const children = []; + const openingElement = this.jsxParseOpeningElementAt(startLoc); + let closingElement = null; + if (!openingElement.selfClosing) { + contents: for (;;) { + switch (this.state.type) { + case 143: + startLoc = this.state.startLoc; + this.next(); + if (this.eat(56)) { + closingElement = this.jsxParseClosingElementAt(startLoc); + break contents; + } + children.push(this.jsxParseElementAt(startLoc)); + break; + case 142: + children.push(this.parseLiteral(this.state.value, "JSXText")); + break; + case 5: + { + const node = this.startNode(); + this.setContext(types.brace); + this.next(); + if (this.match(21)) { + children.push(this.jsxParseSpreadChild(node)); + } else { + children.push(this.jsxParseExpressionContainer(node, types.j_expr)); + } + break; + } + default: + this.unexpected(); + } + } + if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) { + this.raise(JsxErrors.MissingClosingTagFragment, closingElement); + } else if (!isFragment(openingElement) && isFragment(closingElement)) { + this.raise(JsxErrors.MissingClosingTagElement, closingElement, { + openingTagName: getQualifiedJSXName(openingElement.name) + }); + } else if (!isFragment(openingElement) && !isFragment(closingElement)) { + if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) { + this.raise(JsxErrors.MissingClosingTagElement, closingElement, { + openingTagName: getQualifiedJSXName(openingElement.name) + }); + } + } + } + if (isFragment(openingElement)) { + node.openingFragment = openingElement; + node.closingFragment = closingElement; + } else { + node.openingElement = openingElement; + node.closingElement = closingElement; + } + node.children = children; + if (this.match(47)) { + throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc); + } + return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement"); + } + jsxParseElement() { + const startLoc = this.state.startLoc; + this.next(); + return this.jsxParseElementAt(startLoc); + } + setContext(newContext) { + const { + context + } = this.state; + context[context.length - 1] = newContext; + } + parseExprAtom(refExpressionErrors) { + if (this.match(143)) { + return this.jsxParseElement(); + } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) { + this.replaceToken(143); + return this.jsxParseElement(); + } else { + return super.parseExprAtom(refExpressionErrors); + } + } + skipSpace() { + const curContext = this.curContext(); + if (!curContext.preserveSpace) super.skipSpace(); + } + getTokenFromCode(code) { + const context = this.curContext(); + if (context === types.j_expr) { + this.jsxReadToken(); + return; + } + if (context === types.j_oTag || context === types.j_cTag) { + if (isIdentifierStart(code)) { + this.jsxReadWord(); + return; + } + if (code === 62) { + ++this.state.pos; + this.finishToken(144); + return; + } + if ((code === 34 || code === 39) && context === types.j_oTag) { + this.jsxReadString(code); + return; + } + } + if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) { + ++this.state.pos; + this.finishToken(143); + return; + } + super.getTokenFromCode(code); + } + updateContext(prevType) { + const { + context, + type + } = this.state; + if (type === 56 && prevType === 143) { + context.splice(-2, 2, types.j_cTag); + this.state.canStartJSXElement = false; + } else if (type === 143) { + context.push(types.j_oTag); + } else if (type === 144) { + const out = context[context.length - 1]; + if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) { + context.pop(); + this.state.canStartJSXElement = context[context.length - 1] === types.j_expr; + } else { + this.setContext(types.j_expr); + this.state.canStartJSXElement = true; + } + } else { + this.state.canStartJSXElement = tokenComesBeforeExpression(type); + } + } +}; +class TypeScriptScope extends Scope { + constructor(...args) { + super(...args); + this.tsNames = new Map(); + } +} +class TypeScriptScopeHandler extends ScopeHandler { + constructor(...args) { + super(...args); + this.importsStack = []; + } + createScope(flags) { + this.importsStack.push(new Set()); + return new TypeScriptScope(flags); + } + enter(flags) { + if (flags === 1024) { + this.importsStack.push(new Set()); + } + super.enter(flags); + } + exit() { + const flags = super.exit(); + if (flags === 1024) { + this.importsStack.pop(); + } + return flags; + } + hasImport(name, allowShadow) { + const len = this.importsStack.length; + if (this.importsStack[len - 1].has(name)) { + return true; + } + if (!allowShadow && len > 1) { + for (let i = 0; i < len - 1; i++) { + if (this.importsStack[i].has(name)) return true; + } + } + return false; + } + declareName(name, bindingType, loc) { + if (bindingType & 4096) { + if (this.hasImport(name, true)) { + this.parser.raise(Errors.VarRedeclaration, loc, { + identifierName: name + }); + } + this.importsStack[this.importsStack.length - 1].add(name); + return; + } + const scope = this.currentScope(); + let type = scope.tsNames.get(name) || 0; + if (bindingType & 1024) { + this.maybeExportDefined(scope, name); + scope.tsNames.set(name, type | 16); + return; + } + super.declareName(name, bindingType, loc); + if (bindingType & 2) { + if (!(bindingType & 1)) { + this.checkRedeclarationInScope(scope, name, bindingType, loc); + this.maybeExportDefined(scope, name); + } + type = type | 1; + } + if (bindingType & 256) { + type = type | 2; + } + if (bindingType & 512) { + type = type | 4; + } + if (bindingType & 128) { + type = type | 8; + } + if (type) scope.tsNames.set(name, type); + } + isRedeclaredInScope(scope, name, bindingType) { + const type = scope.tsNames.get(name); + if ((type & 2) > 0) { + if (bindingType & 256) { + const isConst = !!(bindingType & 512); + const wasConst = (type & 4) > 0; + return isConst !== wasConst; + } + return true; + } + if (bindingType & 128 && (type & 8) > 0) { + if (scope.names.get(name) & 2) { + return !!(bindingType & 1); + } else { + return false; + } + } + if (bindingType & 2 && (type & 1) > 0) { + return true; + } + return super.isRedeclaredInScope(scope, name, bindingType); + } + checkLocalExport(id) { + const { + name + } = id; + if (this.hasImport(name)) return; + const len = this.scopeStack.length; + for (let i = len - 1; i >= 0; i--) { + const scope = this.scopeStack[i]; + const type = scope.tsNames.get(name); + if ((type & 1) > 0 || (type & 16) > 0) { + return; + } + } + super.checkLocalExport(id); + } +} +class ProductionParameterHandler { + constructor() { + this.stacks = []; + } + enter(flags) { + this.stacks.push(flags); + } + exit() { + this.stacks.pop(); + } + currentFlags() { + return this.stacks[this.stacks.length - 1]; + } + get hasAwait() { + return (this.currentFlags() & 2) > 0; + } + get hasYield() { + return (this.currentFlags() & 1) > 0; + } + get hasReturn() { + return (this.currentFlags() & 4) > 0; + } + get hasIn() { + return (this.currentFlags() & 8) > 0; + } +} +function functionFlags(isAsync, isGenerator) { + return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0); +} +class BaseParser { + constructor() { + this.sawUnambiguousESM = false; + this.ambiguousScriptDifferentAst = false; + } + sourceToOffsetPos(sourcePos) { + return sourcePos + this.startIndex; + } + offsetToSourcePos(offsetPos) { + return offsetPos - this.startIndex; + } + hasPlugin(pluginConfig) { + if (typeof pluginConfig === "string") { + return this.plugins.has(pluginConfig); + } else { + const [pluginName, pluginOptions] = pluginConfig; + if (!this.hasPlugin(pluginName)) { + return false; + } + const actualOptions = this.plugins.get(pluginName); + for (const key of Object.keys(pluginOptions)) { + if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) { + return false; + } + } + return true; + } + } + getPluginOption(plugin, name) { + var _this$plugins$get; + return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name]; + } +} +function setTrailingComments(node, comments) { + if (node.trailingComments === undefined) { + node.trailingComments = comments; + } else { + node.trailingComments.unshift(...comments); + } +} +function setLeadingComments(node, comments) { + if (node.leadingComments === undefined) { + node.leadingComments = comments; + } else { + node.leadingComments.unshift(...comments); + } +} +function setInnerComments(node, comments) { + if (node.innerComments === undefined) { + node.innerComments = comments; + } else { + node.innerComments.unshift(...comments); + } +} +function adjustInnerComments(node, elements, commentWS) { + let lastElement = null; + let i = elements.length; + while (lastElement === null && i > 0) { + lastElement = elements[--i]; + } + if (lastElement === null || lastElement.start > commentWS.start) { + setInnerComments(node, commentWS.comments); + } else { + setTrailingComments(lastElement, commentWS.comments); + } +} +class CommentsParser extends BaseParser { + addComment(comment) { + if (this.filename) comment.loc.filename = this.filename; + const { + commentsLen + } = this.state; + if (this.comments.length !== commentsLen) { + this.comments.length = commentsLen; + } + this.comments.push(comment); + this.state.commentsLen++; + } + processComment(node) { + const { + commentStack + } = this.state; + const commentStackLength = commentStack.length; + if (commentStackLength === 0) return; + let i = commentStackLength - 1; + const lastCommentWS = commentStack[i]; + if (lastCommentWS.start === node.end) { + lastCommentWS.leadingNode = node; + i--; + } + const { + start: nodeStart + } = node; + for (; i >= 0; i--) { + const commentWS = commentStack[i]; + const commentEnd = commentWS.end; + if (commentEnd > nodeStart) { + commentWS.containingNode = node; + this.finalizeComment(commentWS); + commentStack.splice(i, 1); + } else { + if (commentEnd === nodeStart) { + commentWS.trailingNode = node; + } + break; + } + } + } + finalizeComment(commentWS) { + var _node$options; + const { + comments + } = commentWS; + if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) { + if (commentWS.leadingNode !== null) { + setTrailingComments(commentWS.leadingNode, comments); + } + if (commentWS.trailingNode !== null) { + setLeadingComments(commentWS.trailingNode, comments); + } + } else { + const node = commentWS.containingNode; + const commentStart = commentWS.start; + if (this.input.charCodeAt(this.offsetToSourcePos(commentStart) - 1) === 44) { + switch (node.type) { + case "ObjectExpression": + case "ObjectPattern": + adjustInnerComments(node, node.properties, commentWS); + break; + case "CallExpression": + case "OptionalCallExpression": + adjustInnerComments(node, node.arguments, commentWS); + break; + case "ImportExpression": + adjustInnerComments(node, [node.source, (_node$options = node.options) != null ? _node$options : null], commentWS); + break; + case "FunctionDeclaration": + case "FunctionExpression": + case "ArrowFunctionExpression": + case "ObjectMethod": + case "ClassMethod": + case "ClassPrivateMethod": + adjustInnerComments(node, node.params, commentWS); + break; + case "ArrayExpression": + case "ArrayPattern": + adjustInnerComments(node, node.elements, commentWS); + break; + case "ExportNamedDeclaration": + case "ImportDeclaration": + adjustInnerComments(node, node.specifiers, commentWS); + break; + case "TSEnumDeclaration": + adjustInnerComments(node, node.members, commentWS); + break; + case "TSEnumBody": + adjustInnerComments(node, node.members, commentWS); + break; + default: + { + if (node.type === "RecordExpression") { + adjustInnerComments(node, node.properties, commentWS); + break; + } + if (node.type === "TupleExpression") { + adjustInnerComments(node, node.elements, commentWS); + break; + } + setInnerComments(node, comments); + } + } + } else { + setInnerComments(node, comments); + } + } + } + finalizeRemainingComments() { + const { + commentStack + } = this.state; + for (let i = commentStack.length - 1; i >= 0; i--) { + this.finalizeComment(commentStack[i]); + } + this.state.commentStack = []; + } + resetPreviousNodeTrailingComments(node) { + const { + commentStack + } = this.state; + const { + length + } = commentStack; + if (length === 0) return; + const commentWS = commentStack[length - 1]; + if (commentWS.leadingNode === node) { + commentWS.leadingNode = null; + } + } + takeSurroundingComments(node, start, end) { + const { + commentStack + } = this.state; + const commentStackLength = commentStack.length; + if (commentStackLength === 0) return; + let i = commentStackLength - 1; + for (; i >= 0; i--) { + const commentWS = commentStack[i]; + const commentEnd = commentWS.end; + const commentStart = commentWS.start; + if (commentStart === end) { + commentWS.leadingNode = node; + } else if (commentEnd === start) { + commentWS.trailingNode = node; + } else if (commentEnd < start) { + break; + } + } + } +} +class State { + constructor() { + this.flags = 1024; + this.startIndex = void 0; + this.curLine = void 0; + this.lineStart = void 0; + this.startLoc = void 0; + this.endLoc = void 0; + this.errors = []; + this.potentialArrowAt = -1; + this.noArrowAt = []; + this.noArrowParamsConversionAt = []; + this.topicContext = { + maxNumOfResolvableTopics: 0, + maxTopicIndex: null + }; + this.labels = []; + this.commentsLen = 0; + this.commentStack = []; + this.pos = 0; + this.type = 140; + this.value = null; + this.start = 0; + this.end = 0; + this.lastTokEndLoc = null; + this.lastTokStartLoc = null; + this.context = [types.brace]; + this.firstInvalidTemplateEscapePos = null; + this.strictErrors = new Map(); + this.tokensLength = 0; + } + get strict() { + return (this.flags & 1) > 0; + } + set strict(v) { + if (v) this.flags |= 1;else this.flags &= -2; + } + init({ + strictMode, + sourceType, + startIndex, + startLine, + startColumn + }) { + this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module"; + this.startIndex = startIndex; + this.curLine = startLine; + this.lineStart = -startColumn; + this.startLoc = this.endLoc = new Position(startLine, startColumn, startIndex); + } + get maybeInArrowParameters() { + return (this.flags & 2) > 0; + } + set maybeInArrowParameters(v) { + if (v) this.flags |= 2;else this.flags &= -3; + } + get inType() { + return (this.flags & 4) > 0; + } + set inType(v) { + if (v) this.flags |= 4;else this.flags &= -5; + } + get noAnonFunctionType() { + return (this.flags & 8) > 0; + } + set noAnonFunctionType(v) { + if (v) this.flags |= 8;else this.flags &= -9; + } + get hasFlowComment() { + return (this.flags & 16) > 0; + } + set hasFlowComment(v) { + if (v) this.flags |= 16;else this.flags &= -17; + } + get isAmbientContext() { + return (this.flags & 32) > 0; + } + set isAmbientContext(v) { + if (v) this.flags |= 32;else this.flags &= -33; + } + get inAbstractClass() { + return (this.flags & 64) > 0; + } + set inAbstractClass(v) { + if (v) this.flags |= 64;else this.flags &= -65; + } + get inDisallowConditionalTypesContext() { + return (this.flags & 128) > 0; + } + set inDisallowConditionalTypesContext(v) { + if (v) this.flags |= 128;else this.flags &= -129; + } + get soloAwait() { + return (this.flags & 256) > 0; + } + set soloAwait(v) { + if (v) this.flags |= 256;else this.flags &= -257; + } + get inFSharpPipelineDirectBody() { + return (this.flags & 512) > 0; + } + set inFSharpPipelineDirectBody(v) { + if (v) this.flags |= 512;else this.flags &= -513; + } + get canStartJSXElement() { + return (this.flags & 1024) > 0; + } + set canStartJSXElement(v) { + if (v) this.flags |= 1024;else this.flags &= -1025; + } + get containsEsc() { + return (this.flags & 2048) > 0; + } + set containsEsc(v) { + if (v) this.flags |= 2048;else this.flags &= -2049; + } + get hasTopLevelAwait() { + return (this.flags & 4096) > 0; + } + set hasTopLevelAwait(v) { + if (v) this.flags |= 4096;else this.flags &= -4097; + } + curPosition() { + return new Position(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex); + } + clone() { + const state = new State(); + state.flags = this.flags; + state.startIndex = this.startIndex; + state.curLine = this.curLine; + state.lineStart = this.lineStart; + state.startLoc = this.startLoc; + state.endLoc = this.endLoc; + state.errors = this.errors.slice(); + state.potentialArrowAt = this.potentialArrowAt; + state.noArrowAt = this.noArrowAt.slice(); + state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice(); + state.topicContext = this.topicContext; + state.labels = this.labels.slice(); + state.commentsLen = this.commentsLen; + state.commentStack = this.commentStack.slice(); + state.pos = this.pos; + state.type = this.type; + state.value = this.value; + state.start = this.start; + state.end = this.end; + state.lastTokEndLoc = this.lastTokEndLoc; + state.lastTokStartLoc = this.lastTokStartLoc; + state.context = this.context.slice(); + state.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos; + state.strictErrors = this.strictErrors; + state.tokensLength = this.tokensLength; + return state; + } +} +var _isDigit = function isDigit(code) { + return code >= 48 && code <= 57; +}; +const forbiddenNumericSeparatorSiblings = { + decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]), + hex: new Set([46, 88, 95, 120]) +}; +const isAllowedNumericSeparatorSibling = { + bin: ch => ch === 48 || ch === 49, + oct: ch => ch >= 48 && ch <= 55, + dec: ch => ch >= 48 && ch <= 57, + hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102 +}; +function readStringContents(type, input, pos, lineStart, curLine, errors) { + const initialPos = pos; + const initialLineStart = lineStart; + const initialCurLine = curLine; + let out = ""; + let firstInvalidLoc = null; + let chunkStart = pos; + const { + length + } = input; + for (;;) { + if (pos >= length) { + errors.unterminated(initialPos, initialLineStart, initialCurLine); + out += input.slice(chunkStart, pos); + break; + } + const ch = input.charCodeAt(pos); + if (isStringEnd(type, ch, input, pos)) { + out += input.slice(chunkStart, pos); + break; + } + if (ch === 92) { + out += input.slice(chunkStart, pos); + const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors); + if (res.ch === null && !firstInvalidLoc) { + firstInvalidLoc = { + pos, + lineStart, + curLine + }; + } else { + out += res.ch; + } + ({ + pos, + lineStart, + curLine + } = res); + chunkStart = pos; + } else if (ch === 8232 || ch === 8233) { + ++pos; + ++curLine; + lineStart = pos; + } else if (ch === 10 || ch === 13) { + if (type === "template") { + out += input.slice(chunkStart, pos) + "\n"; + ++pos; + if (ch === 13 && input.charCodeAt(pos) === 10) { + ++pos; + } + ++curLine; + chunkStart = lineStart = pos; + } else { + errors.unterminated(initialPos, initialLineStart, initialCurLine); + } + } else { + ++pos; + } + } + return { + pos, + str: out, + firstInvalidLoc, + lineStart, + curLine, + containsInvalid: !!firstInvalidLoc + }; +} +function isStringEnd(type, ch, input, pos) { + if (type === "template") { + return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123; + } + return ch === (type === "double" ? 34 : 39); +} +function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) { + const throwOnInvalid = !inTemplate; + pos++; + const res = ch => ({ + pos, + ch, + lineStart, + curLine + }); + const ch = input.charCodeAt(pos++); + switch (ch) { + case 110: + return res("\n"); + case 114: + return res("\r"); + case 120: + { + let code; + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors)); + return res(code === null ? null : String.fromCharCode(code)); + } + case 117: + { + let code; + ({ + code, + pos + } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors)); + return res(code === null ? null : String.fromCodePoint(code)); + } + case 116: + return res("\t"); + case 98: + return res("\b"); + case 118: + return res("\u000b"); + case 102: + return res("\f"); + case 13: + if (input.charCodeAt(pos) === 10) { + ++pos; + } + case 10: + lineStart = pos; + ++curLine; + case 8232: + case 8233: + return res(""); + case 56: + case 57: + if (inTemplate) { + return res(null); + } else { + errors.strictNumericEscape(pos - 1, lineStart, curLine); + } + default: + if (ch >= 48 && ch <= 55) { + const startPos = pos - 1; + const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2)); + let octalStr = match[0]; + let octal = parseInt(octalStr, 8); + if (octal > 255) { + octalStr = octalStr.slice(0, -1); + octal = parseInt(octalStr, 8); + } + pos += octalStr.length - 1; + const next = input.charCodeAt(pos); + if (octalStr !== "0" || next === 56 || next === 57) { + if (inTemplate) { + return res(null); + } else { + errors.strictNumericEscape(startPos, lineStart, curLine); + } + } + return res(String.fromCharCode(octal)); + } + return res(String.fromCharCode(ch)); + } +} +function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) { + const initialPos = pos; + let n; + ({ + n, + pos + } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid)); + if (n === null) { + if (throwOnInvalid) { + errors.invalidEscapeSequence(initialPos, lineStart, curLine); + } else { + pos = initialPos - 1; + } + } + return { + code: n, + pos + }; +} +function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) { + const start = pos; + const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct; + const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin; + let invalid = false; + let total = 0; + for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) { + const code = input.charCodeAt(pos); + let val; + if (code === 95 && allowNumSeparator !== "bail") { + const prev = input.charCodeAt(pos - 1); + const next = input.charCodeAt(pos + 1); + if (!allowNumSeparator) { + if (bailOnError) return { + n: null, + pos + }; + errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine); + } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) { + if (bailOnError) return { + n: null, + pos + }; + errors.unexpectedNumericSeparator(pos, lineStart, curLine); + } + ++pos; + continue; + } + if (code >= 97) { + val = code - 97 + 10; + } else if (code >= 65) { + val = code - 65 + 10; + } else if (_isDigit(code)) { + val = code - 48; + } else { + val = Infinity; + } + if (val >= radix) { + if (val <= 9 && bailOnError) { + return { + n: null, + pos + }; + } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) { + val = 0; + } else if (forceLen) { + val = 0; + invalid = true; + } else { + break; + } + } + ++pos; + total = total * radix + val; + } + if (pos === start || len != null && pos - start !== len || invalid) { + return { + n: null, + pos + }; + } + return { + n: total, + pos + }; +} +function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) { + const ch = input.charCodeAt(pos); + let code; + if (ch === 123) { + ++pos; + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors)); + ++pos; + if (code !== null && code > 0x10ffff) { + if (throwOnInvalid) { + errors.invalidCodePoint(pos, lineStart, curLine); + } else { + return { + code: null, + pos + }; + } + } + } else { + ({ + code, + pos + } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors)); + } + return { + code, + pos + }; +} +function buildPosition(pos, lineStart, curLine) { + return new Position(curLine, pos - lineStart, pos); +} +const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]); +class Token { + constructor(state) { + const startIndex = state.startIndex || 0; + this.type = state.type; + this.value = state.value; + this.start = startIndex + state.start; + this.end = startIndex + state.end; + this.loc = new SourceLocation(state.startLoc, state.endLoc); + } +} +class Tokenizer extends CommentsParser { + constructor(options, input) { + super(); + this.isLookahead = void 0; + this.tokens = []; + this.errorHandlers_readInt = { + invalidDigit: (pos, lineStart, curLine, radix) => { + if (!(this.optionFlags & 2048)) return false; + this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), { + radix + }); + return true; + }, + numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence), + unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator) + }; + this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, { + invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence), + invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint) + }); + this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, { + strictNumericEscape: (pos, lineStart, curLine) => { + this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine)); + }, + unterminated: (pos, lineStart, curLine) => { + throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine)); + } + }); + this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, { + strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape), + unterminated: (pos, lineStart, curLine) => { + throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine)); + } + }); + this.state = new State(); + this.state.init(options); + this.input = input; + this.length = input.length; + this.comments = []; + this.isLookahead = false; + } + pushToken(token) { + this.tokens.length = this.state.tokensLength; + this.tokens.push(token); + ++this.state.tokensLength; + } + next() { + this.checkKeywordEscapes(); + if (this.optionFlags & 256) { + this.pushToken(new Token(this.state)); + } + this.state.lastTokEndLoc = this.state.endLoc; + this.state.lastTokStartLoc = this.state.startLoc; + this.nextToken(); + } + eat(type) { + if (this.match(type)) { + this.next(); + return true; + } else { + return false; + } + } + match(type) { + return this.state.type === type; + } + createLookaheadState(state) { + return { + pos: state.pos, + value: null, + type: state.type, + start: state.start, + end: state.end, + context: [this.curContext()], + inType: state.inType, + startLoc: state.startLoc, + lastTokEndLoc: state.lastTokEndLoc, + curLine: state.curLine, + lineStart: state.lineStart, + curPosition: state.curPosition + }; + } + lookahead() { + const old = this.state; + this.state = this.createLookaheadState(old); + this.isLookahead = true; + this.nextToken(); + this.isLookahead = false; + const curr = this.state; + this.state = old; + return curr; + } + nextTokenStart() { + return this.nextTokenStartSince(this.state.pos); + } + nextTokenStartSince(pos) { + skipWhiteSpace.lastIndex = pos; + return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos; + } + lookaheadCharCode() { + return this.lookaheadCharCodeSince(this.state.pos); + } + lookaheadCharCodeSince(pos) { + return this.input.charCodeAt(this.nextTokenStartSince(pos)); + } + nextTokenInLineStart() { + return this.nextTokenInLineStartSince(this.state.pos); + } + nextTokenInLineStartSince(pos) { + skipWhiteSpaceInLine.lastIndex = pos; + return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos; + } + lookaheadInLineCharCode() { + return this.input.charCodeAt(this.nextTokenInLineStart()); + } + codePointAtPos(pos) { + let cp = this.input.charCodeAt(pos); + if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) { + const trail = this.input.charCodeAt(pos); + if ((trail & 0xfc00) === 0xdc00) { + cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff); + } + } + return cp; + } + setStrict(strict) { + this.state.strict = strict; + if (strict) { + this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, at)); + this.state.strictErrors.clear(); + } + } + curContext() { + return this.state.context[this.state.context.length - 1]; + } + nextToken() { + this.skipSpace(); + this.state.start = this.state.pos; + if (!this.isLookahead) this.state.startLoc = this.state.curPosition(); + if (this.state.pos >= this.length) { + this.finishToken(140); + return; + } + this.getTokenFromCode(this.codePointAtPos(this.state.pos)); + } + skipBlockComment(commentEnd) { + let startLoc; + if (!this.isLookahead) startLoc = this.state.curPosition(); + const start = this.state.pos; + const end = this.input.indexOf(commentEnd, start + 2); + if (end === -1) { + throw this.raise(Errors.UnterminatedComment, this.state.curPosition()); + } + this.state.pos = end + commentEnd.length; + lineBreakG.lastIndex = start + 2; + while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) { + ++this.state.curLine; + this.state.lineStart = lineBreakG.lastIndex; + } + if (this.isLookahead) return; + const comment = { + type: "CommentBlock", + value: this.input.slice(start + 2, end), + start: this.sourceToOffsetPos(start), + end: this.sourceToOffsetPos(end + commentEnd.length), + loc: new SourceLocation(startLoc, this.state.curPosition()) + }; + if (this.optionFlags & 256) this.pushToken(comment); + return comment; + } + skipLineComment(startSkip) { + const start = this.state.pos; + let startLoc; + if (!this.isLookahead) startLoc = this.state.curPosition(); + let ch = this.input.charCodeAt(this.state.pos += startSkip); + if (this.state.pos < this.length) { + while (!isNewLine(ch) && ++this.state.pos < this.length) { + ch = this.input.charCodeAt(this.state.pos); + } + } + if (this.isLookahead) return; + const end = this.state.pos; + const value = this.input.slice(start + startSkip, end); + const comment = { + type: "CommentLine", + value, + start: this.sourceToOffsetPos(start), + end: this.sourceToOffsetPos(end), + loc: new SourceLocation(startLoc, this.state.curPosition()) + }; + if (this.optionFlags & 256) this.pushToken(comment); + return comment; + } + skipSpace() { + const spaceStart = this.state.pos; + const comments = this.optionFlags & 4096 ? [] : null; + loop: while (this.state.pos < this.length) { + const ch = this.input.charCodeAt(this.state.pos); + switch (ch) { + case 32: + case 160: + case 9: + ++this.state.pos; + break; + case 13: + if (this.input.charCodeAt(this.state.pos + 1) === 10) { + ++this.state.pos; + } + case 10: + case 8232: + case 8233: + ++this.state.pos; + ++this.state.curLine; + this.state.lineStart = this.state.pos; + break; + case 47: + switch (this.input.charCodeAt(this.state.pos + 1)) { + case 42: + { + const comment = this.skipBlockComment("*/"); + if (comment !== undefined) { + this.addComment(comment); + comments == null || comments.push(comment); + } + break; + } + case 47: + { + const comment = this.skipLineComment(2); + if (comment !== undefined) { + this.addComment(comment); + comments == null || comments.push(comment); + } + break; + } + default: + break loop; + } + break; + default: + if (isWhitespace(ch)) { + ++this.state.pos; + } else if (ch === 45 && !this.inModule && this.optionFlags & 8192) { + const pos = this.state.pos; + if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) { + const comment = this.skipLineComment(3); + if (comment !== undefined) { + this.addComment(comment); + comments == null || comments.push(comment); + } + } else { + break loop; + } + } else if (ch === 60 && !this.inModule && this.optionFlags & 8192) { + const pos = this.state.pos; + if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) { + const comment = this.skipLineComment(4); + if (comment !== undefined) { + this.addComment(comment); + comments == null || comments.push(comment); + } + } else { + break loop; + } + } else { + break loop; + } + } + } + if ((comments == null ? void 0 : comments.length) > 0) { + const end = this.state.pos; + const commentWhitespace = { + start: this.sourceToOffsetPos(spaceStart), + end: this.sourceToOffsetPos(end), + comments: comments, + leadingNode: null, + trailingNode: null, + containingNode: null + }; + this.state.commentStack.push(commentWhitespace); + } + } + finishToken(type, val) { + this.state.end = this.state.pos; + this.state.endLoc = this.state.curPosition(); + const prevType = this.state.type; + this.state.type = type; + this.state.value = val; + if (!this.isLookahead) { + this.updateContext(prevType); + } + } + replaceToken(type) { + this.state.type = type; + this.updateContext(); + } + readToken_numberSign() { + if (this.state.pos === 0 && this.readToken_interpreter()) { + return; + } + const nextPos = this.state.pos + 1; + const next = this.codePointAtPos(nextPos); + if (next >= 48 && next <= 57) { + throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition()); + } + if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) { + this.expectPlugin("recordAndTuple"); + if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") { + throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, this.state.curPosition()); + } + this.state.pos += 2; + if (next === 123) { + this.finishToken(7); + } else { + this.finishToken(1); + } + } else if (isIdentifierStart(next)) { + ++this.state.pos; + this.finishToken(139, this.readWord1(next)); + } else if (next === 92) { + ++this.state.pos; + this.finishToken(139, this.readWord1()); + } else { + this.finishOp(27, 1); + } + } + readToken_dot() { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next >= 48 && next <= 57) { + this.readNumber(true); + return; + } + if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) { + this.state.pos += 3; + this.finishToken(21); + } else { + ++this.state.pos; + this.finishToken(16); + } + } + readToken_slash() { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === 61) { + this.finishOp(31, 2); + } else { + this.finishOp(56, 1); + } + } + readToken_interpreter() { + if (this.state.pos !== 0 || this.length < 2) return false; + let ch = this.input.charCodeAt(this.state.pos + 1); + if (ch !== 33) return false; + const start = this.state.pos; + this.state.pos += 1; + while (!isNewLine(ch) && ++this.state.pos < this.length) { + ch = this.input.charCodeAt(this.state.pos); + } + const value = this.input.slice(start + 2, this.state.pos); + this.finishToken(28, value); + return true; + } + readToken_mult_modulo(code) { + let type = code === 42 ? 55 : 54; + let width = 1; + let next = this.input.charCodeAt(this.state.pos + 1); + if (code === 42 && next === 42) { + width++; + next = this.input.charCodeAt(this.state.pos + 2); + type = 57; + } + if (next === 61 && !this.state.inType) { + width++; + type = code === 37 ? 33 : 30; + } + this.finishOp(type, width); + } + readToken_pipe_amp(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === code) { + if (this.input.charCodeAt(this.state.pos + 2) === 61) { + this.finishOp(30, 3); + } else { + this.finishOp(code === 124 ? 41 : 42, 2); + } + return; + } + if (code === 124) { + if (next === 62) { + this.finishOp(39, 2); + return; + } + if (this.hasPlugin("recordAndTuple") && next === 125) { + if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { + throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, this.state.curPosition()); + } + this.state.pos += 2; + this.finishToken(9); + return; + } + if (this.hasPlugin("recordAndTuple") && next === 93) { + if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { + throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, this.state.curPosition()); + } + this.state.pos += 2; + this.finishToken(4); + return; + } + } + if (next === 61) { + this.finishOp(30, 2); + return; + } + this.finishOp(code === 124 ? 43 : 45, 1); + } + readToken_caret() { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === 61 && !this.state.inType) { + this.finishOp(32, 2); + } else if (next === 94 && this.hasPlugin(["pipelineOperator", { + proposal: "hack", + topicToken: "^^" + }])) { + this.finishOp(37, 2); + const lookaheadCh = this.input.codePointAt(this.state.pos); + if (lookaheadCh === 94) { + this.unexpected(); + } + } else { + this.finishOp(44, 1); + } + } + readToken_atSign() { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === 64 && this.hasPlugin(["pipelineOperator", { + proposal: "hack", + topicToken: "@@" + }])) { + this.finishOp(38, 2); + } else { + this.finishOp(26, 1); + } + } + readToken_plus_min(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === code) { + this.finishOp(34, 2); + return; + } + if (next === 61) { + this.finishOp(30, 2); + } else { + this.finishOp(53, 1); + } + } + readToken_lt() { + const { + pos + } = this.state; + const next = this.input.charCodeAt(pos + 1); + if (next === 60) { + if (this.input.charCodeAt(pos + 2) === 61) { + this.finishOp(30, 3); + return; + } + this.finishOp(51, 2); + return; + } + if (next === 61) { + this.finishOp(49, 2); + return; + } + this.finishOp(47, 1); + } + readToken_gt() { + const { + pos + } = this.state; + const next = this.input.charCodeAt(pos + 1); + if (next === 62) { + const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2; + if (this.input.charCodeAt(pos + size) === 61) { + this.finishOp(30, size + 1); + return; + } + this.finishOp(52, size); + return; + } + if (next === 61) { + this.finishOp(49, 2); + return; + } + this.finishOp(48, 1); + } + readToken_eq_excl(code) { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === 61) { + this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2); + return; + } + if (code === 61 && next === 62) { + this.state.pos += 2; + this.finishToken(19); + return; + } + this.finishOp(code === 61 ? 29 : 35, 1); + } + readToken_question() { + const next = this.input.charCodeAt(this.state.pos + 1); + const next2 = this.input.charCodeAt(this.state.pos + 2); + if (next === 63) { + if (next2 === 61) { + this.finishOp(30, 3); + } else { + this.finishOp(40, 2); + } + } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) { + this.state.pos += 2; + this.finishToken(18); + } else { + ++this.state.pos; + this.finishToken(17); + } + } + getTokenFromCode(code) { + switch (code) { + case 46: + this.readToken_dot(); + return; + case 40: + ++this.state.pos; + this.finishToken(10); + return; + case 41: + ++this.state.pos; + this.finishToken(11); + return; + case 59: + ++this.state.pos; + this.finishToken(13); + return; + case 44: + ++this.state.pos; + this.finishToken(12); + return; + case 91: + if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { + if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { + throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, this.state.curPosition()); + } + this.state.pos += 2; + this.finishToken(2); + } else { + ++this.state.pos; + this.finishToken(0); + } + return; + case 93: + ++this.state.pos; + this.finishToken(3); + return; + case 123: + if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { + if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { + throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, this.state.curPosition()); + } + this.state.pos += 2; + this.finishToken(6); + } else { + ++this.state.pos; + this.finishToken(5); + } + return; + case 125: + ++this.state.pos; + this.finishToken(8); + return; + case 58: + if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) { + this.finishOp(15, 2); + } else { + ++this.state.pos; + this.finishToken(14); + } + return; + case 63: + this.readToken_question(); + return; + case 96: + this.readTemplateToken(); + return; + case 48: + { + const next = this.input.charCodeAt(this.state.pos + 1); + if (next === 120 || next === 88) { + this.readRadixNumber(16); + return; + } + if (next === 111 || next === 79) { + this.readRadixNumber(8); + return; + } + if (next === 98 || next === 66) { + this.readRadixNumber(2); + return; + } + } + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + this.readNumber(false); + return; + case 34: + case 39: + this.readString(code); + return; + case 47: + this.readToken_slash(); + return; + case 37: + case 42: + this.readToken_mult_modulo(code); + return; + case 124: + case 38: + this.readToken_pipe_amp(code); + return; + case 94: + this.readToken_caret(); + return; + case 43: + case 45: + this.readToken_plus_min(code); + return; + case 60: + this.readToken_lt(); + return; + case 62: + this.readToken_gt(); + return; + case 61: + case 33: + this.readToken_eq_excl(code); + return; + case 126: + this.finishOp(36, 1); + return; + case 64: + this.readToken_atSign(); + return; + case 35: + this.readToken_numberSign(); + return; + case 92: + this.readWord(); + return; + default: + if (isIdentifierStart(code)) { + this.readWord(code); + return; + } + } + throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), { + unexpected: String.fromCodePoint(code) + }); + } + finishOp(type, size) { + const str = this.input.slice(this.state.pos, this.state.pos + size); + this.state.pos += size; + this.finishToken(type, str); + } + readRegexp() { + const startLoc = this.state.startLoc; + const start = this.state.start + 1; + let escaped, inClass; + let { + pos + } = this.state; + for (;; ++pos) { + if (pos >= this.length) { + throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1)); + } + const ch = this.input.charCodeAt(pos); + if (isNewLine(ch)) { + throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1)); + } + if (escaped) { + escaped = false; + } else { + if (ch === 91) { + inClass = true; + } else if (ch === 93 && inClass) { + inClass = false; + } else if (ch === 47 && !inClass) { + break; + } + escaped = ch === 92; + } + } + const content = this.input.slice(start, pos); + ++pos; + let mods = ""; + const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start); + while (pos < this.length) { + const cp = this.codePointAtPos(pos); + const char = String.fromCharCode(cp); + if (VALID_REGEX_FLAGS.has(cp)) { + if (cp === 118) { + if (mods.includes("u")) { + this.raise(Errors.IncompatibleRegExpUVFlags, nextPos()); + } + } else if (cp === 117) { + if (mods.includes("v")) { + this.raise(Errors.IncompatibleRegExpUVFlags, nextPos()); + } + } + if (mods.includes(char)) { + this.raise(Errors.DuplicateRegExpFlags, nextPos()); + } + } else if (isIdentifierChar(cp) || cp === 92) { + this.raise(Errors.MalformedRegExpFlags, nextPos()); + } else { + break; + } + ++pos; + mods += char; + } + this.state.pos = pos; + this.finishToken(138, { + pattern: content, + flags: mods + }); + } + readInt(radix, len, forceLen = false, allowNumSeparator = true) { + const { + n, + pos + } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false); + this.state.pos = pos; + return n; + } + readRadixNumber(radix) { + const start = this.state.pos; + const startLoc = this.state.curPosition(); + let isBigInt = false; + this.state.pos += 2; + const val = this.readInt(radix); + if (val == null) { + this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), { + radix + }); + } + const next = this.input.charCodeAt(this.state.pos); + if (next === 110) { + ++this.state.pos; + isBigInt = true; + } else if (next === 109) { + throw this.raise(Errors.InvalidDecimal, startLoc); + } + if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { + throw this.raise(Errors.NumberIdentifier, this.state.curPosition()); + } + if (isBigInt) { + const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, ""); + this.finishToken(136, str); + return; + } + this.finishToken(135, val); + } + readNumber(startsWithDot) { + const start = this.state.pos; + const startLoc = this.state.curPosition(); + let isFloat = false; + let isBigInt = false; + let hasExponent = false; + let isOctal = false; + if (!startsWithDot && this.readInt(10) === null) { + this.raise(Errors.InvalidNumber, this.state.curPosition()); + } + const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48; + if (hasLeadingZero) { + const integer = this.input.slice(start, this.state.pos); + this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc); + if (!this.state.strict) { + const underscorePos = integer.indexOf("_"); + if (underscorePos > 0) { + this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos)); + } + } + isOctal = hasLeadingZero && !/[89]/.test(integer); + } + let next = this.input.charCodeAt(this.state.pos); + if (next === 46 && !isOctal) { + ++this.state.pos; + this.readInt(10); + isFloat = true; + next = this.input.charCodeAt(this.state.pos); + } + if ((next === 69 || next === 101) && !isOctal) { + next = this.input.charCodeAt(++this.state.pos); + if (next === 43 || next === 45) { + ++this.state.pos; + } + if (this.readInt(10) === null) { + this.raise(Errors.InvalidOrMissingExponent, startLoc); + } + isFloat = true; + hasExponent = true; + next = this.input.charCodeAt(this.state.pos); + } + if (next === 110) { + if (isFloat || hasLeadingZero) { + this.raise(Errors.InvalidBigIntLiteral, startLoc); + } + ++this.state.pos; + isBigInt = true; + } + if (next === 109) { + this.expectPlugin("decimal", this.state.curPosition()); + if (hasExponent || hasLeadingZero) { + this.raise(Errors.InvalidDecimal, startLoc); + } + ++this.state.pos; + var isDecimal = true; + } + if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { + throw this.raise(Errors.NumberIdentifier, this.state.curPosition()); + } + const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, ""); + if (isBigInt) { + this.finishToken(136, str); + return; + } + if (isDecimal) { + this.finishToken(137, str); + return; + } + const val = isOctal ? parseInt(str, 8) : parseFloat(str); + this.finishToken(135, val); + } + readCodePoint(throwOnInvalid) { + const { + code, + pos + } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint); + this.state.pos = pos; + return code; + } + readString(quote) { + const { + str, + pos, + curLine, + lineStart + } = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string); + this.state.pos = pos + 1; + this.state.lineStart = lineStart; + this.state.curLine = curLine; + this.finishToken(134, str); + } + readTemplateContinuation() { + if (!this.match(8)) { + this.unexpected(null, 8); + } + this.state.pos--; + this.readTemplateToken(); + } + readTemplateToken() { + const opening = this.input[this.state.pos]; + const { + str, + firstInvalidLoc, + pos, + curLine, + lineStart + } = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template); + this.state.pos = pos + 1; + this.state.lineStart = lineStart; + this.state.curLine = curLine; + if (firstInvalidLoc) { + this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos)); + } + if (this.input.codePointAt(pos) === 96) { + this.finishToken(24, firstInvalidLoc ? null : opening + str + "`"); + } else { + this.state.pos++; + this.finishToken(25, firstInvalidLoc ? null : opening + str + "${"); + } + } + recordStrictModeErrors(toParseError, at) { + const index = at.index; + if (this.state.strict && !this.state.strictErrors.has(index)) { + this.raise(toParseError, at); + } else { + this.state.strictErrors.set(index, [toParseError, at]); + } + } + readWord1(firstCode) { + this.state.containsEsc = false; + let word = ""; + const start = this.state.pos; + let chunkStart = this.state.pos; + if (firstCode !== undefined) { + this.state.pos += firstCode <= 0xffff ? 1 : 2; + } + while (this.state.pos < this.length) { + const ch = this.codePointAtPos(this.state.pos); + if (isIdentifierChar(ch)) { + this.state.pos += ch <= 0xffff ? 1 : 2; + } else if (ch === 92) { + this.state.containsEsc = true; + word += this.input.slice(chunkStart, this.state.pos); + const escStart = this.state.curPosition(); + const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar; + if (this.input.charCodeAt(++this.state.pos) !== 117) { + this.raise(Errors.MissingUnicodeEscape, this.state.curPosition()); + chunkStart = this.state.pos - 1; + continue; + } + ++this.state.pos; + const esc = this.readCodePoint(true); + if (esc !== null) { + if (!identifierCheck(esc)) { + this.raise(Errors.EscapedCharNotAnIdentifier, escStart); + } + word += String.fromCodePoint(esc); + } + chunkStart = this.state.pos; + } else { + break; + } + } + return word + this.input.slice(chunkStart, this.state.pos); + } + readWord(firstCode) { + const word = this.readWord1(firstCode); + const type = keywords$1.get(word); + if (type !== undefined) { + this.finishToken(type, tokenLabelName(type)); + } else { + this.finishToken(132, word); + } + } + checkKeywordEscapes() { + const { + type + } = this.state; + if (tokenIsKeyword(type) && this.state.containsEsc) { + this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, { + reservedWord: tokenLabelName(type) + }); + } + } + raise(toParseError, at, details = {}) { + const loc = at instanceof Position ? at : at.loc.start; + const error = toParseError(loc, details); + if (!(this.optionFlags & 2048)) throw error; + if (!this.isLookahead) this.state.errors.push(error); + return error; + } + raiseOverwrite(toParseError, at, details = {}) { + const loc = at instanceof Position ? at : at.loc.start; + const pos = loc.index; + const errors = this.state.errors; + for (let i = errors.length - 1; i >= 0; i--) { + const error = errors[i]; + if (error.loc.index === pos) { + return errors[i] = toParseError(loc, details); + } + if (error.loc.index < pos) break; + } + return this.raise(toParseError, at, details); + } + updateContext(prevType) {} + unexpected(loc, type) { + throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, { + expected: type ? tokenLabelName(type) : null + }); + } + expectPlugin(pluginName, loc) { + if (this.hasPlugin(pluginName)) { + return true; + } + throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, { + missingPlugin: [pluginName] + }); + } + expectOnePlugin(pluginNames) { + if (!pluginNames.some(name => this.hasPlugin(name))) { + throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, { + missingPlugin: pluginNames + }); + } + } + errorBuilder(error) { + return (pos, lineStart, curLine) => { + this.raise(error, buildPosition(pos, lineStart, curLine)); + }; + } +} +class ClassScope { + constructor() { + this.privateNames = new Set(); + this.loneAccessors = new Map(); + this.undefinedPrivateNames = new Map(); + } +} +class ClassScopeHandler { + constructor(parser) { + this.parser = void 0; + this.stack = []; + this.undefinedPrivateNames = new Map(); + this.parser = parser; + } + current() { + return this.stack[this.stack.length - 1]; + } + enter() { + this.stack.push(new ClassScope()); + } + exit() { + const oldClassScope = this.stack.pop(); + const current = this.current(); + for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) { + if (current) { + if (!current.undefinedPrivateNames.has(name)) { + current.undefinedPrivateNames.set(name, loc); + } + } else { + this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { + identifierName: name + }); + } + } + } + declarePrivateName(name, elementType, loc) { + const { + privateNames, + loneAccessors, + undefinedPrivateNames + } = this.current(); + let redefined = privateNames.has(name); + if (elementType & 3) { + const accessor = redefined && loneAccessors.get(name); + if (accessor) { + const oldStatic = accessor & 4; + const newStatic = elementType & 4; + const oldKind = accessor & 3; + const newKind = elementType & 3; + redefined = oldKind === newKind || oldStatic !== newStatic; + if (!redefined) loneAccessors.delete(name); + } else if (!redefined) { + loneAccessors.set(name, elementType); + } + } + if (redefined) { + this.parser.raise(Errors.PrivateNameRedeclaration, loc, { + identifierName: name + }); + } + privateNames.add(name); + undefinedPrivateNames.delete(name); + } + usePrivateName(name, loc) { + let classScope; + for (classScope of this.stack) { + if (classScope.privateNames.has(name)) return; + } + if (classScope) { + classScope.undefinedPrivateNames.set(name, loc); + } else { + this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { + identifierName: name + }); + } + } +} +class ExpressionScope { + constructor(type = 0) { + this.type = type; + } + canBeArrowParameterDeclaration() { + return this.type === 2 || this.type === 1; + } + isCertainlyParameterDeclaration() { + return this.type === 3; + } +} +class ArrowHeadParsingScope extends ExpressionScope { + constructor(type) { + super(type); + this.declarationErrors = new Map(); + } + recordDeclarationError(ParsingErrorClass, at) { + const index = at.index; + this.declarationErrors.set(index, [ParsingErrorClass, at]); + } + clearDeclarationError(index) { + this.declarationErrors.delete(index); + } + iterateErrors(iterator) { + this.declarationErrors.forEach(iterator); + } +} +class ExpressionScopeHandler { + constructor(parser) { + this.parser = void 0; + this.stack = [new ExpressionScope()]; + this.parser = parser; + } + enter(scope) { + this.stack.push(scope); + } + exit() { + this.stack.pop(); + } + recordParameterInitializerError(toParseError, node) { + const origin = node.loc.start; + const { + stack + } = this; + let i = stack.length - 1; + let scope = stack[i]; + while (!scope.isCertainlyParameterDeclaration()) { + if (scope.canBeArrowParameterDeclaration()) { + scope.recordDeclarationError(toParseError, origin); + } else { + return; + } + scope = stack[--i]; + } + this.parser.raise(toParseError, origin); + } + recordArrowParameterBindingError(error, node) { + const { + stack + } = this; + const scope = stack[stack.length - 1]; + const origin = node.loc.start; + if (scope.isCertainlyParameterDeclaration()) { + this.parser.raise(error, origin); + } else if (scope.canBeArrowParameterDeclaration()) { + scope.recordDeclarationError(error, origin); + } else { + return; + } + } + recordAsyncArrowParametersError(at) { + const { + stack + } = this; + let i = stack.length - 1; + let scope = stack[i]; + while (scope.canBeArrowParameterDeclaration()) { + if (scope.type === 2) { + scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at); + } + scope = stack[--i]; + } + } + validateAsPattern() { + const { + stack + } = this; + const currentScope = stack[stack.length - 1]; + if (!currentScope.canBeArrowParameterDeclaration()) return; + currentScope.iterateErrors(([toParseError, loc]) => { + this.parser.raise(toParseError, loc); + let i = stack.length - 2; + let scope = stack[i]; + while (scope.canBeArrowParameterDeclaration()) { + scope.clearDeclarationError(loc.index); + scope = stack[--i]; + } + }); + } +} +function newParameterDeclarationScope() { + return new ExpressionScope(3); +} +function newArrowHeadScope() { + return new ArrowHeadParsingScope(1); +} +function newAsyncArrowScope() { + return new ArrowHeadParsingScope(2); +} +function newExpressionScope() { + return new ExpressionScope(); +} +class UtilParser extends Tokenizer { + addExtra(node, key, value, enumerable = true) { + if (!node) return; + let { + extra + } = node; + if (extra == null) { + extra = {}; + node.extra = extra; + } + if (enumerable) { + extra[key] = value; + } else { + Object.defineProperty(extra, key, { + enumerable, + value + }); + } + } + isContextual(token) { + return this.state.type === token && !this.state.containsEsc; + } + isUnparsedContextual(nameStart, name) { + if (this.input.startsWith(name, nameStart)) { + const nextCh = this.input.charCodeAt(nameStart + name.length); + return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800); + } + return false; + } + isLookaheadContextual(name) { + const next = this.nextTokenStart(); + return this.isUnparsedContextual(next, name); + } + eatContextual(token) { + if (this.isContextual(token)) { + this.next(); + return true; + } + return false; + } + expectContextual(token, toParseError) { + if (!this.eatContextual(token)) { + if (toParseError != null) { + throw this.raise(toParseError, this.state.startLoc); + } + this.unexpected(null, token); + } + } + canInsertSemicolon() { + return this.match(140) || this.match(8) || this.hasPrecedingLineBreak(); + } + hasPrecedingLineBreak() { + return hasNewLine(this.input, this.offsetToSourcePos(this.state.lastTokEndLoc.index), this.state.start); + } + hasFollowingLineBreak() { + return hasNewLine(this.input, this.state.end, this.nextTokenStart()); + } + isLineTerminator() { + return this.eat(13) || this.canInsertSemicolon(); + } + semicolon(allowAsi = true) { + if (allowAsi ? this.isLineTerminator() : this.eat(13)) return; + this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc); + } + expect(type, loc) { + if (!this.eat(type)) { + this.unexpected(loc, type); + } + } + tryParse(fn, oldState = this.state.clone()) { + const abortSignal = { + node: null + }; + try { + const node = fn((node = null) => { + abortSignal.node = node; + throw abortSignal; + }); + if (this.state.errors.length > oldState.errors.length) { + const failState = this.state; + this.state = oldState; + this.state.tokensLength = failState.tokensLength; + return { + node, + error: failState.errors[oldState.errors.length], + thrown: false, + aborted: false, + failState + }; + } + return { + node: node, + error: null, + thrown: false, + aborted: false, + failState: null + }; + } catch (error) { + const failState = this.state; + this.state = oldState; + if (error instanceof SyntaxError) { + return { + node: null, + error, + thrown: true, + aborted: false, + failState + }; + } + if (error === abortSignal) { + return { + node: abortSignal.node, + error: null, + thrown: false, + aborted: true, + failState + }; + } + throw error; + } + } + checkExpressionErrors(refExpressionErrors, andThrow) { + if (!refExpressionErrors) return false; + const { + shorthandAssignLoc, + doubleProtoLoc, + privateKeyLoc, + optionalParametersLoc, + voidPatternLoc + } = refExpressionErrors; + const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc || !!voidPatternLoc; + if (!andThrow) { + return hasErrors; + } + if (shorthandAssignLoc != null) { + this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc); + } + if (doubleProtoLoc != null) { + this.raise(Errors.DuplicateProto, doubleProtoLoc); + } + if (privateKeyLoc != null) { + this.raise(Errors.UnexpectedPrivateField, privateKeyLoc); + } + if (optionalParametersLoc != null) { + this.unexpected(optionalParametersLoc); + } + if (voidPatternLoc != null) { + this.raise(Errors.InvalidCoverDiscardElement, voidPatternLoc); + } + } + isLiteralPropertyName() { + return tokenIsLiteralPropertyName(this.state.type); + } + isPrivateName(node) { + return node.type === "PrivateName"; + } + getPrivateNameSV(node) { + return node.id.name; + } + hasPropertyAsPrivateName(node) { + return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property); + } + isObjectProperty(node) { + return node.type === "ObjectProperty"; + } + isObjectMethod(node) { + return node.type === "ObjectMethod"; + } + initializeScopes(inModule = this.options.sourceType === "module") { + const oldLabels = this.state.labels; + this.state.labels = []; + const oldExportedIdentifiers = this.exportedIdentifiers; + this.exportedIdentifiers = new Set(); + const oldInModule = this.inModule; + this.inModule = inModule; + const oldScope = this.scope; + const ScopeHandler = this.getScopeHandler(); + this.scope = new ScopeHandler(this, inModule); + const oldProdParam = this.prodParam; + this.prodParam = new ProductionParameterHandler(); + const oldClassScope = this.classScope; + this.classScope = new ClassScopeHandler(this); + const oldExpressionScope = this.expressionScope; + this.expressionScope = new ExpressionScopeHandler(this); + return () => { + this.state.labels = oldLabels; + this.exportedIdentifiers = oldExportedIdentifiers; + this.inModule = oldInModule; + this.scope = oldScope; + this.prodParam = oldProdParam; + this.classScope = oldClassScope; + this.expressionScope = oldExpressionScope; + }; + } + enterInitialScopes() { + let paramFlags = 0; + if (this.inModule || this.optionFlags & 1) { + paramFlags |= 2; + } + if (this.optionFlags & 32) { + paramFlags |= 1; + } + const isCommonJS = !this.inModule && this.options.sourceType === "commonjs"; + if (isCommonJS || this.optionFlags & 2) { + paramFlags |= 4; + } + this.prodParam.enter(paramFlags); + let scopeFlags = isCommonJS ? 514 : 1; + if (this.optionFlags & 4) { + scopeFlags |= 512; + } + this.scope.enter(scopeFlags); + } + checkDestructuringPrivate(refExpressionErrors) { + const { + privateKeyLoc + } = refExpressionErrors; + if (privateKeyLoc !== null) { + this.expectPlugin("destructuringPrivate", privateKeyLoc); + } + } +} +class ExpressionErrors { + constructor() { + this.shorthandAssignLoc = null; + this.doubleProtoLoc = null; + this.privateKeyLoc = null; + this.optionalParametersLoc = null; + this.voidPatternLoc = null; + } +} +class Node { + constructor(parser, pos, loc) { + this.type = ""; + this.start = pos; + this.end = 0; + this.loc = new SourceLocation(loc); + if ((parser == null ? void 0 : parser.optionFlags) & 128) this.range = [pos, 0]; + if (parser != null && parser.filename) this.loc.filename = parser.filename; + } +} +const NodePrototype = Node.prototype; +NodePrototype.__clone = function () { + const newNode = new Node(undefined, this.start, this.loc.start); + const keys = Object.keys(this); + for (let i = 0, length = keys.length; i < length; i++) { + const key = keys[i]; + if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") { + newNode[key] = this[key]; + } + } + return newNode; +}; +class NodeUtils extends UtilParser { + startNode() { + const loc = this.state.startLoc; + return new Node(this, loc.index, loc); + } + startNodeAt(loc) { + return new Node(this, loc.index, loc); + } + startNodeAtNode(type) { + return this.startNodeAt(type.loc.start); + } + finishNode(node, type) { + return this.finishNodeAt(node, type, this.state.lastTokEndLoc); + } + finishNodeAt(node, type, endLoc) { + node.type = type; + node.end = endLoc.index; + node.loc.end = endLoc; + if (this.optionFlags & 128) node.range[1] = endLoc.index; + if (this.optionFlags & 4096) { + this.processComment(node); + } + return node; + } + resetStartLocation(node, startLoc) { + node.start = startLoc.index; + node.loc.start = startLoc; + if (this.optionFlags & 128) node.range[0] = startLoc.index; + } + resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { + node.end = endLoc.index; + node.loc.end = endLoc; + if (this.optionFlags & 128) node.range[1] = endLoc.index; + } + resetStartLocationFromNode(node, locationNode) { + this.resetStartLocation(node, locationNode.loc.start); + } + castNodeTo(node, type) { + node.type = type; + return node; + } + cloneIdentifier(node) { + const { + type, + start, + end, + loc, + range, + name + } = node; + const cloned = Object.create(NodePrototype); + cloned.type = type; + cloned.start = start; + cloned.end = end; + cloned.loc = loc; + cloned.range = range; + cloned.name = name; + if (node.extra) cloned.extra = node.extra; + return cloned; + } + cloneStringLiteral(node) { + const { + type, + start, + end, + loc, + range, + extra + } = node; + const cloned = Object.create(NodePrototype); + cloned.type = type; + cloned.start = start; + cloned.end = end; + cloned.loc = loc; + cloned.range = range; + cloned.extra = extra; + cloned.value = node.value; + return cloned; + } +} +const unwrapParenthesizedExpression = node => { + return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node; +}; +class LValParser extends NodeUtils { + toAssignable(node, isLHS = false) { + var _node$extra, _node$extra3; + let parenthesized = undefined; + if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) { + parenthesized = unwrapParenthesizedExpression(node); + if (isLHS) { + if (parenthesized.type === "Identifier") { + this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node); + } else if (parenthesized.type !== "CallExpression" && parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) { + this.raise(Errors.InvalidParenthesizedAssignment, node); + } + } else { + this.raise(Errors.InvalidParenthesizedAssignment, node); + } + } + switch (node.type) { + case "Identifier": + case "ObjectPattern": + case "ArrayPattern": + case "AssignmentPattern": + case "RestElement": + case "VoidPattern": + break; + case "ObjectExpression": + this.castNodeTo(node, "ObjectPattern"); + for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) { + var _node$extra2; + const prop = node.properties[i]; + const isLast = i === last; + this.toAssignableObjectExpressionProp(prop, isLast, isLHS); + if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) { + this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc); + } + } + break; + case "ObjectProperty": + { + const { + key, + value + } = node; + if (this.isPrivateName(key)) { + this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); + } + this.toAssignable(value, isLHS); + break; + } + case "SpreadElement": + { + throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller."); + } + case "ArrayExpression": + this.castNodeTo(node, "ArrayPattern"); + this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS); + break; + case "AssignmentExpression": + if (node.operator !== "=") { + this.raise(Errors.MissingEqInAssignment, node.left.loc.end); + } + this.castNodeTo(node, "AssignmentPattern"); + delete node.operator; + if (node.left.type === "VoidPattern") { + this.raise(Errors.VoidPatternInitializer, node.left); + } + this.toAssignable(node.left, isLHS); + break; + case "ParenthesizedExpression": + this.toAssignable(parenthesized, isLHS); + break; + } + } + toAssignableObjectExpressionProp(prop, isLast, isLHS) { + if (prop.type === "ObjectMethod") { + this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key); + } else if (prop.type === "SpreadElement") { + this.castNodeTo(prop, "RestElement"); + const arg = prop.argument; + this.checkToRestConversion(arg, false); + this.toAssignable(arg, isLHS); + if (!isLast) { + this.raise(Errors.RestTrailingComma, prop); + } + } else { + this.toAssignable(prop, isLHS); + } + } + toAssignableList(exprList, trailingCommaLoc, isLHS) { + const end = exprList.length - 1; + for (let i = 0; i <= end; i++) { + const elt = exprList[i]; + if (!elt) continue; + this.toAssignableListItem(exprList, i, isLHS); + if (elt.type === "RestElement") { + if (i < end) { + this.raise(Errors.RestTrailingComma, elt); + } else if (trailingCommaLoc) { + this.raise(Errors.RestTrailingComma, trailingCommaLoc); + } + } + } + } + toAssignableListItem(exprList, index, isLHS) { + const node = exprList[index]; + if (node.type === "SpreadElement") { + this.castNodeTo(node, "RestElement"); + const arg = node.argument; + this.checkToRestConversion(arg, true); + this.toAssignable(arg, isLHS); + } else { + this.toAssignable(node, isLHS); + } + } + isAssignable(node, isBinding) { + switch (node.type) { + case "Identifier": + case "ObjectPattern": + case "ArrayPattern": + case "AssignmentPattern": + case "RestElement": + case "VoidPattern": + return true; + case "ObjectExpression": + { + const last = node.properties.length - 1; + return node.properties.every((prop, i) => { + return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop); + }); + } + case "ObjectProperty": + return this.isAssignable(node.value); + case "SpreadElement": + return this.isAssignable(node.argument); + case "ArrayExpression": + return node.elements.every(element => element === null || this.isAssignable(element)); + case "AssignmentExpression": + return node.operator === "="; + case "ParenthesizedExpression": + return this.isAssignable(node.expression); + case "MemberExpression": + case "OptionalMemberExpression": + return !isBinding; + default: + return false; + } + } + toReferencedList(exprList, isParenthesizedExpr) { + return exprList; + } + toReferencedListDeep(exprList, isParenthesizedExpr) { + this.toReferencedList(exprList, isParenthesizedExpr); + for (const expr of exprList) { + if ((expr == null ? void 0 : expr.type) === "ArrayExpression") { + this.toReferencedListDeep(expr.elements); + } + } + } + parseSpread(refExpressionErrors) { + const node = this.startNode(); + this.next(); + node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined); + return this.finishNode(node, "SpreadElement"); + } + parseRestBinding() { + const node = this.startNode(); + this.next(); + const argument = this.parseBindingAtom(); + if (argument.type === "VoidPattern") { + this.raise(Errors.UnexpectedVoidPattern, argument); + } + node.argument = argument; + return this.finishNode(node, "RestElement"); + } + parseBindingAtom() { + switch (this.state.type) { + case 0: + { + const node = this.startNode(); + this.next(); + node.elements = this.parseBindingList(3, 93, 1); + return this.finishNode(node, "ArrayPattern"); + } + case 5: + return this.parseObjectLike(8, true); + case 88: + return this.parseVoidPattern(null); + } + return this.parseIdentifier(); + } + parseBindingList(close, closeCharCode, flags) { + const allowEmpty = flags & 1; + const elts = []; + let first = true; + while (!this.eat(close)) { + if (first) { + first = false; + } else { + this.expect(12); + } + if (allowEmpty && this.match(12)) { + elts.push(null); + } else if (this.eat(close)) { + break; + } else if (this.match(21)) { + let rest = this.parseRestBinding(); + if (this.hasPlugin("flow") || flags & 2) { + rest = this.parseFunctionParamType(rest); + } + elts.push(rest); + if (!this.checkCommaAfterRest(closeCharCode)) { + this.expect(close); + break; + } + } else { + const decorators = []; + if (flags & 2) { + if (this.match(26) && this.hasPlugin("decorators")) { + this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc); + } + while (this.match(26)) { + decorators.push(this.parseDecorator()); + } + } + elts.push(this.parseBindingElement(flags, decorators)); + } + } + return elts; + } + parseBindingRestProperty(prop) { + this.next(); + if (this.hasPlugin("discardBinding") && this.match(88)) { + prop.argument = this.parseVoidPattern(null); + this.raise(Errors.UnexpectedVoidPattern, prop.argument); + } else { + prop.argument = this.parseIdentifier(); + } + this.checkCommaAfterRest(125); + return this.finishNode(prop, "RestElement"); + } + parseBindingProperty() { + const { + type, + startLoc + } = this.state; + if (type === 21) { + return this.parseBindingRestProperty(this.startNode()); + } + const prop = this.startNode(); + if (type === 139) { + this.expectPlugin("destructuringPrivate", startLoc); + this.classScope.usePrivateName(this.state.value, startLoc); + prop.key = this.parsePrivateName(); + } else { + this.parsePropertyName(prop); + } + prop.method = false; + return this.parseObjPropValue(prop, startLoc, false, false, true, false); + } + parseBindingElement(flags, decorators) { + const left = this.parseMaybeDefault(); + if (this.hasPlugin("flow") || flags & 2) { + this.parseFunctionParamType(left); + } + if (decorators.length) { + left.decorators = decorators; + this.resetStartLocationFromNode(left, decorators[0]); + } + const elt = this.parseMaybeDefault(left.loc.start, left); + return elt; + } + parseFunctionParamType(param) { + return param; + } + parseMaybeDefault(startLoc, left) { + startLoc != null ? startLoc : startLoc = this.state.startLoc; + left = left != null ? left : this.parseBindingAtom(); + if (!this.eat(29)) return left; + const node = this.startNodeAt(startLoc); + if (left.type === "VoidPattern") { + this.raise(Errors.VoidPatternInitializer, left); + } + node.left = left; + node.right = this.parseMaybeAssignAllowIn(); + return this.finishNode(node, "AssignmentPattern"); + } + isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) { + switch (type) { + case "AssignmentPattern": + return "left"; + case "RestElement": + return "argument"; + case "ObjectProperty": + return "value"; + case "ParenthesizedExpression": + return "expression"; + case "ArrayPattern": + return "elements"; + case "ObjectPattern": + return "properties"; + case "VoidPattern": + return true; + case "CallExpression": + if (!disallowCallExpression && !this.state.strict && this.optionFlags & 8192) { + return true; + } + } + return false; + } + isOptionalMemberExpression(expression) { + return expression.type === "OptionalMemberExpression"; + } + checkLVal(expression, ancestor, binding = 64, checkClashes = false, strictModeChanged = false, hasParenthesizedAncestor = false, disallowCallExpression = false) { + var _expression$extra; + const type = expression.type; + if (this.isObjectMethod(expression)) return; + const isOptionalMemberExpression = this.isOptionalMemberExpression(expression); + if (isOptionalMemberExpression || type === "MemberExpression") { + if (isOptionalMemberExpression) { + this.expectPlugin("optionalChainingAssign", expression.loc.start); + if (ancestor.type !== "AssignmentExpression") { + this.raise(Errors.InvalidLhsOptionalChaining, expression, { + ancestor + }); + } + } + if (binding !== 64) { + this.raise(Errors.InvalidPropertyBindingPattern, expression); + } + return; + } + if (type === "Identifier") { + this.checkIdentifier(expression, binding, strictModeChanged); + const { + name + } = expression; + if (checkClashes) { + if (checkClashes.has(name)) { + this.raise(Errors.ParamDupe, expression); + } else { + checkClashes.add(name); + } + } + return; + } else if (type === "VoidPattern" && ancestor.type === "CatchClause") { + this.raise(Errors.VoidPatternCatchClauseParam, expression); + } + const unwrappedExpression = unwrapParenthesizedExpression(expression); + disallowCallExpression || (disallowCallExpression = unwrappedExpression.type === "CallExpression" && (unwrappedExpression.callee.type === "Import" || unwrappedExpression.callee.type === "Super")); + const validity = this.isValidLVal(type, disallowCallExpression, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding); + if (validity === true) return; + if (validity === false) { + const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding; + this.raise(ParseErrorClass, expression, { + ancestor + }); + return; + } + let key, isParenthesizedExpression; + if (typeof validity === "string") { + key = validity; + isParenthesizedExpression = type === "ParenthesizedExpression"; + } else { + [key, isParenthesizedExpression] = validity; + } + const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" ? { + type + } : ancestor; + const val = expression[key]; + if (Array.isArray(val)) { + for (const child of val) { + if (child) { + this.checkLVal(child, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, true); + } + } + } else if (val) { + this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, disallowCallExpression); + } + } + checkIdentifier(at, bindingType, strictModeChanged = false) { + if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) { + if (bindingType === 64) { + this.raise(Errors.StrictEvalArguments, at, { + referenceName: at.name + }); + } else { + this.raise(Errors.StrictEvalArgumentsBinding, at, { + bindingName: at.name + }); + } + } + if (bindingType & 8192 && at.name === "let") { + this.raise(Errors.LetInLexicalBinding, at); + } + if (!(bindingType & 64)) { + this.declareNameFromIdentifier(at, bindingType); + } + } + declareNameFromIdentifier(identifier, binding) { + this.scope.declareName(identifier.name, binding, identifier.loc.start); + } + checkToRestConversion(node, allowPattern) { + switch (node.type) { + case "ParenthesizedExpression": + this.checkToRestConversion(node.expression, allowPattern); + break; + case "Identifier": + case "MemberExpression": + break; + case "ArrayExpression": + case "ObjectExpression": + if (allowPattern) break; + default: + this.raise(Errors.InvalidRestAssignmentPattern, node); + } + } + checkCommaAfterRest(close) { + if (!this.match(12)) { + return false; + } + this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc); + return true; + } +} +const keywordAndTSRelationalOperator = /in(?:stanceof)?|as|satisfies/y; +function nonNull(x) { + if (x == null) { + throw new Error(`Unexpected ${x} value.`); + } + return x; +} +function assert(x) { + if (!x) { + throw new Error("Assert fail"); + } +} +const TSErrors = ParseErrorEnum`typescript`({ + AbstractMethodHasImplementation: ({ + methodName + }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`, + AbstractPropertyHasInitializer: ({ + propertyName + }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`, + AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.", + AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.", + AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.", + ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.", + ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.", + ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.", + ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.", + DeclareAccessor: ({ + kind + }) => `'declare' is not allowed in ${kind}ters.`, + DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.", + DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.", + DuplicateAccessibilityModifier: ({ + modifier + }) => `Accessibility modifier already seen: '${modifier}'.`, + DuplicateModifier: ({ + modifier + }) => `Duplicate modifier: '${modifier}'.`, + EmptyHeritageClauseType: ({ + token + }) => `'${token}' list cannot be empty.`, + EmptyTypeArguments: "Type argument list cannot be empty.", + EmptyTypeParameters: "Type parameter list cannot be empty.", + ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.", + ImportAliasHasImportType: "An import alias can not use 'import type'.", + ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier", + IncompatibleModifiers: ({ + modifiers + }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`, + IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.", + IndexSignatureHasAccessibility: ({ + modifier + }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`, + IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.", + IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.", + IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.", + InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.", + InvalidHeritageClauseType: ({ + token + }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`, + InvalidModifierOnAwaitUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on an await using declaration.`, + InvalidModifierOnTypeMember: ({ + modifier + }) => `'${modifier}' modifier cannot appear on a type member.`, + InvalidModifierOnTypeParameter: ({ + modifier + }) => `'${modifier}' modifier cannot appear on a type parameter.`, + InvalidModifierOnTypeParameterPositions: ({ + modifier + }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`, + InvalidModifierOnUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on a using declaration.`, + InvalidModifiersOrder: ({ + orderedModifiers + }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`, + InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.", + InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.", + MissingInterfaceName: "'interface' declarations must be followed by an identifier.", + NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.", + NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.", + OptionalTypeBeforeRequired: "A required element cannot follow an optional element.", + OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.", + PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.", + PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.", + PrivateElementHasAccessibility: ({ + modifier + }) => `Private elements cannot have an accessibility modifier ('${modifier}').`, + ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.", + ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `() => ...`.", + ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.", + SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.", + SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.", + SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.", + SingleTypeParameterWithoutTrailingComma: ({ + typeParameterName + }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`, + StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.", + TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).", + TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.", + TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.", + TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.", + TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.", + UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.", + UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.", + UnexpectedTypeAnnotation: "Did not expect a type annotation here.", + UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.", + UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.", + UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.", + UnsupportedSignatureParameterKind: ({ + type + }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`, + UsingDeclarationInAmbientContext: kind => `'${kind}' declarations are not allowed in ambient contexts.` +}); +function keywordTypeFromName(value) { + switch (value) { + case "any": + return "TSAnyKeyword"; + case "boolean": + return "TSBooleanKeyword"; + case "bigint": + return "TSBigIntKeyword"; + case "never": + return "TSNeverKeyword"; + case "number": + return "TSNumberKeyword"; + case "object": + return "TSObjectKeyword"; + case "string": + return "TSStringKeyword"; + case "symbol": + return "TSSymbolKeyword"; + case "undefined": + return "TSUndefinedKeyword"; + case "unknown": + return "TSUnknownKeyword"; + default: + return undefined; + } +} +function tsIsAccessModifier(modifier) { + return modifier === "private" || modifier === "public" || modifier === "protected"; +} +function tsIsVarianceAnnotations(modifier) { + return modifier === "in" || modifier === "out"; +} +var typescript = superClass => class TypeScriptParserMixin extends superClass { + constructor(...args) { + super(...args); + this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, { + allowedModifiers: ["in", "out"], + disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"], + errorTemplate: TSErrors.InvalidModifierOnTypeParameter + }); + this.tsParseConstModifier = this.tsParseModifiers.bind(this, { + allowedModifiers: ["const"], + disallowedModifiers: ["in", "out"], + errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions + }); + this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, { + allowedModifiers: ["in", "out", "const"], + disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"], + errorTemplate: TSErrors.InvalidModifierOnTypeParameter + }); + } + getScopeHandler() { + return TypeScriptScopeHandler; + } + tsIsIdentifier() { + return tokenIsIdentifier(this.state.type); + } + tsTokenCanFollowModifier() { + return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(139) || this.isLiteralPropertyName(); + } + tsNextTokenOnSameLineAndCanFollowModifier() { + this.next(); + if (this.hasPrecedingLineBreak()) { + return false; + } + return this.tsTokenCanFollowModifier(); + } + tsNextTokenCanFollowModifier() { + if (this.match(106)) { + this.next(); + return this.tsTokenCanFollowModifier(); + } + return this.tsNextTokenOnSameLineAndCanFollowModifier(); + } + tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) { + if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) { + return undefined; + } + const modifier = this.state.value; + if (allowedModifiers.includes(modifier)) { + if (hasSeenStaticModifier && this.match(106)) { + return undefined; + } + if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) { + return undefined; + } + if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) { + return modifier; + } + } + return undefined; + } + tsParseModifiers({ + allowedModifiers, + disallowedModifiers, + stopOnStartOfClassStaticBlock, + errorTemplate = TSErrors.InvalidModifierOnTypeMember + }, modified) { + const enforceOrder = (loc, modifier, before, after) => { + if (modifier === before && modified[after]) { + this.raise(TSErrors.InvalidModifiersOrder, loc, { + orderedModifiers: [before, after] + }); + } + }; + const incompatible = (loc, modifier, mod1, mod2) => { + if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) { + this.raise(TSErrors.IncompatibleModifiers, loc, { + modifiers: [mod1, mod2] + }); + } + }; + for (;;) { + const { + startLoc + } = this.state; + const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock, modified.static); + if (!modifier) break; + if (tsIsAccessModifier(modifier)) { + if (modified.accessibility) { + this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, { + modifier + }); + } else { + enforceOrder(startLoc, modifier, modifier, "override"); + enforceOrder(startLoc, modifier, modifier, "static"); + enforceOrder(startLoc, modifier, modifier, "readonly"); + modified.accessibility = modifier; + } + } else if (tsIsVarianceAnnotations(modifier)) { + if (modified[modifier]) { + this.raise(TSErrors.DuplicateModifier, startLoc, { + modifier + }); + } + modified[modifier] = true; + enforceOrder(startLoc, modifier, "in", "out"); + } else { + if (hasOwnProperty.call(modified, modifier)) { + this.raise(TSErrors.DuplicateModifier, startLoc, { + modifier + }); + } else { + enforceOrder(startLoc, modifier, "static", "readonly"); + enforceOrder(startLoc, modifier, "static", "override"); + enforceOrder(startLoc, modifier, "override", "readonly"); + enforceOrder(startLoc, modifier, "abstract", "override"); + incompatible(startLoc, modifier, "declare", "override"); + incompatible(startLoc, modifier, "static", "abstract"); + } + modified[modifier] = true; + } + if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) { + this.raise(errorTemplate, startLoc, { + modifier + }); + } + } + } + tsIsListTerminator(kind) { + switch (kind) { + case "EnumMembers": + case "TypeMembers": + return this.match(8); + case "HeritageClauseElement": + return this.match(5); + case "TupleElementTypes": + return this.match(3); + case "TypeParametersOrArguments": + return this.match(48); + } + } + tsParseList(kind, parseElement) { + const result = []; + while (!this.tsIsListTerminator(kind)) { + result.push(parseElement()); + } + return result; + } + tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) { + return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos)); + } + tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) { + const result = []; + let trailingCommaPos = -1; + for (;;) { + if (this.tsIsListTerminator(kind)) { + break; + } + trailingCommaPos = -1; + const element = parseElement(); + if (element == null) { + return undefined; + } + result.push(element); + if (this.eat(12)) { + trailingCommaPos = this.state.lastTokStartLoc.index; + continue; + } + if (this.tsIsListTerminator(kind)) { + break; + } + if (expectSuccess) { + this.expect(12); + } + return undefined; + } + if (refTrailingCommaPos) { + refTrailingCommaPos.value = trailingCommaPos; + } + return result; + } + tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) { + if (!skipFirstToken) { + if (bracket) { + this.expect(0); + } else { + this.expect(47); + } + } + const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos); + if (bracket) { + this.expect(3); + } else { + this.expect(48); + } + return result; + } + tsParseImportType() { + const node = this.startNode(); + this.expect(83); + this.expect(10); + if (!this.match(134)) { + this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc); + node.argument = super.parseExprAtom(); + } else { + node.argument = this.parseStringLiteral(this.state.value); + } + if (this.eat(12)) { + node.options = this.tsParseImportTypeOptions(); + } else { + node.options = null; + } + this.expect(11); + if (this.eat(16)) { + node.qualifier = this.tsParseEntityName(1 | 2); + } + if (this.match(47)) { + node.typeParameters = this.tsParseTypeArguments(); + } + return this.finishNode(node, "TSImportType"); + } + tsParseImportTypeOptions() { + const node = this.startNode(); + this.expect(5); + const withProperty = this.startNode(); + if (this.isContextual(76)) { + withProperty.method = false; + withProperty.key = this.parseIdentifier(true); + withProperty.computed = false; + withProperty.shorthand = false; + } else { + this.unexpected(null, 76); + } + this.expect(14); + withProperty.value = this.tsParseImportTypeWithPropertyValue(); + node.properties = [this.finishObjectProperty(withProperty)]; + this.eat(12); + this.expect(8); + return this.finishNode(node, "ObjectExpression"); + } + tsParseImportTypeWithPropertyValue() { + const node = this.startNode(); + const properties = []; + this.expect(5); + while (!this.match(8)) { + const type = this.state.type; + if (tokenIsIdentifier(type) || type === 134) { + properties.push(super.parsePropertyDefinition(null)); + } else { + this.unexpected(); + } + this.eat(12); + } + node.properties = properties; + this.next(); + return this.finishNode(node, "ObjectExpression"); + } + tsParseEntityName(flags) { + let entity; + if (flags & 1 && this.match(78)) { + if (flags & 2) { + entity = this.parseIdentifier(true); + } else { + const node = this.startNode(); + this.next(); + entity = this.finishNode(node, "ThisExpression"); + } + } else { + entity = this.parseIdentifier(!!(flags & 1)); + } + while (this.eat(16)) { + const node = this.startNodeAtNode(entity); + node.left = entity; + node.right = this.parseIdentifier(!!(flags & 1)); + entity = this.finishNode(node, "TSQualifiedName"); + } + return entity; + } + tsParseTypeReference() { + const node = this.startNode(); + node.typeName = this.tsParseEntityName(1); + if (!this.hasPrecedingLineBreak() && this.match(47)) { + node.typeParameters = this.tsParseTypeArguments(); + } + return this.finishNode(node, "TSTypeReference"); + } + tsParseThisTypePredicate(lhs) { + this.next(); + const node = this.startNodeAtNode(lhs); + node.parameterName = lhs; + node.typeAnnotation = this.tsParseTypeAnnotation(false); + node.asserts = false; + return this.finishNode(node, "TSTypePredicate"); + } + tsParseThisTypeNode() { + const node = this.startNode(); + this.next(); + return this.finishNode(node, "TSThisType"); + } + tsParseTypeQuery() { + const node = this.startNode(); + this.expect(87); + if (this.match(83)) { + node.exprName = this.tsParseImportType(); + } else { + node.exprName = this.tsParseEntityName(1 | 2); + } + if (!this.hasPrecedingLineBreak() && this.match(47)) { + node.typeParameters = this.tsParseTypeArguments(); + } + return this.finishNode(node, "TSTypeQuery"); + } + tsParseTypeParameter(parseModifiers) { + const node = this.startNode(); + parseModifiers(node); + node.name = this.tsParseTypeParameterName(); + node.constraint = this.tsEatThenParseType(81); + node.default = this.tsEatThenParseType(29); + return this.finishNode(node, "TSTypeParameter"); + } + tsTryParseTypeParameters(parseModifiers) { + if (this.match(47)) { + return this.tsParseTypeParameters(parseModifiers); + } + } + tsParseTypeParameters(parseModifiers) { + const node = this.startNode(); + if (this.match(47) || this.match(143)) { + this.next(); + } else { + this.unexpected(); + } + const refTrailingCommaPos = { + value: -1 + }; + node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos); + if (node.params.length === 0) { + this.raise(TSErrors.EmptyTypeParameters, node); + } + if (refTrailingCommaPos.value !== -1) { + this.addExtra(node, "trailingComma", refTrailingCommaPos.value); + } + return this.finishNode(node, "TSTypeParameterDeclaration"); + } + tsFillSignature(returnToken, signature) { + const returnTokenRequired = returnToken === 19; + const paramsKey = "parameters"; + const returnTypeKey = "typeAnnotation"; + signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier); + this.expect(10); + signature[paramsKey] = this.tsParseBindingListForSignature(); + if (returnTokenRequired) { + signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); + } else if (this.match(returnToken)) { + signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); + } + } + tsParseBindingListForSignature() { + const list = super.parseBindingList(11, 41, 2); + for (const pattern of list) { + const { + type + } = pattern; + if (type === "AssignmentPattern" || type === "TSParameterProperty") { + this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, { + type + }); + } + } + return list; + } + tsParseTypeMemberSemicolon() { + if (!this.eat(12) && !this.isLineTerminator()) { + this.expect(13); + } + } + tsParseSignatureMember(kind, node) { + this.tsFillSignature(14, node); + this.tsParseTypeMemberSemicolon(); + return this.finishNode(node, kind); + } + tsIsUnambiguouslyIndexSignature() { + this.next(); + if (tokenIsIdentifier(this.state.type)) { + this.next(); + return this.match(14); + } + return false; + } + tsTryParseIndexSignature(node) { + if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) { + return; + } + this.expect(0); + const id = this.parseIdentifier(); + id.typeAnnotation = this.tsParseTypeAnnotation(); + this.resetEndLocation(id); + this.expect(3); + node.parameters = [id]; + const type = this.tsTryParseTypeAnnotation(); + if (type) node.typeAnnotation = type; + this.tsParseTypeMemberSemicolon(); + return this.finishNode(node, "TSIndexSignature"); + } + tsParsePropertyOrMethodSignature(node, readonly) { + if (this.eat(17)) node.optional = true; + if (this.match(10) || this.match(47)) { + if (readonly) { + this.raise(TSErrors.ReadonlyForMethodSignature, node); + } + const method = node; + if (method.kind && this.match(47)) { + this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition()); + } + this.tsFillSignature(14, method); + this.tsParseTypeMemberSemicolon(); + const paramsKey = "parameters"; + const returnTypeKey = "typeAnnotation"; + if (method.kind === "get") { + if (method[paramsKey].length > 0) { + this.raise(Errors.BadGetterArity, this.state.curPosition()); + if (this.isThisParam(method[paramsKey][0])) { + this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition()); + } + } + } else if (method.kind === "set") { + if (method[paramsKey].length !== 1) { + this.raise(Errors.BadSetterArity, this.state.curPosition()); + } else { + const firstParameter = method[paramsKey][0]; + if (this.isThisParam(firstParameter)) { + this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition()); + } + if (firstParameter.type === "Identifier" && firstParameter.optional) { + this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition()); + } + if (firstParameter.type === "RestElement") { + this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition()); + } + } + if (method[returnTypeKey]) { + this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]); + } + } else { + method.kind = "method"; + } + return this.finishNode(method, "TSMethodSignature"); + } else { + const property = node; + if (readonly) property.readonly = true; + const type = this.tsTryParseTypeAnnotation(); + if (type) property.typeAnnotation = type; + this.tsParseTypeMemberSemicolon(); + return this.finishNode(property, "TSPropertySignature"); + } + } + tsParseTypeMember() { + const node = this.startNode(); + if (this.match(10) || this.match(47)) { + return this.tsParseSignatureMember("TSCallSignatureDeclaration", node); + } + if (this.match(77)) { + const id = this.startNode(); + this.next(); + if (this.match(10) || this.match(47)) { + return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node); + } else { + node.key = this.createIdentifier(id, "new"); + return this.tsParsePropertyOrMethodSignature(node, false); + } + } + this.tsParseModifiers({ + allowedModifiers: ["readonly"], + disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"] + }, node); + const idx = this.tsTryParseIndexSignature(node); + if (idx) { + return idx; + } + super.parsePropertyName(node); + if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) { + node.kind = node.key.name; + super.parsePropertyName(node); + if (!this.match(10) && !this.match(47)) { + this.unexpected(null, 10); + } + } + return this.tsParsePropertyOrMethodSignature(node, !!node.readonly); + } + tsParseTypeLiteral() { + const node = this.startNode(); + node.members = this.tsParseObjectTypeMembers(); + return this.finishNode(node, "TSTypeLiteral"); + } + tsParseObjectTypeMembers() { + this.expect(5); + const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this)); + this.expect(8); + return members; + } + tsIsStartOfMappedType() { + this.next(); + if (this.eat(53)) { + return this.isContextual(122); + } + if (this.isContextual(122)) { + this.next(); + } + if (!this.match(0)) { + return false; + } + this.next(); + if (!this.tsIsIdentifier()) { + return false; + } + this.next(); + return this.match(58); + } + tsParseMappedType() { + const node = this.startNode(); + this.expect(5); + if (this.match(53)) { + node.readonly = this.state.value; + this.next(); + this.expectContextual(122); + } else if (this.eatContextual(122)) { + node.readonly = true; + } + this.expect(0); + const typeParameter = this.startNode(); + typeParameter.name = this.tsParseTypeParameterName(); + typeParameter.constraint = this.tsExpectThenParseType(58); + node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter"); + node.nameType = this.eatContextual(93) ? this.tsParseType() : null; + this.expect(3); + if (this.match(53)) { + node.optional = this.state.value; + this.next(); + this.expect(17); + } else if (this.eat(17)) { + node.optional = true; + } + node.typeAnnotation = this.tsTryParseType(); + this.semicolon(); + this.expect(8); + return this.finishNode(node, "TSMappedType"); + } + tsParseTupleType() { + const node = this.startNode(); + node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false); + let seenOptionalElement = false; + node.elementTypes.forEach(elementNode => { + const { + type + } = elementNode; + if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) { + this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode); + } + seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType"); + }); + return this.finishNode(node, "TSTupleType"); + } + tsParseTupleElementType() { + const restStartLoc = this.state.startLoc; + const rest = this.eat(21); + const { + startLoc + } = this.state; + let labeled; + let label; + let optional; + let type; + const isWord = tokenIsKeywordOrIdentifier(this.state.type); + const chAfterWord = isWord ? this.lookaheadCharCode() : null; + if (chAfterWord === 58) { + labeled = true; + optional = false; + label = this.parseIdentifier(true); + this.expect(14); + type = this.tsParseType(); + } else if (chAfterWord === 63) { + optional = true; + const wordName = this.state.value; + const typeOrLabel = this.tsParseNonArrayType(); + if (this.lookaheadCharCode() === 58) { + labeled = true; + label = this.createIdentifier(this.startNodeAt(startLoc), wordName); + this.expect(17); + this.expect(14); + type = this.tsParseType(); + } else { + labeled = false; + type = typeOrLabel; + this.expect(17); + } + } else { + type = this.tsParseType(); + optional = this.eat(17); + labeled = this.eat(14); + } + if (labeled) { + let labeledNode; + if (label) { + labeledNode = this.startNodeAt(startLoc); + labeledNode.optional = optional; + labeledNode.label = label; + labeledNode.elementType = type; + if (this.eat(17)) { + labeledNode.optional = true; + this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc); + } + } else { + labeledNode = this.startNodeAt(startLoc); + labeledNode.optional = optional; + this.raise(TSErrors.InvalidTupleMemberLabel, type); + labeledNode.label = type; + labeledNode.elementType = this.tsParseType(); + } + type = this.finishNode(labeledNode, "TSNamedTupleMember"); + } else if (optional) { + const optionalTypeNode = this.startNodeAt(startLoc); + optionalTypeNode.typeAnnotation = type; + type = this.finishNode(optionalTypeNode, "TSOptionalType"); + } + if (rest) { + const restNode = this.startNodeAt(restStartLoc); + restNode.typeAnnotation = type; + type = this.finishNode(restNode, "TSRestType"); + } + return type; + } + tsParseParenthesizedType() { + const node = this.startNode(); + this.expect(10); + node.typeAnnotation = this.tsParseType(); + this.expect(11); + return this.finishNode(node, "TSParenthesizedType"); + } + tsParseFunctionOrConstructorType(type, abstract) { + const node = this.startNode(); + if (type === "TSConstructorType") { + node.abstract = !!abstract; + if (abstract) this.next(); + this.next(); + } + this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node)); + return this.finishNode(node, type); + } + tsParseLiteralTypeNode() { + const node = this.startNode(); + switch (this.state.type) { + case 135: + case 136: + case 134: + case 85: + case 86: + node.literal = super.parseExprAtom(); + break; + default: + this.unexpected(); + } + return this.finishNode(node, "TSLiteralType"); + } + tsParseTemplateLiteralType() { + const node = this.startNode(); + node.literal = super.parseTemplate(false); + return this.finishNode(node, "TSLiteralType"); + } + parseTemplateSubstitution() { + if (this.state.inType) return this.tsParseType(); + return super.parseTemplateSubstitution(); + } + tsParseThisTypeOrThisTypePredicate() { + const thisKeyword = this.tsParseThisTypeNode(); + if (this.isContextual(116) && !this.hasPrecedingLineBreak()) { + return this.tsParseThisTypePredicate(thisKeyword); + } else { + return thisKeyword; + } + } + tsParseNonArrayType() { + switch (this.state.type) { + case 134: + case 135: + case 136: + case 85: + case 86: + return this.tsParseLiteralTypeNode(); + case 53: + if (this.state.value === "-") { + const node = this.startNode(); + const nextToken = this.lookahead(); + if (nextToken.type !== 135 && nextToken.type !== 136) { + this.unexpected(); + } + node.literal = this.parseMaybeUnary(); + return this.finishNode(node, "TSLiteralType"); + } + break; + case 78: + return this.tsParseThisTypeOrThisTypePredicate(); + case 87: + return this.tsParseTypeQuery(); + case 83: + return this.tsParseImportType(); + case 5: + return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral(); + case 0: + return this.tsParseTupleType(); + case 10: + return this.tsParseParenthesizedType(); + case 25: + case 24: + return this.tsParseTemplateLiteralType(); + default: + { + const { + type + } = this.state; + if (tokenIsIdentifier(type) || type === 88 || type === 84) { + const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value); + if (nodeType !== undefined && this.lookaheadCharCode() !== 46) { + const node = this.startNode(); + this.next(); + return this.finishNode(node, nodeType); + } + return this.tsParseTypeReference(); + } + } + } + throw this.unexpected(); + } + tsParseArrayTypeOrHigher() { + const { + startLoc + } = this.state; + let type = this.tsParseNonArrayType(); + while (!this.hasPrecedingLineBreak() && this.eat(0)) { + if (this.match(3)) { + const node = this.startNodeAt(startLoc); + node.elementType = type; + this.expect(3); + type = this.finishNode(node, "TSArrayType"); + } else { + const node = this.startNodeAt(startLoc); + node.objectType = type; + node.indexType = this.tsParseType(); + this.expect(3); + type = this.finishNode(node, "TSIndexedAccessType"); + } + } + return type; + } + tsParseTypeOperator() { + const node = this.startNode(); + const operator = this.state.value; + this.next(); + node.operator = operator; + node.typeAnnotation = this.tsParseTypeOperatorOrHigher(); + if (operator === "readonly") { + this.tsCheckTypeAnnotationForReadOnly(node); + } + return this.finishNode(node, "TSTypeOperator"); + } + tsCheckTypeAnnotationForReadOnly(node) { + switch (node.typeAnnotation.type) { + case "TSTupleType": + case "TSArrayType": + return; + default: + this.raise(TSErrors.UnexpectedReadonly, node); + } + } + tsParseInferType() { + const node = this.startNode(); + this.expectContextual(115); + const typeParameter = this.startNode(); + typeParameter.name = this.tsParseTypeParameterName(); + typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType()); + node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter"); + return this.finishNode(node, "TSInferType"); + } + tsParseConstraintForInferType() { + if (this.eat(81)) { + const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType()); + if (this.state.inDisallowConditionalTypesContext || !this.match(17)) { + return constraint; + } + } + } + tsParseTypeOperatorOrHigher() { + const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc; + return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher()); + } + tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) { + const node = this.startNode(); + const hasLeadingOperator = this.eat(operator); + const types = []; + do { + types.push(parseConstituentType()); + } while (this.eat(operator)); + if (types.length === 1 && !hasLeadingOperator) { + return types[0]; + } + node.types = types; + return this.finishNode(node, kind); + } + tsParseIntersectionTypeOrHigher() { + return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45); + } + tsParseUnionTypeOrHigher() { + return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43); + } + tsIsStartOfFunctionType() { + if (this.match(47)) { + return true; + } + return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this)); + } + tsSkipParameterStart() { + if (tokenIsIdentifier(this.state.type) || this.match(78)) { + this.next(); + return true; + } + if (this.match(5)) { + const { + errors + } = this.state; + const previousErrorCount = errors.length; + try { + this.parseObjectLike(8, true); + return errors.length === previousErrorCount; + } catch (_unused) { + return false; + } + } + if (this.match(0)) { + this.next(); + const { + errors + } = this.state; + const previousErrorCount = errors.length; + try { + super.parseBindingList(3, 93, 1); + return errors.length === previousErrorCount; + } catch (_unused2) { + return false; + } + } + return false; + } + tsIsUnambiguouslyStartOfFunctionType() { + this.next(); + if (this.match(11) || this.match(21)) { + return true; + } + if (this.tsSkipParameterStart()) { + if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) { + return true; + } + if (this.match(11)) { + this.next(); + if (this.match(19)) { + return true; + } + } + } + return false; + } + tsParseTypeOrTypePredicateAnnotation(returnToken) { + return this.tsInType(() => { + const t = this.startNode(); + this.expect(returnToken); + const node = this.startNode(); + const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this)); + if (asserts && this.match(78)) { + let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate(); + if (thisTypePredicate.type === "TSThisType") { + node.parameterName = thisTypePredicate; + node.asserts = true; + node.typeAnnotation = null; + thisTypePredicate = this.finishNode(node, "TSTypePredicate"); + } else { + this.resetStartLocationFromNode(thisTypePredicate, node); + thisTypePredicate.asserts = true; + } + t.typeAnnotation = thisTypePredicate; + return this.finishNode(t, "TSTypeAnnotation"); + } + const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this)); + if (!typePredicateVariable) { + if (!asserts) { + return this.tsParseTypeAnnotation(false, t); + } + node.parameterName = this.parseIdentifier(); + node.asserts = asserts; + node.typeAnnotation = null; + t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); + return this.finishNode(t, "TSTypeAnnotation"); + } + const type = this.tsParseTypeAnnotation(false); + node.parameterName = typePredicateVariable; + node.typeAnnotation = type; + node.asserts = asserts; + t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); + return this.finishNode(t, "TSTypeAnnotation"); + }); + } + tsTryParseTypeOrTypePredicateAnnotation() { + if (this.match(14)) { + return this.tsParseTypeOrTypePredicateAnnotation(14); + } + } + tsTryParseTypeAnnotation() { + if (this.match(14)) { + return this.tsParseTypeAnnotation(); + } + } + tsTryParseType() { + return this.tsEatThenParseType(14); + } + tsParseTypePredicatePrefix() { + const id = this.parseIdentifier(); + if (this.isContextual(116) && !this.hasPrecedingLineBreak()) { + this.next(); + return id; + } + } + tsParseTypePredicateAsserts() { + if (this.state.type !== 109) { + return false; + } + const containsEsc = this.state.containsEsc; + this.next(); + if (!tokenIsIdentifier(this.state.type) && !this.match(78)) { + return false; + } + if (containsEsc) { + this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, { + reservedWord: "asserts" + }); + } + return true; + } + tsParseTypeAnnotation(eatColon = true, t = this.startNode()) { + this.tsInType(() => { + if (eatColon) this.expect(14); + t.typeAnnotation = this.tsParseType(); + }); + return this.finishNode(t, "TSTypeAnnotation"); + } + tsParseType() { + assert(this.state.inType); + const type = this.tsParseNonConditionalType(); + if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) { + return type; + } + const node = this.startNodeAtNode(type); + node.checkType = type; + node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType()); + this.expect(17); + node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); + this.expect(14); + node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); + return this.finishNode(node, "TSConditionalType"); + } + isAbstractConstructorSignature() { + return this.isContextual(124) && this.isLookaheadContextual("new"); + } + tsParseNonConditionalType() { + if (this.tsIsStartOfFunctionType()) { + return this.tsParseFunctionOrConstructorType("TSFunctionType"); + } + if (this.match(77)) { + return this.tsParseFunctionOrConstructorType("TSConstructorType"); + } else if (this.isAbstractConstructorSignature()) { + return this.tsParseFunctionOrConstructorType("TSConstructorType", true); + } + return this.tsParseUnionTypeOrHigher(); + } + tsParseTypeAssertion() { + if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { + this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc); + } + const node = this.startNode(); + node.typeAnnotation = this.tsInType(() => { + this.next(); + return this.match(75) ? this.tsParseTypeReference() : this.tsParseType(); + }); + this.expect(48); + node.expression = this.parseMaybeUnary(); + return this.finishNode(node, "TSTypeAssertion"); + } + tsParseHeritageClause(token) { + const originalStartLoc = this.state.startLoc; + const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => { + const node = this.startNode(); + node.expression = this.tsParseEntityName(1 | 2); + if (this.match(47)) { + node.typeParameters = this.tsParseTypeArguments(); + } + return this.finishNode(node, "TSExpressionWithTypeArguments"); + }); + if (!delimitedList.length) { + this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, { + token + }); + } + return delimitedList; + } + tsParseInterfaceDeclaration(node, properties = {}) { + if (this.hasFollowingLineBreak()) return null; + this.expectContextual(129); + if (properties.declare) node.declare = true; + if (tokenIsIdentifier(this.state.type)) { + node.id = this.parseIdentifier(); + this.checkIdentifier(node.id, 130); + } else { + node.id = null; + this.raise(TSErrors.MissingInterfaceName, this.state.startLoc); + } + node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers); + if (this.eat(81)) { + node.extends = this.tsParseHeritageClause("extends"); + } + const body = this.startNode(); + body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this)); + node.body = this.finishNode(body, "TSInterfaceBody"); + return this.finishNode(node, "TSInterfaceDeclaration"); + } + tsParseTypeAliasDeclaration(node) { + node.id = this.parseIdentifier(); + this.checkIdentifier(node.id, 2); + node.typeAnnotation = this.tsInType(() => { + node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers); + this.expect(29); + if (this.isContextual(114) && this.lookaheadCharCode() !== 46) { + const node = this.startNode(); + this.next(); + return this.finishNode(node, "TSIntrinsicKeyword"); + } + return this.tsParseType(); + }); + this.semicolon(); + return this.finishNode(node, "TSTypeAliasDeclaration"); + } + tsInTopLevelContext(cb) { + if (this.curContext() !== types.brace) { + const oldContext = this.state.context; + this.state.context = [oldContext[0]]; + try { + return cb(); + } finally { + this.state.context = oldContext; + } + } else { + return cb(); + } + } + tsInType(cb) { + const oldInType = this.state.inType; + this.state.inType = true; + try { + return cb(); + } finally { + this.state.inType = oldInType; + } + } + tsInDisallowConditionalTypesContext(cb) { + const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; + this.state.inDisallowConditionalTypesContext = true; + try { + return cb(); + } finally { + this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; + } + } + tsInAllowConditionalTypesContext(cb) { + const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; + this.state.inDisallowConditionalTypesContext = false; + try { + return cb(); + } finally { + this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; + } + } + tsEatThenParseType(token) { + if (this.match(token)) { + return this.tsNextThenParseType(); + } + } + tsExpectThenParseType(token) { + return this.tsInType(() => { + this.expect(token); + return this.tsParseType(); + }); + } + tsNextThenParseType() { + return this.tsInType(() => { + this.next(); + return this.tsParseType(); + }); + } + tsParseEnumMember() { + const node = this.startNode(); + node.id = this.match(134) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true); + if (this.eat(29)) { + node.initializer = super.parseMaybeAssignAllowIn(); + } + return this.finishNode(node, "TSEnumMember"); + } + tsParseEnumDeclaration(node, properties = {}) { + if (properties.const) node.const = true; + if (properties.declare) node.declare = true; + this.expectContextual(126); + node.id = this.parseIdentifier(); + this.checkIdentifier(node.id, node.const ? 8971 : 8459); + this.expect(5); + node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)); + this.expect(8); + return this.finishNode(node, "TSEnumDeclaration"); + } + tsParseEnumBody() { + const node = this.startNode(); + this.expect(5); + node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)); + this.expect(8); + return this.finishNode(node, "TSEnumBody"); + } + tsParseModuleBlock() { + const node = this.startNode(); + this.scope.enter(0); + this.expect(5); + super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8); + this.scope.exit(); + return this.finishNode(node, "TSModuleBlock"); + } + tsParseModuleOrNamespaceDeclaration(node, nested = false) { + node.id = this.parseIdentifier(); + if (!nested) { + this.checkIdentifier(node.id, 1024); + } + if (this.eat(16)) { + const inner = this.startNode(); + this.tsParseModuleOrNamespaceDeclaration(inner, true); + node.body = inner; + } else { + this.scope.enter(1024); + this.prodParam.enter(0); + node.body = this.tsParseModuleBlock(); + this.prodParam.exit(); + this.scope.exit(); + } + return this.finishNode(node, "TSModuleDeclaration"); + } + tsParseAmbientExternalModuleDeclaration(node) { + if (this.isContextual(112)) { + node.kind = "global"; + node.global = true; + node.id = this.parseIdentifier(); + } else if (this.match(134)) { + node.kind = "module"; + node.id = super.parseStringLiteral(this.state.value); + } else { + this.unexpected(); + } + if (this.match(5)) { + this.scope.enter(1024); + this.prodParam.enter(0); + node.body = this.tsParseModuleBlock(); + this.prodParam.exit(); + this.scope.exit(); + } else { + this.semicolon(); + } + return this.finishNode(node, "TSModuleDeclaration"); + } + tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) { + node.isExport = isExport || false; + node.id = maybeDefaultIdentifier || this.parseIdentifier(); + this.checkIdentifier(node.id, 4096); + this.expect(29); + const moduleReference = this.tsParseModuleReference(); + if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") { + this.raise(TSErrors.ImportAliasHasImportType, moduleReference); + } + node.moduleReference = moduleReference; + this.semicolon(); + return this.finishNode(node, "TSImportEqualsDeclaration"); + } + tsIsExternalModuleReference() { + return this.isContextual(119) && this.lookaheadCharCode() === 40; + } + tsParseModuleReference() { + return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0); + } + tsParseExternalModuleReference() { + const node = this.startNode(); + this.expectContextual(119); + this.expect(10); + if (!this.match(134)) { + this.unexpected(); + } + node.expression = super.parseExprAtom(); + this.expect(11); + this.sawUnambiguousESM = true; + return this.finishNode(node, "TSExternalModuleReference"); + } + tsLookAhead(f) { + const state = this.state.clone(); + const res = f(); + this.state = state; + return res; + } + tsTryParseAndCatch(f) { + const result = this.tryParse(abort => f() || abort()); + if (result.aborted || !result.node) return; + if (result.error) this.state = result.failState; + return result.node; + } + tsTryParse(f) { + const state = this.state.clone(); + const result = f(); + if (result !== undefined && result !== false) { + return result; + } + this.state = state; + } + tsTryParseDeclare(node) { + if (this.isLineTerminator()) { + return; + } + const startType = this.state.type; + return this.tsInAmbientContext(() => { + switch (startType) { + case 68: + node.declare = true; + return super.parseFunctionStatement(node, false, false); + case 80: + node.declare = true; + return this.parseClass(node, true, false); + case 126: + return this.tsParseEnumDeclaration(node, { + declare: true + }); + case 112: + return this.tsParseAmbientExternalModuleDeclaration(node); + case 100: + if (this.state.containsEsc) { + return; + } + case 75: + case 74: + if (!this.match(75) || !this.isLookaheadContextual("enum")) { + node.declare = true; + return this.parseVarStatement(node, this.state.value, true); + } + this.expect(75); + return this.tsParseEnumDeclaration(node, { + const: true, + declare: true + }); + case 107: + if (this.isUsing()) { + this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare"); + node.declare = true; + return this.parseVarStatement(node, "using", true); + } + break; + case 96: + if (this.isAwaitUsing()) { + this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare"); + node.declare = true; + this.next(); + return this.parseVarStatement(node, "await using", true); + } + break; + case 129: + { + const result = this.tsParseInterfaceDeclaration(node, { + declare: true + }); + if (result) return result; + } + default: + if (tokenIsIdentifier(startType)) { + return this.tsParseDeclaration(node, this.state.type, true, null); + } + } + }); + } + tsTryParseExportDeclaration() { + return this.tsParseDeclaration(this.startNode(), this.state.type, true, null); + } + tsParseDeclaration(node, type, next, decorators) { + switch (type) { + case 124: + if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) { + return this.tsParseAbstractDeclaration(node, decorators); + } + break; + case 127: + if (this.tsCheckLineTerminator(next)) { + if (this.match(134)) { + return this.tsParseAmbientExternalModuleDeclaration(node); + } else if (tokenIsIdentifier(this.state.type)) { + node.kind = "module"; + return this.tsParseModuleOrNamespaceDeclaration(node); + } + } + break; + case 128: + if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { + node.kind = "namespace"; + return this.tsParseModuleOrNamespaceDeclaration(node); + } + break; + case 130: + if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { + return this.tsParseTypeAliasDeclaration(node); + } + break; + } + } + tsCheckLineTerminator(next) { + if (next) { + if (this.hasFollowingLineBreak()) return false; + this.next(); + return true; + } + return !this.isLineTerminator(); + } + tsTryParseGenericAsyncArrowFunction(startLoc) { + if (!this.match(47)) return; + const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; + this.state.maybeInArrowParameters = true; + const res = this.tsTryParseAndCatch(() => { + const node = this.startNodeAt(startLoc); + node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier); + super.parseFunctionParams(node); + node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation(); + this.expect(19); + return node; + }); + this.state.maybeInArrowParameters = oldMaybeInArrowParameters; + if (!res) return; + return super.parseArrowExpression(res, null, true); + } + tsParseTypeArgumentsInExpression() { + if (this.reScan_lt() !== 47) return; + return this.tsParseTypeArguments(); + } + tsParseTypeArguments() { + const node = this.startNode(); + node.params = this.tsInType(() => this.tsInTopLevelContext(() => { + this.expect(47); + return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this)); + })); + if (node.params.length === 0) { + this.raise(TSErrors.EmptyTypeArguments, node); + } else if (!this.state.inType && this.curContext() === types.brace) { + this.reScan_lt_gt(); + } + this.expect(48); + return this.finishNode(node, "TSTypeParameterInstantiation"); + } + tsIsDeclarationStart() { + return tokenIsTSDeclarationStart(this.state.type); + } + isExportDefaultSpecifier() { + if (this.tsIsDeclarationStart()) return false; + return super.isExportDefaultSpecifier(); + } + parseBindingElement(flags, decorators) { + const startLoc = decorators.length ? decorators[0].loc.start : this.state.startLoc; + const modified = {}; + this.tsParseModifiers({ + allowedModifiers: ["public", "private", "protected", "override", "readonly"] + }, modified); + const accessibility = modified.accessibility; + const override = modified.override; + const readonly = modified.readonly; + if (!(flags & 4) && (accessibility || readonly || override)) { + this.raise(TSErrors.UnexpectedParameterModifier, startLoc); + } + const left = this.parseMaybeDefault(); + if (flags & 2) { + this.parseFunctionParamType(left); + } + const elt = this.parseMaybeDefault(left.loc.start, left); + if (accessibility || readonly || override) { + const pp = this.startNodeAt(startLoc); + if (decorators.length) { + pp.decorators = decorators; + } + if (accessibility) pp.accessibility = accessibility; + if (readonly) pp.readonly = readonly; + if (override) pp.override = override; + if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") { + this.raise(TSErrors.UnsupportedParameterPropertyKind, pp); + } + pp.parameter = elt; + return this.finishNode(pp, "TSParameterProperty"); + } + if (decorators.length) { + left.decorators = decorators; + } + return elt; + } + isSimpleParameter(node) { + return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node); + } + tsDisallowOptionalPattern(node) { + for (const param of node.params) { + if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) { + this.raise(TSErrors.PatternIsOptional, param); + } + } + } + setArrowFunctionParameters(node, params, trailingCommaLoc) { + super.setArrowFunctionParameters(node, params, trailingCommaLoc); + this.tsDisallowOptionalPattern(node); + } + parseFunctionBodyAndFinish(node, type, isMethod = false) { + if (this.match(14)) { + node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14); + } + const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined; + if (bodilessType && !this.match(5) && this.isLineTerminator()) { + return this.finishNode(node, bodilessType); + } + if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) { + this.raise(TSErrors.DeclareFunctionHasImplementation, node); + if (node.declare) { + return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod); + } + } + this.tsDisallowOptionalPattern(node); + return super.parseFunctionBodyAndFinish(node, type, isMethod); + } + registerFunctionStatementId(node) { + if (!node.body && node.id) { + this.checkIdentifier(node.id, 1024); + } else { + super.registerFunctionStatementId(node); + } + } + tsCheckForInvalidTypeCasts(items) { + items.forEach(node => { + if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") { + this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation); + } + }); + } + toReferencedList(exprList, isInParens) { + this.tsCheckForInvalidTypeCasts(exprList); + return exprList; + } + parseArrayLike(close, isTuple, refExpressionErrors) { + const node = super.parseArrayLike(close, isTuple, refExpressionErrors); + if (node.type === "ArrayExpression") { + this.tsCheckForInvalidTypeCasts(node.elements); + } + return node; + } + parseSubscript(base, startLoc, noCalls, state) { + if (!this.hasPrecedingLineBreak() && this.match(35)) { + this.state.canStartJSXElement = false; + this.next(); + const nonNullExpression = this.startNodeAt(startLoc); + nonNullExpression.expression = base; + return this.finishNode(nonNullExpression, "TSNonNullExpression"); + } + let isOptionalCall = false; + if (this.match(18) && this.lookaheadCharCode() === 60) { + if (noCalls) { + state.stop = true; + return base; + } + state.optionalChainMember = isOptionalCall = true; + this.next(); + } + if (this.match(47) || this.match(51)) { + let missingParenErrorLoc; + const result = this.tsTryParseAndCatch(() => { + if (!noCalls && this.atPossibleAsyncArrow(base)) { + const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc); + if (asyncArrowFn) { + state.stop = true; + return asyncArrowFn; + } + } + const typeArguments = this.tsParseTypeArgumentsInExpression(); + if (!typeArguments) return; + if (isOptionalCall && !this.match(10)) { + missingParenErrorLoc = this.state.curPosition(); + return; + } + if (tokenIsTemplate(this.state.type)) { + const result = super.parseTaggedTemplateExpression(base, startLoc, state); + result.typeParameters = typeArguments; + return result; + } + if (!noCalls && this.eat(10)) { + const node = this.startNodeAt(startLoc); + node.callee = base; + node.arguments = this.parseCallExpressionArguments(); + this.tsCheckForInvalidTypeCasts(node.arguments); + node.typeParameters = typeArguments; + if (state.optionalChainMember) { + node.optional = isOptionalCall; + } + return this.finishCallExpression(node, state.optionalChainMember); + } + const tokenType = this.state.type; + if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenType !== 93 && tokenType !== 120 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) { + return; + } + const node = this.startNodeAt(startLoc); + node.expression = base; + node.typeParameters = typeArguments; + return this.finishNode(node, "TSInstantiationExpression"); + }); + if (missingParenErrorLoc) { + this.unexpected(missingParenErrorLoc, 10); + } + if (result) { + if (result.type === "TSInstantiationExpression") { + if (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40) { + this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc); + } + if (!this.match(16) && !this.match(18)) { + result.expression = super.stopParseSubscript(base, state); + } + } + return result; + } + } + return super.parseSubscript(base, startLoc, noCalls, state); + } + parseNewCallee(node) { + var _callee$extra; + super.parseNewCallee(node); + const { + callee + } = node; + if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) { + node.typeParameters = callee.typeParameters; + node.callee = callee.expression; + } + } + parseExprOp(left, leftStartLoc, minPrec) { + let isSatisfies; + if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) { + const node = this.startNodeAt(leftStartLoc); + node.expression = left; + node.typeAnnotation = this.tsInType(() => { + this.next(); + if (this.match(75)) { + if (isSatisfies) { + this.raise(Errors.UnexpectedKeyword, this.state.startLoc, { + keyword: "const" + }); + } + return this.tsParseTypeReference(); + } + return this.tsParseType(); + }); + this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression"); + this.reScan_lt_gt(); + return this.parseExprOp(node, leftStartLoc, minPrec); + } + return super.parseExprOp(left, leftStartLoc, minPrec); + } + checkReservedWord(word, startLoc, checkKeywords, isBinding) { + if (!this.state.isAmbientContext) { + super.checkReservedWord(word, startLoc, checkKeywords, isBinding); + } + } + checkImportReflection(node) { + super.checkImportReflection(node); + if (node.module && node.importKind !== "value") { + this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start); + } + } + checkDuplicateExports() {} + isPotentialImportPhase(isExport) { + if (super.isPotentialImportPhase(isExport)) return true; + if (this.isContextual(130)) { + const ch = this.lookaheadCharCode(); + return isExport ? ch === 123 || ch === 42 : ch !== 61; + } + return !isExport && this.isContextual(87); + } + applyImportPhase(node, isExport, phase, loc) { + super.applyImportPhase(node, isExport, phase, loc); + if (isExport) { + node.exportKind = phase === "type" ? "type" : "value"; + } else { + node.importKind = phase === "type" || phase === "typeof" ? phase : "value"; + } + } + parseImport(node) { + if (this.match(134)) { + node.importKind = "value"; + return super.parseImport(node); + } + let importNode; + if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) { + node.importKind = "value"; + return this.tsParseImportEqualsDeclaration(node); + } else if (this.isContextual(130)) { + const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false); + if (this.lookaheadCharCode() === 61) { + return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier); + } else { + importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier); + } + } else { + importNode = super.parseImport(node); + } + if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") { + this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode); + } + return importNode; + } + parseExport(node, decorators) { + if (this.match(83)) { + const nodeImportEquals = node; + this.next(); + let maybeDefaultIdentifier = null; + if (this.isContextual(130) && this.isPotentialImportPhase(false)) { + maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false); + } else { + nodeImportEquals.importKind = "value"; + } + const declaration = this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true); + return declaration; + } else if (this.eat(29)) { + const assign = node; + assign.expression = super.parseExpression(); + this.semicolon(); + this.sawUnambiguousESM = true; + return this.finishNode(assign, "TSExportAssignment"); + } else if (this.eatContextual(93)) { + const decl = node; + this.expectContextual(128); + decl.id = this.parseIdentifier(); + this.semicolon(); + return this.finishNode(decl, "TSNamespaceExportDeclaration"); + } else { + return super.parseExport(node, decorators); + } + } + isAbstractClass() { + return this.isContextual(124) && this.isLookaheadContextual("class"); + } + parseExportDefaultExpression() { + if (this.isAbstractClass()) { + const cls = this.startNode(); + this.next(); + cls.abstract = true; + return this.parseClass(cls, true, true); + } + if (this.match(129)) { + const result = this.tsParseInterfaceDeclaration(this.startNode()); + if (result) return result; + } + return super.parseExportDefaultExpression(); + } + parseVarStatement(node, kind, allowMissingInitializer = false) { + const { + isAmbientContext + } = this.state; + const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext); + if (!isAmbientContext) return declaration; + if (!node.declare && (kind === "using" || kind === "await using")) { + this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind); + return declaration; + } + for (const { + id, + init + } of declaration.declarations) { + if (!init) continue; + if (kind === "var" || kind === "let" || !!id.typeAnnotation) { + this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init); + } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) { + this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init); + } + } + return declaration; + } + parseStatementContent(flags, decorators) { + if (!this.state.containsEsc) { + switch (this.state.type) { + case 75: + { + if (this.isLookaheadContextual("enum")) { + const node = this.startNode(); + this.expect(75); + return this.tsParseEnumDeclaration(node, { + const: true + }); + } + break; + } + case 124: + case 125: + { + if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) { + const token = this.state.type; + const node = this.startNode(); + this.next(); + const declaration = token === 125 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators); + if (declaration) { + if (token === 125) { + declaration.declare = true; + } + return declaration; + } else { + node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 125 ? "declare" : "abstract"); + this.semicolon(false); + return this.finishNode(node, "ExpressionStatement"); + } + } + break; + } + case 126: + return this.tsParseEnumDeclaration(this.startNode()); + case 112: + { + const nextCh = this.lookaheadCharCode(); + if (nextCh === 123) { + const node = this.startNode(); + return this.tsParseAmbientExternalModuleDeclaration(node); + } + break; + } + case 129: + { + const result = this.tsParseInterfaceDeclaration(this.startNode()); + if (result) return result; + break; + } + case 127: + { + if (this.nextTokenIsIdentifierOrStringLiteralOnSameLine()) { + const node = this.startNode(); + this.next(); + return this.tsParseDeclaration(node, 127, false, decorators); + } + break; + } + case 128: + { + if (this.nextTokenIsIdentifierOnSameLine()) { + const node = this.startNode(); + this.next(); + return this.tsParseDeclaration(node, 128, false, decorators); + } + break; + } + case 130: + { + if (this.nextTokenIsIdentifierOnSameLine()) { + const node = this.startNode(); + this.next(); + return this.tsParseTypeAliasDeclaration(node); + } + break; + } + } + } + return super.parseStatementContent(flags, decorators); + } + parseAccessModifier() { + return this.tsParseModifier(["public", "protected", "private"]); + } + tsHasSomeModifiers(member, modifiers) { + return modifiers.some(modifier => { + if (tsIsAccessModifier(modifier)) { + return member.accessibility === modifier; + } + return !!member[modifier]; + }); + } + tsIsStartOfStaticBlocks() { + return this.isContextual(106) && this.lookaheadCharCode() === 123; + } + parseClassMember(classBody, member, state) { + const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"]; + this.tsParseModifiers({ + allowedModifiers: modifiers, + disallowedModifiers: ["in", "out"], + stopOnStartOfClassStaticBlock: true, + errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions + }, member); + const callParseClassMemberWithIsStatic = () => { + if (this.tsIsStartOfStaticBlocks()) { + this.next(); + this.next(); + if (this.tsHasSomeModifiers(member, modifiers)) { + this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition()); + } + super.parseClassStaticBlock(classBody, member); + } else { + this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static); + } + }; + if (member.declare) { + this.tsInAmbientContext(callParseClassMemberWithIsStatic); + } else { + callParseClassMemberWithIsStatic(); + } + } + parseClassMemberWithIsStatic(classBody, member, state, isStatic) { + const idx = this.tsTryParseIndexSignature(member); + if (idx) { + classBody.body.push(idx); + if (member.abstract) { + this.raise(TSErrors.IndexSignatureHasAbstract, member); + } + if (member.accessibility) { + this.raise(TSErrors.IndexSignatureHasAccessibility, member, { + modifier: member.accessibility + }); + } + if (member.declare) { + this.raise(TSErrors.IndexSignatureHasDeclare, member); + } + if (member.override) { + this.raise(TSErrors.IndexSignatureHasOverride, member); + } + return; + } + if (!this.state.inAbstractClass && member.abstract) { + this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member); + } + if (member.override) { + if (!state.hadSuperClass) { + this.raise(TSErrors.OverrideNotInSubClass, member); + } + } + super.parseClassMemberWithIsStatic(classBody, member, state, isStatic); + } + parsePostMemberNameModifiers(methodOrProp) { + const optional = this.eat(17); + if (optional) methodOrProp.optional = true; + if (methodOrProp.readonly && this.match(10)) { + this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp); + } + if (methodOrProp.declare && this.match(10)) { + this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp); + } + } + shouldParseExportDeclaration() { + if (this.tsIsDeclarationStart()) return true; + return super.shouldParseExportDeclaration(); + } + parseConditional(expr, startLoc, refExpressionErrors) { + if (!this.match(17)) return expr; + if (this.state.maybeInArrowParameters) { + const nextCh = this.lookaheadCharCode(); + if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) { + this.setOptionalParametersError(refExpressionErrors); + return expr; + } + } + return super.parseConditional(expr, startLoc, refExpressionErrors); + } + parseParenItem(node, startLoc) { + const newNode = super.parseParenItem(node, startLoc); + if (this.eat(17)) { + newNode.optional = true; + this.resetEndLocation(node); + } + if (this.match(14)) { + const typeCastNode = this.startNodeAt(startLoc); + typeCastNode.expression = node; + typeCastNode.typeAnnotation = this.tsParseTypeAnnotation(); + return this.finishNode(typeCastNode, "TSTypeCastExpression"); + } + return node; + } + parseExportDeclaration(node) { + if (!this.state.isAmbientContext && this.isContextual(125)) { + return this.tsInAmbientContext(() => this.parseExportDeclaration(node)); + } + const startLoc = this.state.startLoc; + const isDeclare = this.eatContextual(125); + if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) { + throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc); + } + const isIdentifier = tokenIsIdentifier(this.state.type); + const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node); + if (!declaration) return null; + if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) { + node.exportKind = "type"; + } + if (isDeclare && declaration.type !== "TSImportEqualsDeclaration") { + this.resetStartLocation(declaration, startLoc); + declaration.declare = true; + } + return declaration; + } + parseClassId(node, isStatement, optionalId, bindingType) { + if ((!isStatement || optionalId) && this.isContextual(113)) { + return; + } + super.parseClassId(node, isStatement, optionalId, node.declare ? 1024 : 8331); + const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers); + if (typeParameters) node.typeParameters = typeParameters; + } + parseClassPropertyAnnotation(node) { + if (!node.optional) { + if (this.eat(35)) { + node.definite = true; + } else if (this.eat(17)) { + node.optional = true; + } + } + const type = this.tsTryParseTypeAnnotation(); + if (type) node.typeAnnotation = type; + } + parseClassProperty(node) { + this.parseClassPropertyAnnotation(node); + if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) { + this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc); + } + if (node.abstract && this.match(29)) { + const { + key + } = node; + this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, { + propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` + }); + } + return super.parseClassProperty(node); + } + parseClassPrivateProperty(node) { + if (node.abstract) { + this.raise(TSErrors.PrivateElementHasAbstract, node); + } + if (node.accessibility) { + this.raise(TSErrors.PrivateElementHasAccessibility, node, { + modifier: node.accessibility + }); + } + this.parseClassPropertyAnnotation(node); + return super.parseClassPrivateProperty(node); + } + parseClassAccessorProperty(node) { + this.parseClassPropertyAnnotation(node); + if (node.optional) { + this.raise(TSErrors.AccessorCannotBeOptional, node); + } + return super.parseClassAccessorProperty(node); + } + pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { + const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier); + if (typeParameters && isConstructor) { + this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters); + } + const { + declare = false, + kind + } = method; + if (declare && (kind === "get" || kind === "set")) { + this.raise(TSErrors.DeclareAccessor, method, { + kind + }); + } + if (typeParameters) method.typeParameters = typeParameters; + super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); + } + pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { + const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier); + if (typeParameters) method.typeParameters = typeParameters; + super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); + } + declareClassPrivateMethodInScope(node, kind) { + if (node.type === "TSDeclareMethod") return; + if (node.type === "MethodDefinition" && node.value.body == null) { + return; + } + super.declareClassPrivateMethodInScope(node, kind); + } + parseClassSuper(node) { + super.parseClassSuper(node); + if (node.superClass) { + if (node.superClass.type === "TSInstantiationExpression") { + const tsInstantiationExpression = node.superClass; + const superClass = tsInstantiationExpression.expression; + this.takeSurroundingComments(superClass, superClass.start, superClass.end); + const superTypeArguments = tsInstantiationExpression.typeParameters; + this.takeSurroundingComments(superTypeArguments, superTypeArguments.start, superTypeArguments.end); + node.superClass = superClass; + node.superTypeParameters = superTypeArguments; + } else if (this.match(47) || this.match(51)) { + node.superTypeParameters = this.tsParseTypeArgumentsInExpression(); + } + } + if (this.eatContextual(113)) { + node.implements = this.tsParseHeritageClause("implements"); + } + } + parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { + const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier); + if (typeParameters) prop.typeParameters = typeParameters; + return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors); + } + parseFunctionParams(node, isConstructor) { + const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier); + if (typeParameters) node.typeParameters = typeParameters; + super.parseFunctionParams(node, isConstructor); + } + parseVarId(decl, kind) { + super.parseVarId(decl, kind); + if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) { + decl.definite = true; + } + const type = this.tsTryParseTypeAnnotation(); + if (type) { + decl.id.typeAnnotation = type; + this.resetEndLocation(decl.id); + } + } + parseAsyncArrowFromCallExpression(node, call) { + if (this.match(14)) { + node.returnType = this.tsParseTypeAnnotation(); + } + return super.parseAsyncArrowFromCallExpression(node, call); + } + parseMaybeAssign(refExpressionErrors, afterLeftParse) { + var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2; + let state; + let jsx; + let typeCast; + if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) { + state = this.state.clone(); + jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); + if (!jsx.error) return jsx.node; + const { + context + } = this.state; + const currentContext = context[context.length - 1]; + if (currentContext === types.j_oTag || currentContext === types.j_expr) { + context.pop(); + } + } + if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) { + return super.parseMaybeAssign(refExpressionErrors, afterLeftParse); + } + if (!state || state === this.state) state = this.state.clone(); + let typeParameters; + const arrow = this.tryParse(abort => { + var _expr$extra, _typeParameters; + typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier); + const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse); + if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) { + abort(); + } + if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) { + this.resetStartLocationFromNode(expr, typeParameters); + } + expr.typeParameters = typeParameters; + return expr; + }, state); + if (!arrow.error && !arrow.aborted) { + if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); + return arrow.node; + } + if (!jsx) { + assert(!this.hasPlugin("jsx")); + typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); + if (!typeCast.error) return typeCast.node; + } + if ((_jsx2 = jsx) != null && _jsx2.node) { + this.state = jsx.failState; + return jsx.node; + } + if (arrow.node) { + this.state = arrow.failState; + if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); + return arrow.node; + } + if ((_typeCast = typeCast) != null && _typeCast.node) { + this.state = typeCast.failState; + return typeCast.node; + } + throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error); + } + reportReservedArrowTypeParam(node) { + var _node$extra2; + if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra2 = node.extra) != null && _node$extra2.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { + this.raise(TSErrors.ReservedArrowTypeParam, node); + } + } + parseMaybeUnary(refExpressionErrors, sawUnary) { + if (!this.hasPlugin("jsx") && this.match(47)) { + return this.tsParseTypeAssertion(); + } + return super.parseMaybeUnary(refExpressionErrors, sawUnary); + } + parseArrow(node) { + if (this.match(14)) { + const result = this.tryParse(abort => { + const returnType = this.tsParseTypeOrTypePredicateAnnotation(14); + if (this.canInsertSemicolon() || !this.match(19)) abort(); + return returnType; + }); + if (result.aborted) return; + if (!result.thrown) { + if (result.error) this.state = result.failState; + node.returnType = result.node; + } + } + return super.parseArrow(node); + } + parseFunctionParamType(param) { + if (this.eat(17)) { + param.optional = true; + } + const type = this.tsTryParseTypeAnnotation(); + if (type) param.typeAnnotation = type; + this.resetEndLocation(param); + return param; + } + isAssignable(node, isBinding) { + switch (node.type) { + case "TSTypeCastExpression": + return this.isAssignable(node.expression, isBinding); + case "TSParameterProperty": + return true; + default: + return super.isAssignable(node, isBinding); + } + } + toAssignable(node, isLHS = false) { + switch (node.type) { + case "ParenthesizedExpression": + this.toAssignableParenthesizedExpression(node, isLHS); + break; + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSNonNullExpression": + case "TSTypeAssertion": + if (isLHS) { + this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node); + } else { + this.raise(TSErrors.UnexpectedTypeCastInParameter, node); + } + this.toAssignable(node.expression, isLHS); + break; + case "AssignmentExpression": + if (!isLHS && node.left.type === "TSTypeCastExpression") { + node.left = this.typeCastToParameter(node.left); + } + default: + super.toAssignable(node, isLHS); + } + } + toAssignableParenthesizedExpression(node, isLHS) { + switch (node.expression.type) { + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSNonNullExpression": + case "TSTypeAssertion": + case "ParenthesizedExpression": + this.toAssignable(node.expression, isLHS); + break; + default: + super.toAssignable(node, isLHS); + } + } + checkToRestConversion(node, allowPattern) { + switch (node.type) { + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + this.checkToRestConversion(node.expression, false); + break; + default: + super.checkToRestConversion(node, allowPattern); + } + } + isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) { + switch (type) { + case "TSTypeCastExpression": + return true; + case "TSParameterProperty": + return "parameter"; + case "TSNonNullExpression": + return "expression"; + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + return (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true]; + default: + return super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding); + } + } + parseBindingAtom() { + if (this.state.type === 78) { + return this.parseIdentifier(true); + } + return super.parseBindingAtom(); + } + parseMaybeDecoratorArguments(expr, startLoc) { + if (this.match(47) || this.match(51)) { + const typeArguments = this.tsParseTypeArgumentsInExpression(); + if (this.match(10)) { + const call = super.parseMaybeDecoratorArguments(expr, startLoc); + call.typeParameters = typeArguments; + return call; + } + this.unexpected(null, 10); + } + return super.parseMaybeDecoratorArguments(expr, startLoc); + } + checkCommaAfterRest(close) { + if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) { + this.next(); + return false; + } + return super.checkCommaAfterRest(close); + } + isClassMethod() { + return this.match(47) || super.isClassMethod(); + } + isClassProperty() { + return this.match(35) || this.match(14) || super.isClassProperty(); + } + parseMaybeDefault(startLoc, left) { + const node = super.parseMaybeDefault(startLoc, left); + if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { + this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation); + } + return node; + } + getTokenFromCode(code) { + if (this.state.inType) { + if (code === 62) { + this.finishOp(48, 1); + return; + } + if (code === 60) { + this.finishOp(47, 1); + return; + } + } + super.getTokenFromCode(code); + } + reScan_lt_gt() { + const { + type + } = this.state; + if (type === 47) { + this.state.pos -= 1; + this.readToken_lt(); + } else if (type === 48) { + this.state.pos -= 1; + this.readToken_gt(); + } + } + reScan_lt() { + const { + type + } = this.state; + if (type === 51) { + this.state.pos -= 2; + this.finishOp(47, 1); + return 47; + } + return type; + } + toAssignableListItem(exprList, index, isLHS) { + const node = exprList[index]; + if (node.type === "TSTypeCastExpression") { + exprList[index] = this.typeCastToParameter(node); + } + super.toAssignableListItem(exprList, index, isLHS); + } + typeCastToParameter(node) { + node.expression.typeAnnotation = node.typeAnnotation; + this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); + return node.expression; + } + shouldParseArrow(params) { + if (this.match(14)) { + return params.every(expr => this.isAssignable(expr, true)); + } + return super.shouldParseArrow(params); + } + shouldParseAsyncArrow() { + return this.match(14) || super.shouldParseAsyncArrow(); + } + canHaveLeadingDecorator() { + return super.canHaveLeadingDecorator() || this.isAbstractClass(); + } + jsxParseOpeningElementAfterName(node) { + if (this.match(47) || this.match(51)) { + const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression()); + if (typeArguments) { + node.typeParameters = typeArguments; + } + } + return super.jsxParseOpeningElementAfterName(node); + } + getGetterSetterExpectedParamCount(method) { + const baseCount = super.getGetterSetterExpectedParamCount(method); + const params = this.getObjectOrClassMethodParams(method); + const firstParam = params[0]; + const hasContextParam = firstParam && this.isThisParam(firstParam); + return hasContextParam ? baseCount + 1 : baseCount; + } + parseCatchClauseParam() { + const param = super.parseCatchClauseParam(); + const type = this.tsTryParseTypeAnnotation(); + if (type) { + param.typeAnnotation = type; + this.resetEndLocation(param); + } + return param; + } + tsInAmbientContext(cb) { + const { + isAmbientContext: oldIsAmbientContext, + strict: oldStrict + } = this.state; + this.state.isAmbientContext = true; + this.state.strict = false; + try { + return cb(); + } finally { + this.state.isAmbientContext = oldIsAmbientContext; + this.state.strict = oldStrict; + } + } + parseClass(node, isStatement, optionalId) { + const oldInAbstractClass = this.state.inAbstractClass; + this.state.inAbstractClass = !!node.abstract; + try { + return super.parseClass(node, isStatement, optionalId); + } finally { + this.state.inAbstractClass = oldInAbstractClass; + } + } + tsParseAbstractDeclaration(node, decorators) { + if (this.match(80)) { + node.abstract = true; + return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false)); + } else if (this.isContextual(129)) { + if (!this.hasFollowingLineBreak()) { + node.abstract = true; + this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node); + return this.tsParseInterfaceDeclaration(node); + } else { + return null; + } + } + throw this.unexpected(null, 80); + } + parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) { + const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope); + if (method.abstract || method.type === "TSAbstractMethodDefinition") { + const hasEstreePlugin = this.hasPlugin("estree"); + const methodFn = hasEstreePlugin ? method.value : method; + if (methodFn.body) { + const { + key + } = method; + this.raise(TSErrors.AbstractMethodHasImplementation, method, { + methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` + }); + } + } + return method; + } + tsParseTypeParameterName() { + const typeName = this.parseIdentifier(); + return typeName.name; + } + shouldParseAsAmbientContext() { + return !!this.getPluginOption("typescript", "dts"); + } + parse() { + if (this.shouldParseAsAmbientContext()) { + this.state.isAmbientContext = true; + } + return super.parse(); + } + getExpression() { + if (this.shouldParseAsAmbientContext()) { + this.state.isAmbientContext = true; + } + return super.getExpression(); + } + parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { + if (!isString && isMaybeTypeOnly) { + this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport); + return this.finishNode(node, "ExportSpecifier"); + } + node.exportKind = "value"; + return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly); + } + parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { + if (!importedIsString && isMaybeTypeOnly) { + this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport); + return this.finishNode(specifier, "ImportSpecifier"); + } + specifier.importKind = "value"; + return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096); + } + parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) { + const leftOfAsKey = isImport ? "imported" : "local"; + const rightOfAsKey = isImport ? "local" : "exported"; + let leftOfAs = node[leftOfAsKey]; + let rightOfAs; + let hasTypeSpecifier = false; + let canParseAsKeyword = true; + const loc = leftOfAs.loc.start; + if (this.isContextual(93)) { + const firstAs = this.parseIdentifier(); + if (this.isContextual(93)) { + const secondAs = this.parseIdentifier(); + if (tokenIsKeywordOrIdentifier(this.state.type)) { + hasTypeSpecifier = true; + leftOfAs = firstAs; + rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); + canParseAsKeyword = false; + } else { + rightOfAs = secondAs; + canParseAsKeyword = false; + } + } else if (tokenIsKeywordOrIdentifier(this.state.type)) { + canParseAsKeyword = false; + rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); + } else { + hasTypeSpecifier = true; + leftOfAs = firstAs; + } + } else if (tokenIsKeywordOrIdentifier(this.state.type)) { + hasTypeSpecifier = true; + if (isImport) { + leftOfAs = this.parseIdentifier(true); + if (!this.isContextual(93)) { + this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true); + } + } else { + leftOfAs = this.parseModuleExportName(); + } + } + if (hasTypeSpecifier && isInTypeOnlyImportExport) { + this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc); + } + node[leftOfAsKey] = leftOfAs; + node[rightOfAsKey] = rightOfAs; + const kindKey = isImport ? "importKind" : "exportKind"; + node[kindKey] = hasTypeSpecifier ? "type" : "value"; + if (canParseAsKeyword && this.eatContextual(93)) { + node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName(); + } + if (!node[rightOfAsKey]) { + node[rightOfAsKey] = this.cloneIdentifier(node[leftOfAsKey]); + } + if (isImport) { + this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096); + } + } + fillOptionalPropertiesForTSESLint(node) { + var _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out; + switch (node.type) { + case "ExpressionStatement": + (_node$directive = node.directive) != null ? _node$directive : node.directive = undefined; + return; + case "RestElement": + node.value = undefined; + case "Identifier": + case "ArrayPattern": + case "AssignmentPattern": + case "ObjectPattern": + (_node$decorators = node.decorators) != null ? _node$decorators : node.decorators = []; + (_node$optional = node.optional) != null ? _node$optional : node.optional = false; + (_node$typeAnnotation = node.typeAnnotation) != null ? _node$typeAnnotation : node.typeAnnotation = undefined; + return; + case "TSParameterProperty": + (_node$accessibility = node.accessibility) != null ? _node$accessibility : node.accessibility = undefined; + (_node$decorators2 = node.decorators) != null ? _node$decorators2 : node.decorators = []; + (_node$override = node.override) != null ? _node$override : node.override = false; + (_node$readonly = node.readonly) != null ? _node$readonly : node.readonly = false; + (_node$static = node.static) != null ? _node$static : node.static = false; + return; + case "TSEmptyBodyFunctionExpression": + node.body = null; + case "TSDeclareFunction": + case "FunctionDeclaration": + case "FunctionExpression": + case "ClassMethod": + case "ClassPrivateMethod": + (_node$declare = node.declare) != null ? _node$declare : node.declare = false; + (_node$returnType = node.returnType) != null ? _node$returnType : node.returnType = undefined; + (_node$typeParameters = node.typeParameters) != null ? _node$typeParameters : node.typeParameters = undefined; + return; + case "Property": + (_node$optional2 = node.optional) != null ? _node$optional2 : node.optional = false; + return; + case "TSMethodSignature": + case "TSPropertySignature": + (_node$optional3 = node.optional) != null ? _node$optional3 : node.optional = false; + case "TSIndexSignature": + (_node$accessibility2 = node.accessibility) != null ? _node$accessibility2 : node.accessibility = undefined; + (_node$readonly2 = node.readonly) != null ? _node$readonly2 : node.readonly = false; + (_node$static2 = node.static) != null ? _node$static2 : node.static = false; + return; + case "TSAbstractPropertyDefinition": + case "PropertyDefinition": + case "TSAbstractAccessorProperty": + case "AccessorProperty": + (_node$declare2 = node.declare) != null ? _node$declare2 : node.declare = false; + (_node$definite = node.definite) != null ? _node$definite : node.definite = false; + (_node$readonly3 = node.readonly) != null ? _node$readonly3 : node.readonly = false; + (_node$typeAnnotation2 = node.typeAnnotation) != null ? _node$typeAnnotation2 : node.typeAnnotation = undefined; + case "TSAbstractMethodDefinition": + case "MethodDefinition": + (_node$accessibility3 = node.accessibility) != null ? _node$accessibility3 : node.accessibility = undefined; + (_node$decorators3 = node.decorators) != null ? _node$decorators3 : node.decorators = []; + (_node$override2 = node.override) != null ? _node$override2 : node.override = false; + (_node$optional4 = node.optional) != null ? _node$optional4 : node.optional = false; + return; + case "ClassExpression": + (_node$id = node.id) != null ? _node$id : node.id = null; + case "ClassDeclaration": + (_node$abstract = node.abstract) != null ? _node$abstract : node.abstract = false; + (_node$declare3 = node.declare) != null ? _node$declare3 : node.declare = false; + (_node$decorators4 = node.decorators) != null ? _node$decorators4 : node.decorators = []; + (_node$implements = node.implements) != null ? _node$implements : node.implements = []; + (_node$superTypeArgume = node.superTypeArguments) != null ? _node$superTypeArgume : node.superTypeArguments = undefined; + (_node$typeParameters2 = node.typeParameters) != null ? _node$typeParameters2 : node.typeParameters = undefined; + return; + case "TSTypeAliasDeclaration": + case "VariableDeclaration": + (_node$declare4 = node.declare) != null ? _node$declare4 : node.declare = false; + return; + case "VariableDeclarator": + (_node$definite2 = node.definite) != null ? _node$definite2 : node.definite = false; + return; + case "TSEnumDeclaration": + (_node$const = node.const) != null ? _node$const : node.const = false; + (_node$declare5 = node.declare) != null ? _node$declare5 : node.declare = false; + return; + case "TSEnumMember": + (_node$computed = node.computed) != null ? _node$computed : node.computed = false; + return; + case "TSImportType": + (_node$qualifier = node.qualifier) != null ? _node$qualifier : node.qualifier = null; + (_node$options = node.options) != null ? _node$options : node.options = null; + return; + case "TSInterfaceDeclaration": + (_node$declare6 = node.declare) != null ? _node$declare6 : node.declare = false; + (_node$extends = node.extends) != null ? _node$extends : node.extends = []; + return; + case "TSMappedType": + (_node$optional5 = node.optional) != null ? _node$optional5 : node.optional = false; + (_node$readonly4 = node.readonly) != null ? _node$readonly4 : node.readonly = undefined; + return; + case "TSModuleDeclaration": + (_node$declare7 = node.declare) != null ? _node$declare7 : node.declare = false; + (_node$global = node.global) != null ? _node$global : node.global = node.kind === "global"; + return; + case "TSTypeParameter": + (_node$const2 = node.const) != null ? _node$const2 : node.const = false; + (_node$in = node.in) != null ? _node$in : node.in = false; + (_node$out = node.out) != null ? _node$out : node.out = false; + return; + } + } + chStartsBindingIdentifierAndNotRelationalOperator(ch, pos) { + if (isIdentifierStart(ch)) { + keywordAndTSRelationalOperator.lastIndex = pos; + if (keywordAndTSRelationalOperator.test(this.input)) { + const endCh = this.codePointAtPos(keywordAndTSRelationalOperator.lastIndex); + if (!isIdentifierChar(endCh) && endCh !== 92) { + return false; + } + } + return true; + } else if (ch === 92) { + return true; + } else { + return false; + } + } + nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine() { + const next = this.nextTokenInLineStart(); + const nextCh = this.codePointAtPos(next); + return this.chStartsBindingIdentifierAndNotRelationalOperator(nextCh, next); + } + nextTokenIsIdentifierOrStringLiteralOnSameLine() { + const next = this.nextTokenInLineStart(); + const nextCh = this.codePointAtPos(next); + return this.chStartsBindingIdentifier(nextCh, next) || nextCh === 34 || nextCh === 39; + } +}; +function isPossiblyLiteralEnum(expression) { + if (expression.type !== "MemberExpression") return false; + const { + computed, + property + } = expression; + if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) { + return false; + } + return isUncomputedMemberExpressionChain(expression.object); +} +function isValidAmbientConstInitializer(expression, estree) { + var _expression$extra; + const { + type + } = expression; + if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) { + return false; + } + if (estree) { + if (type === "Literal") { + const { + value + } = expression; + if (typeof value === "string" || typeof value === "boolean") { + return true; + } + } + } else { + if (type === "StringLiteral" || type === "BooleanLiteral") { + return true; + } + } + if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) { + return true; + } + if (type === "TemplateLiteral" && expression.expressions.length === 0) { + return true; + } + if (isPossiblyLiteralEnum(expression)) { + return true; + } + return false; +} +function isNumber(expression, estree) { + if (estree) { + return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression); + } + return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral"; +} +function isNegativeNumber(expression, estree) { + if (expression.type === "UnaryExpression") { + const { + operator, + argument + } = expression; + if (operator === "-" && isNumber(argument, estree)) { + return true; + } + } + return false; +} +function isUncomputedMemberExpressionChain(expression) { + if (expression.type === "Identifier") return true; + if (expression.type !== "MemberExpression" || expression.computed) { + return false; + } + return isUncomputedMemberExpressionChain(expression.object); +} +const PlaceholderErrors = ParseErrorEnum`placeholders`({ + ClassNameIsRequired: "A class name is required.", + UnexpectedSpace: "Unexpected space in placeholder." +}); +var placeholders = superClass => class PlaceholdersParserMixin extends superClass { + parsePlaceholder(expectedNode) { + if (this.match(133)) { + const node = this.startNode(); + this.next(); + this.assertNoSpace(); + node.name = super.parseIdentifier(true); + this.assertNoSpace(); + this.expect(133); + return this.finishPlaceholder(node, expectedNode); + } + } + finishPlaceholder(node, expectedNode) { + let placeholder = node; + if (!placeholder.expectedNode || !placeholder.type) { + placeholder = this.finishNode(placeholder, "Placeholder"); + } + placeholder.expectedNode = expectedNode; + return placeholder; + } + getTokenFromCode(code) { + if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) { + this.finishOp(133, 2); + } else { + super.getTokenFromCode(code); + } + } + parseExprAtom(refExpressionErrors) { + return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors); + } + parseIdentifier(liberal) { + return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal); + } + checkReservedWord(word, startLoc, checkKeywords, isBinding) { + if (word !== undefined) { + super.checkReservedWord(word, startLoc, checkKeywords, isBinding); + } + } + cloneIdentifier(node) { + const cloned = super.cloneIdentifier(node); + if (cloned.type === "Placeholder") { + cloned.expectedNode = node.expectedNode; + } + return cloned; + } + cloneStringLiteral(node) { + if (node.type === "Placeholder") { + return this.cloneIdentifier(node); + } + return super.cloneStringLiteral(node); + } + parseBindingAtom() { + return this.parsePlaceholder("Pattern") || super.parseBindingAtom(); + } + isValidLVal(type, disallowCallExpression, isParenthesized, binding) { + return type === "Placeholder" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding); + } + toAssignable(node, isLHS) { + if (node && node.type === "Placeholder" && node.expectedNode === "Expression") { + node.expectedNode = "Pattern"; + } else { + super.toAssignable(node, isLHS); + } + } + chStartsBindingIdentifier(ch, pos) { + if (super.chStartsBindingIdentifier(ch, pos)) { + return true; + } + const next = this.nextTokenStart(); + if (this.input.charCodeAt(next) === 37 && this.input.charCodeAt(next + 1) === 37) { + return true; + } + return false; + } + verifyBreakContinue(node, isBreak) { + var _node$label; + if (((_node$label = node.label) == null ? void 0 : _node$label.type) === "Placeholder") return; + super.verifyBreakContinue(node, isBreak); + } + parseExpressionStatement(node, expr) { + var _expr$extra; + if (expr.type !== "Placeholder" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) { + return super.parseExpressionStatement(node, expr); + } + if (this.match(14)) { + const stmt = node; + stmt.label = this.finishPlaceholder(expr, "Identifier"); + this.next(); + stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration(); + return this.finishNode(stmt, "LabeledStatement"); + } + this.semicolon(); + const stmtPlaceholder = node; + stmtPlaceholder.name = expr.name; + return this.finishPlaceholder(stmtPlaceholder, "Statement"); + } + parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) { + return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse); + } + parseFunctionId(requireId) { + return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId); + } + parseClass(node, isStatement, optionalId) { + const type = isStatement ? "ClassDeclaration" : "ClassExpression"; + this.next(); + const oldStrict = this.state.strict; + const placeholder = this.parsePlaceholder("Identifier"); + if (placeholder) { + if (this.match(81) || this.match(133) || this.match(5)) { + node.id = placeholder; + } else if (optionalId || !isStatement) { + node.id = null; + node.body = this.finishPlaceholder(placeholder, "ClassBody"); + return this.finishNode(node, type); + } else { + throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc); + } + } else { + this.parseClassId(node, isStatement, optionalId); + } + super.parseClassSuper(node); + node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict); + return this.finishNode(node, type); + } + parseExport(node, decorators) { + const placeholder = this.parsePlaceholder("Identifier"); + if (!placeholder) return super.parseExport(node, decorators); + const node2 = node; + if (!this.isContextual(98) && !this.match(12)) { + node2.specifiers = []; + node2.source = null; + node2.declaration = this.finishPlaceholder(placeholder, "Declaration"); + return this.finishNode(node2, "ExportNamedDeclaration"); + } + this.expectPlugin("exportDefaultFrom"); + const specifier = this.startNode(); + specifier.exported = placeholder; + node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; + return super.parseExport(node2, decorators); + } + isExportDefaultSpecifier() { + if (this.match(65)) { + const next = this.nextTokenStart(); + if (this.isUnparsedContextual(next, "from")) { + if (this.input.startsWith(tokenLabelName(133), this.nextTokenStartSince(next + 4))) { + return true; + } + } + } + return super.isExportDefaultSpecifier(); + } + maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) { + var _specifiers; + if ((_specifiers = node.specifiers) != null && _specifiers.length) { + return true; + } + return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier); + } + checkExport(node) { + const { + specifiers + } = node; + if (specifiers != null && specifiers.length) { + node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder"); + } + super.checkExport(node); + node.specifiers = specifiers; + } + parseImport(node) { + const placeholder = this.parsePlaceholder("Identifier"); + if (!placeholder) return super.parseImport(node); + node.specifiers = []; + if (!this.isContextual(98) && !this.match(12)) { + node.source = this.finishPlaceholder(placeholder, "StringLiteral"); + this.semicolon(); + return this.finishNode(node, "ImportDeclaration"); + } + const specifier = this.startNodeAtNode(placeholder); + specifier.local = placeholder; + node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier")); + if (this.eat(12)) { + const hasStarImport = this.maybeParseStarImportSpecifier(node); + if (!hasStarImport) this.parseNamedImportSpecifiers(node); + } + this.expectContextual(98); + node.source = this.parseImportSource(); + this.semicolon(); + return this.finishNode(node, "ImportDeclaration"); + } + parseImportSource() { + return this.parsePlaceholder("StringLiteral") || super.parseImportSource(); + } + assertNoSpace() { + if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) { + this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc); + } + } +}; +var v8intrinsic = superClass => class V8IntrinsicMixin extends superClass { + parseV8Intrinsic() { + if (this.match(54)) { + const v8IntrinsicStartLoc = this.state.startLoc; + const node = this.startNode(); + this.next(); + if (tokenIsIdentifier(this.state.type)) { + const name = this.parseIdentifierName(); + const identifier = this.createIdentifier(node, name); + this.castNodeTo(identifier, "V8IntrinsicIdentifier"); + if (this.match(10)) { + return identifier; + } + } + this.unexpected(v8IntrinsicStartLoc); + } + } + parseExprAtom(refExpressionErrors) { + return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors); + } +}; +const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"]; +const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"]; +function validatePlugins(pluginsMap) { + if (pluginsMap.has("decorators")) { + if (pluginsMap.has("decorators-legacy")) { + throw new Error("Cannot use the decorators and decorators-legacy plugin together"); + } + const decoratorsBeforeExport = pluginsMap.get("decorators").decoratorsBeforeExport; + if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") { + throw new Error("'decoratorsBeforeExport' must be a boolean, if specified."); + } + const allowCallParenthesized = pluginsMap.get("decorators").allowCallParenthesized; + if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") { + throw new Error("'allowCallParenthesized' must be a boolean."); + } + } + if (pluginsMap.has("flow") && pluginsMap.has("typescript")) { + throw new Error("Cannot combine flow and typescript plugins."); + } + if (pluginsMap.has("placeholders") && pluginsMap.has("v8intrinsic")) { + throw new Error("Cannot combine placeholders and v8intrinsic plugins."); + } + if (pluginsMap.has("pipelineOperator")) { + var _pluginsMap$get2; + const proposal = pluginsMap.get("pipelineOperator").proposal; + if (!PIPELINE_PROPOSALS.includes(proposal)) { + const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", "); + throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`); + } + if (proposal === "hack") { + var _pluginsMap$get; + if (pluginsMap.has("placeholders")) { + throw new Error("Cannot combine placeholders plugin and Hack-style pipes."); + } + if (pluginsMap.has("v8intrinsic")) { + throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes."); + } + const topicToken = pluginsMap.get("pipelineOperator").topicToken; + if (!TOPIC_TOKENS.includes(topicToken)) { + const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", "); + throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`); + } + if (topicToken === "#" && ((_pluginsMap$get = pluginsMap.get("recordAndTuple")) == null ? void 0 : _pluginsMap$get.syntaxType) === "hash") { + throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "hack", topicToken: "#" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`); + } + } else if (proposal === "smart" && ((_pluginsMap$get2 = pluginsMap.get("recordAndTuple")) == null ? void 0 : _pluginsMap$get2.syntaxType) === "hash") { + throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "smart" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`); + } + } + if (pluginsMap.has("moduleAttributes")) { + if (pluginsMap.has("deprecatedImportAssert") || pluginsMap.has("importAssertions")) { + throw new Error("Cannot combine importAssertions, deprecatedImportAssert and moduleAttributes plugins."); + } + const moduleAttributesVersionPluginOption = pluginsMap.get("moduleAttributes").version; + if (moduleAttributesVersionPluginOption !== "may-2020") { + throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'."); + } + } + if (pluginsMap.has("importAssertions")) { + if (pluginsMap.has("deprecatedImportAssert")) { + throw new Error("Cannot combine importAssertions and deprecatedImportAssert plugins."); + } + } + if (pluginsMap.has("deprecatedImportAssert")) ;else if (pluginsMap.has("importAttributes") && pluginsMap.get("importAttributes").deprecatedAssertSyntax) { + pluginsMap.set("deprecatedImportAssert", {}); + } + if (pluginsMap.has("recordAndTuple")) { + const syntaxType = pluginsMap.get("recordAndTuple").syntaxType; + if (syntaxType != null) { + const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"]; + if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) { + throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", ")); + } + } + } + if (pluginsMap.has("asyncDoExpressions") && !pluginsMap.has("doExpressions")) { + const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins."); + error.missingPlugins = "doExpressions"; + throw error; + } + if (pluginsMap.has("optionalChainingAssign") && pluginsMap.get("optionalChainingAssign").version !== "2023-07") { + throw new Error("The 'optionalChainingAssign' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is '2023-07'."); + } + if (pluginsMap.has("discardBinding") && pluginsMap.get("discardBinding").syntaxType !== "void") { + throw new Error("The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'."); + } +} +const mixinPlugins = { + estree, + jsx, + flow, + typescript, + v8intrinsic, + placeholders +}; +const mixinPluginNames = Object.keys(mixinPlugins); +class ExpressionParser extends LValParser { + checkProto(prop, isRecord, sawProto, refExpressionErrors) { + if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) { + return sawProto; + } + const key = prop.key; + const name = key.type === "Identifier" ? key.name : key.value; + if (name === "__proto__") { + if (isRecord) { + this.raise(Errors.RecordNoProto, key); + return true; + } + if (sawProto) { + if (refExpressionErrors) { + if (refExpressionErrors.doubleProtoLoc === null) { + refExpressionErrors.doubleProtoLoc = key.loc.start; + } + } else { + this.raise(Errors.DuplicateProto, key); + } + } + return true; + } + return sawProto; + } + shouldExitDescending(expr, potentialArrowAt) { + return expr.type === "ArrowFunctionExpression" && this.offsetToSourcePos(expr.start) === potentialArrowAt; + } + getExpression() { + this.enterInitialScopes(); + this.nextToken(); + if (this.match(140)) { + throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc); + } + const expr = this.parseExpression(); + if (!this.match(140)) { + throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, { + unexpected: this.input.codePointAt(this.state.start) + }); + } + this.finalizeRemainingComments(); + expr.comments = this.comments; + expr.errors = this.state.errors; + if (this.optionFlags & 256) { + expr.tokens = this.tokens; + } + return expr; + } + parseExpression(disallowIn, refExpressionErrors) { + if (disallowIn) { + return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors)); + } + return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors)); + } + parseExpressionBase(refExpressionErrors) { + const startLoc = this.state.startLoc; + const expr = this.parseMaybeAssign(refExpressionErrors); + if (this.match(12)) { + const node = this.startNodeAt(startLoc); + node.expressions = [expr]; + while (this.eat(12)) { + node.expressions.push(this.parseMaybeAssign(refExpressionErrors)); + } + this.toReferencedList(node.expressions); + return this.finishNode(node, "SequenceExpression"); + } + return expr; + } + parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) { + return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); + } + parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) { + return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); + } + setOptionalParametersError(refExpressionErrors) { + refExpressionErrors.optionalParametersLoc = this.state.startLoc; + } + parseMaybeAssign(refExpressionErrors, afterLeftParse) { + const startLoc = this.state.startLoc; + const isYield = this.isContextual(108); + if (isYield) { + if (this.prodParam.hasYield) { + this.next(); + let left = this.parseYield(startLoc); + if (afterLeftParse) { + left = afterLeftParse.call(this, left, startLoc); + } + return left; + } + } + let ownExpressionErrors; + if (refExpressionErrors) { + ownExpressionErrors = false; + } else { + refExpressionErrors = new ExpressionErrors(); + ownExpressionErrors = true; + } + const { + type + } = this.state; + if (type === 10 || tokenIsIdentifier(type)) { + this.state.potentialArrowAt = this.state.start; + } + let left = this.parseMaybeConditional(refExpressionErrors); + if (afterLeftParse) { + left = afterLeftParse.call(this, left, startLoc); + } + if (tokenIsAssignment(this.state.type)) { + const node = this.startNodeAt(startLoc); + const operator = this.state.value; + node.operator = operator; + if (this.match(29)) { + this.toAssignable(left, true); + node.left = left; + const startIndex = startLoc.index; + if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) { + refExpressionErrors.doubleProtoLoc = null; + } + if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) { + refExpressionErrors.shorthandAssignLoc = null; + } + if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) { + this.checkDestructuringPrivate(refExpressionErrors); + refExpressionErrors.privateKeyLoc = null; + } + if (refExpressionErrors.voidPatternLoc != null && refExpressionErrors.voidPatternLoc.index >= startIndex) { + refExpressionErrors.voidPatternLoc = null; + } + } else { + node.left = left; + } + this.next(); + node.right = this.parseMaybeAssign(); + this.checkLVal(left, this.finishNode(node, "AssignmentExpression"), undefined, undefined, undefined, undefined, operator === "||=" || operator === "&&=" || operator === "??="); + return node; + } else if (ownExpressionErrors) { + this.checkExpressionErrors(refExpressionErrors, true); + } + if (isYield) { + const { + type + } = this.state; + const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54); + if (startsExpr && !this.isAmbiguousPrefixOrIdentifier()) { + this.raiseOverwrite(Errors.YieldNotInGeneratorFunction, startLoc); + return this.parseYield(startLoc); + } + } + return left; + } + parseMaybeConditional(refExpressionErrors) { + const startLoc = this.state.startLoc; + const potentialArrowAt = this.state.potentialArrowAt; + const expr = this.parseExprOps(refExpressionErrors); + if (this.shouldExitDescending(expr, potentialArrowAt)) { + return expr; + } + return this.parseConditional(expr, startLoc, refExpressionErrors); + } + parseConditional(expr, startLoc, refExpressionErrors) { + if (this.eat(17)) { + const node = this.startNodeAt(startLoc); + node.test = expr; + node.consequent = this.parseMaybeAssignAllowIn(); + this.expect(14); + node.alternate = this.parseMaybeAssign(); + return this.finishNode(node, "ConditionalExpression"); + } + return expr; + } + parseMaybeUnaryOrPrivate(refExpressionErrors) { + return this.match(139) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors); + } + parseExprOps(refExpressionErrors) { + const startLoc = this.state.startLoc; + const potentialArrowAt = this.state.potentialArrowAt; + const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors); + if (this.shouldExitDescending(expr, potentialArrowAt)) { + return expr; + } + return this.parseExprOp(expr, startLoc, -1); + } + parseExprOp(left, leftStartLoc, minPrec) { + if (this.isPrivateName(left)) { + const value = this.getPrivateNameSV(left); + if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) { + this.raise(Errors.PrivateInExpectedIn, left, { + identifierName: value + }); + } + this.classScope.usePrivateName(value, left.loc.start); + } + const op = this.state.type; + if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) { + let prec = tokenOperatorPrecedence(op); + if (prec > minPrec) { + if (op === 39) { + this.expectPlugin("pipelineOperator"); + if (this.state.inFSharpPipelineDirectBody) { + return left; + } + this.checkPipelineAtInfixOperator(left, leftStartLoc); + } + const node = this.startNodeAt(leftStartLoc); + node.left = left; + node.operator = this.state.value; + const logical = op === 41 || op === 42; + const coalesce = op === 40; + if (coalesce) { + prec = tokenOperatorPrecedence(42); + } + this.next(); + if (op === 39 && this.hasPlugin(["pipelineOperator", { + proposal: "minimal" + }])) { + if (this.state.type === 96 && this.prodParam.hasAwait) { + throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, this.state.startLoc); + } + } + node.right = this.parseExprOpRightExpr(op, prec); + const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression"); + const nextOp = this.state.type; + if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) { + throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc); + } + return this.parseExprOp(finishedNode, leftStartLoc, minPrec); + } + } + return left; + } + parseExprOpRightExpr(op, prec) { + const startLoc = this.state.startLoc; + switch (op) { + case 39: + switch (this.getPluginOption("pipelineOperator", "proposal")) { + case "hack": + return this.withTopicBindingContext(() => { + return this.parseHackPipeBody(); + }); + case "fsharp": + return this.withSoloAwaitPermittingContext(() => { + return this.parseFSharpPipelineBody(prec); + }); + } + if (this.getPluginOption("pipelineOperator", "proposal") === "smart") { + return this.withTopicBindingContext(() => { + if (this.prodParam.hasYield && this.isContextual(108)) { + throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc); + } + return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc); + }); + } + default: + return this.parseExprOpBaseRightExpr(op, prec); + } + } + parseExprOpBaseRightExpr(op, prec) { + const startLoc = this.state.startLoc; + return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec); + } + parseHackPipeBody() { + var _body$extra; + const { + startLoc + } = this.state; + const body = this.parseMaybeAssign(); + const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type); + if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) { + this.raise(Errors.PipeUnparenthesizedBody, startLoc, { + type: body.type + }); + } + if (!this.topicReferenceWasUsedInCurrentContext()) { + this.raise(Errors.PipeTopicUnused, startLoc); + } + return body; + } + checkExponentialAfterUnary(node) { + if (this.match(57)) { + this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument); + } + } + parseMaybeUnary(refExpressionErrors, sawUnary) { + const startLoc = this.state.startLoc; + const isAwait = this.isContextual(96); + if (isAwait && this.recordAwaitIfAllowed()) { + this.next(); + const expr = this.parseAwait(startLoc); + if (!sawUnary) this.checkExponentialAfterUnary(expr); + return expr; + } + const update = this.match(34); + const node = this.startNode(); + if (tokenIsPrefix(this.state.type)) { + node.operator = this.state.value; + node.prefix = true; + if (this.match(72)) { + this.expectPlugin("throwExpressions"); + } + const isDelete = this.match(89); + this.next(); + node.argument = this.parseMaybeUnary(null, true); + this.checkExpressionErrors(refExpressionErrors, true); + if (this.state.strict && isDelete) { + const arg = node.argument; + if (arg.type === "Identifier") { + this.raise(Errors.StrictDelete, node); + } else if (this.hasPropertyAsPrivateName(arg)) { + this.raise(Errors.DeletePrivateField, node); + } + } + if (!update) { + if (!sawUnary) { + this.checkExponentialAfterUnary(node); + } + return this.finishNode(node, "UnaryExpression"); + } + } + const expr = this.parseUpdate(node, update, refExpressionErrors); + if (isAwait) { + const { + type + } = this.state; + const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54); + if (startsExpr && !this.isAmbiguousPrefixOrIdentifier()) { + this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc); + return this.parseAwait(startLoc); + } + } + return expr; + } + parseUpdate(node, update, refExpressionErrors) { + if (update) { + const updateExpressionNode = node; + this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, "UpdateExpression")); + return node; + } + const startLoc = this.state.startLoc; + let expr = this.parseExprSubscripts(refExpressionErrors); + if (this.checkExpressionErrors(refExpressionErrors, false)) return expr; + while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) { + const node = this.startNodeAt(startLoc); + node.operator = this.state.value; + node.prefix = false; + node.argument = expr; + this.next(); + this.checkLVal(expr, expr = this.finishNode(node, "UpdateExpression")); + } + return expr; + } + parseExprSubscripts(refExpressionErrors) { + const startLoc = this.state.startLoc; + const potentialArrowAt = this.state.potentialArrowAt; + const expr = this.parseExprAtom(refExpressionErrors); + if (this.shouldExitDescending(expr, potentialArrowAt)) { + return expr; + } + return this.parseSubscripts(expr, startLoc); + } + parseSubscripts(base, startLoc, noCalls) { + const state = { + optionalChainMember: false, + maybeAsyncArrow: this.atPossibleAsyncArrow(base), + stop: false + }; + do { + base = this.parseSubscript(base, startLoc, noCalls, state); + state.maybeAsyncArrow = false; + } while (!state.stop); + return base; + } + parseSubscript(base, startLoc, noCalls, state) { + const { + type + } = this.state; + if (!noCalls && type === 15) { + return this.parseBind(base, startLoc, noCalls, state); + } else if (tokenIsTemplate(type)) { + return this.parseTaggedTemplateExpression(base, startLoc, state); + } + let optional = false; + if (type === 18) { + if (noCalls) { + this.raise(Errors.OptionalChainingNoNew, this.state.startLoc); + if (this.lookaheadCharCode() === 40) { + return this.stopParseSubscript(base, state); + } + } + state.optionalChainMember = optional = true; + this.next(); + } + if (!noCalls && this.match(10)) { + return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional); + } else { + const computed = this.eat(0); + if (computed || optional || this.eat(16)) { + return this.parseMember(base, startLoc, state, computed, optional); + } else { + return this.stopParseSubscript(base, state); + } + } + } + stopParseSubscript(base, state) { + state.stop = true; + return base; + } + parseMember(base, startLoc, state, computed, optional) { + const node = this.startNodeAt(startLoc); + node.object = base; + node.computed = computed; + if (computed) { + node.property = this.parseExpression(); + this.expect(3); + } else if (this.match(139)) { + if (base.type === "Super") { + this.raise(Errors.SuperPrivateField, startLoc); + } + this.classScope.usePrivateName(this.state.value, this.state.startLoc); + node.property = this.parsePrivateName(); + } else { + node.property = this.parseIdentifier(true); + } + if (state.optionalChainMember) { + node.optional = optional; + return this.finishNode(node, "OptionalMemberExpression"); + } else { + return this.finishNode(node, "MemberExpression"); + } + } + parseBind(base, startLoc, noCalls, state) { + const node = this.startNodeAt(startLoc); + node.object = base; + this.next(); + node.callee = this.parseNoCallExpr(); + state.stop = true; + return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls); + } + parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) { + const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; + let refExpressionErrors = null; + this.state.maybeInArrowParameters = true; + this.next(); + const node = this.startNodeAt(startLoc); + node.callee = base; + const { + maybeAsyncArrow, + optionalChainMember + } = state; + if (maybeAsyncArrow) { + this.expressionScope.enter(newAsyncArrowScope()); + refExpressionErrors = new ExpressionErrors(); + } + if (optionalChainMember) { + node.optional = optional; + } + if (optional) { + node.arguments = this.parseCallExpressionArguments(); + } else { + node.arguments = this.parseCallExpressionArguments(base.type !== "Super", node, refExpressionErrors); + } + let finishedNode = this.finishCallExpression(node, optionalChainMember); + if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) { + state.stop = true; + this.checkDestructuringPrivate(refExpressionErrors); + this.expressionScope.validateAsPattern(); + this.expressionScope.exit(); + finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode); + } else { + if (maybeAsyncArrow) { + this.checkExpressionErrors(refExpressionErrors, true); + this.expressionScope.exit(); + } + this.toReferencedArguments(finishedNode); + } + this.state.maybeInArrowParameters = oldMaybeInArrowParameters; + return finishedNode; + } + toReferencedArguments(node, isParenthesizedExpr) { + this.toReferencedListDeep(node.arguments, isParenthesizedExpr); + } + parseTaggedTemplateExpression(base, startLoc, state) { + const node = this.startNodeAt(startLoc); + node.tag = base; + node.quasi = this.parseTemplate(true); + if (state.optionalChainMember) { + this.raise(Errors.OptionalChainingNoTemplate, startLoc); + } + return this.finishNode(node, "TaggedTemplateExpression"); + } + atPossibleAsyncArrow(base) { + return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && this.offsetToSourcePos(base.start) === this.state.potentialArrowAt; + } + finishCallExpression(node, optional) { + if (node.callee.type === "Import") { + if (node.arguments.length === 0 || node.arguments.length > 2) { + this.raise(Errors.ImportCallArity, node); + } else { + for (const arg of node.arguments) { + if (arg.type === "SpreadElement") { + this.raise(Errors.ImportCallSpreadArgument, arg); + } + } + } + } + return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression"); + } + parseCallExpressionArguments(allowPlaceholder, nodeForExtra, refExpressionErrors) { + const elts = []; + let first = true; + const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; + this.state.inFSharpPipelineDirectBody = false; + while (!this.eat(11)) { + if (first) { + first = false; + } else { + this.expect(12); + if (this.match(11)) { + if (nodeForExtra) { + this.addTrailingCommaExtraToNode(nodeForExtra); + } + this.next(); + break; + } + } + elts.push(this.parseExprListItem(11, false, refExpressionErrors, allowPlaceholder)); + } + this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; + return elts; + } + shouldParseAsyncArrow() { + return this.match(19) && !this.canInsertSemicolon(); + } + parseAsyncArrowFromCallExpression(node, call) { + var _call$extra; + this.resetPreviousNodeTrailingComments(call); + this.expect(19); + this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc); + if (call.innerComments) { + setInnerComments(node, call.innerComments); + } + if (call.callee.trailingComments) { + setInnerComments(node, call.callee.trailingComments); + } + return node; + } + parseNoCallExpr() { + const startLoc = this.state.startLoc; + return this.parseSubscripts(this.parseExprAtom(), startLoc, true); + } + parseExprAtom(refExpressionErrors) { + let node; + let decorators = null; + const { + type + } = this.state; + switch (type) { + case 79: + return this.parseSuper(); + case 83: + node = this.startNode(); + this.next(); + if (this.match(16)) { + return this.parseImportMetaPropertyOrPhaseCall(node); + } + if (this.match(10)) { + if (this.optionFlags & 512) { + return this.parseImportCall(node); + } else { + return this.finishNode(node, "Import"); + } + } else { + this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc); + return this.finishNode(node, "Import"); + } + case 78: + node = this.startNode(); + this.next(); + return this.finishNode(node, "ThisExpression"); + case 90: + { + return this.parseDo(this.startNode(), false); + } + case 56: + case 31: + { + this.readRegexp(); + return this.parseRegExpLiteral(this.state.value); + } + case 135: + return this.parseNumericLiteral(this.state.value); + case 136: + return this.parseBigIntLiteral(this.state.value); + case 134: + return this.parseStringLiteral(this.state.value); + case 84: + return this.parseNullLiteral(); + case 85: + return this.parseBooleanLiteral(true); + case 86: + return this.parseBooleanLiteral(false); + case 10: + { + const canBeArrow = this.state.potentialArrowAt === this.state.start; + return this.parseParenAndDistinguishExpression(canBeArrow); + } + case 0: + { + return this.parseArrayLike(3, false, refExpressionErrors); + } + case 5: + { + return this.parseObjectLike(8, false, false, refExpressionErrors); + } + case 68: + return this.parseFunctionOrFunctionSent(); + case 26: + decorators = this.parseDecorators(); + case 80: + return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false); + case 77: + return this.parseNewOrNewTarget(); + case 25: + case 24: + return this.parseTemplate(false); + case 15: + { + node = this.startNode(); + this.next(); + node.object = null; + const callee = node.callee = this.parseNoCallExpr(); + if (callee.type === "MemberExpression") { + return this.finishNode(node, "BindExpression"); + } else { + throw this.raise(Errors.UnsupportedBind, callee); + } + } + case 139: + { + this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, { + identifierName: this.state.value + }); + return this.parsePrivateName(); + } + case 33: + { + return this.parseTopicReferenceThenEqualsSign(54, "%"); + } + case 32: + { + return this.parseTopicReferenceThenEqualsSign(44, "^"); + } + case 37: + case 38: + { + return this.parseTopicReference("hack"); + } + case 44: + case 54: + case 27: + { + const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); + if (pipeProposal) { + return this.parseTopicReference(pipeProposal); + } + throw this.unexpected(); + } + case 47: + { + const lookaheadCh = this.input.codePointAt(this.nextTokenStart()); + if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) { + throw this.expectOnePlugin(["jsx", "flow", "typescript"]); + } + throw this.unexpected(); + } + default: + if (type === 137) { + return this.parseDecimalLiteral(this.state.value); + } else if (type === 2 || type === 1) { + return this.parseArrayLike(this.state.type === 2 ? 4 : 3, true); + } else if (type === 6 || type === 7) { + return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true); + } + if (tokenIsIdentifier(type)) { + if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) { + return this.parseModuleExpression(); + } + const canBeArrow = this.state.potentialArrowAt === this.state.start; + const containsEsc = this.state.containsEsc; + const id = this.parseIdentifier(); + if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) { + const { + type + } = this.state; + if (type === 68) { + this.resetPreviousNodeTrailingComments(id); + this.next(); + return this.parseAsyncFunctionExpression(this.startNodeAtNode(id)); + } else if (tokenIsIdentifier(type)) { + if (this.lookaheadCharCode() === 61) { + return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id)); + } else { + return id; + } + } else if (type === 90) { + this.resetPreviousNodeTrailingComments(id); + return this.parseDo(this.startNodeAtNode(id), true); + } + } + if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) { + this.next(); + return this.parseArrowExpression(this.startNodeAtNode(id), [id], false); + } + return id; + } else { + throw this.unexpected(); + } + } + } + parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) { + const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); + if (pipeProposal) { + this.state.type = topicTokenType; + this.state.value = topicTokenValue; + this.state.pos--; + this.state.end--; + this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1); + return this.parseTopicReference(pipeProposal); + } + throw this.unexpected(); + } + parseTopicReference(pipeProposal) { + const node = this.startNode(); + const startLoc = this.state.startLoc; + const tokenType = this.state.type; + this.next(); + return this.finishTopicReference(node, startLoc, pipeProposal, tokenType); + } + finishTopicReference(node, startLoc, pipeProposal, tokenType) { + if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) { + if (pipeProposal === "hack") { + if (!this.topicReferenceIsAllowedInCurrentContext()) { + this.raise(Errors.PipeTopicUnbound, startLoc); + } + this.registerTopicReference(); + return this.finishNode(node, "TopicReference"); + } else { + if (!this.topicReferenceIsAllowedInCurrentContext()) { + this.raise(Errors.PrimaryTopicNotAllowed, startLoc); + } + this.registerTopicReference(); + return this.finishNode(node, "PipelinePrimaryTopicReference"); + } + } else { + throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, { + token: tokenLabelName(tokenType) + }); + } + } + testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) { + switch (pipeProposal) { + case "hack": + { + return this.hasPlugin(["pipelineOperator", { + topicToken: tokenLabelName(tokenType) + }]); + } + case "smart": + return tokenType === 27; + default: + throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc); + } + } + parseAsyncArrowUnaryFunction(node) { + this.prodParam.enter(functionFlags(true, this.prodParam.hasYield)); + const params = [this.parseIdentifier()]; + this.prodParam.exit(); + if (this.hasPrecedingLineBreak()) { + this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition()); + } + this.expect(19); + return this.parseArrowExpression(node, params, true); + } + parseDo(node, isAsync) { + this.expectPlugin("doExpressions"); + if (isAsync) { + this.expectPlugin("asyncDoExpressions"); + } + node.async = isAsync; + this.next(); + const oldLabels = this.state.labels; + this.state.labels = []; + if (isAsync) { + this.prodParam.enter(2); + node.body = this.parseBlock(); + this.prodParam.exit(); + } else { + node.body = this.parseBlock(); + } + this.state.labels = oldLabels; + return this.finishNode(node, "DoExpression"); + } + parseSuper() { + const node = this.startNode(); + this.next(); + if (this.match(10) && !this.scope.allowDirectSuper) { + if (!(this.optionFlags & 16)) { + this.raise(Errors.SuperNotAllowed, node); + } + } else if (!this.scope.allowSuper) { + if (!(this.optionFlags & 16)) { + this.raise(Errors.UnexpectedSuper, node); + } + } + if (!this.match(10) && !this.match(0) && !this.match(16)) { + this.raise(Errors.UnsupportedSuper, node); + } + return this.finishNode(node, "Super"); + } + parsePrivateName() { + const node = this.startNode(); + const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1)); + const name = this.state.value; + this.next(); + node.id = this.createIdentifier(id, name); + return this.finishNode(node, "PrivateName"); + } + parseFunctionOrFunctionSent() { + const node = this.startNode(); + this.next(); + if (this.prodParam.hasYield && this.match(16)) { + const meta = this.createIdentifier(this.startNodeAtNode(node), "function"); + this.next(); + if (this.match(103)) { + this.expectPlugin("functionSent"); + } else if (!this.hasPlugin("functionSent")) { + this.unexpected(); + } + return this.parseMetaProperty(node, meta, "sent"); + } + return this.parseFunction(node); + } + parseMetaProperty(node, meta, propertyName) { + node.meta = meta; + const containsEsc = this.state.containsEsc; + node.property = this.parseIdentifier(true); + if (node.property.name !== propertyName || containsEsc) { + this.raise(Errors.UnsupportedMetaProperty, node.property, { + target: meta.name, + onlyValidPropertyName: propertyName + }); + } + return this.finishNode(node, "MetaProperty"); + } + parseImportMetaPropertyOrPhaseCall(node) { + this.next(); + if (this.isContextual(105) || this.isContextual(97)) { + const isSource = this.isContextual(105); + this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation"); + this.next(); + node.phase = isSource ? "source" : "defer"; + return this.parseImportCall(node); + } else { + const id = this.createIdentifierAt(this.startNodeAtNode(node), "import", this.state.lastTokStartLoc); + if (this.isContextual(101)) { + if (!this.inModule) { + this.raise(Errors.ImportMetaOutsideModule, id); + } + this.sawUnambiguousESM = true; + } + return this.parseMetaProperty(node, id, "meta"); + } + } + parseLiteralAtNode(value, type, node) { + this.addExtra(node, "rawValue", value); + this.addExtra(node, "raw", this.input.slice(this.offsetToSourcePos(node.start), this.state.end)); + node.value = value; + this.next(); + return this.finishNode(node, type); + } + parseLiteral(value, type) { + const node = this.startNode(); + return this.parseLiteralAtNode(value, type, node); + } + parseStringLiteral(value) { + return this.parseLiteral(value, "StringLiteral"); + } + parseNumericLiteral(value) { + return this.parseLiteral(value, "NumericLiteral"); + } + parseBigIntLiteral(value) { + return this.parseLiteral(value, "BigIntLiteral"); + } + parseDecimalLiteral(value) { + return this.parseLiteral(value, "DecimalLiteral"); + } + parseRegExpLiteral(value) { + const node = this.startNode(); + this.addExtra(node, "raw", this.input.slice(this.offsetToSourcePos(node.start), this.state.end)); + node.pattern = value.pattern; + node.flags = value.flags; + this.next(); + return this.finishNode(node, "RegExpLiteral"); + } + parseBooleanLiteral(value) { + const node = this.startNode(); + node.value = value; + this.next(); + return this.finishNode(node, "BooleanLiteral"); + } + parseNullLiteral() { + const node = this.startNode(); + this.next(); + return this.finishNode(node, "NullLiteral"); + } + parseParenAndDistinguishExpression(canBeArrow) { + const startLoc = this.state.startLoc; + let val; + this.next(); + this.expressionScope.enter(newArrowHeadScope()); + const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; + const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; + this.state.maybeInArrowParameters = true; + this.state.inFSharpPipelineDirectBody = false; + const innerStartLoc = this.state.startLoc; + const exprList = []; + const refExpressionErrors = new ExpressionErrors(); + let first = true; + let spreadStartLoc; + let optionalCommaStartLoc; + while (!this.match(11)) { + if (first) { + first = false; + } else { + this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc); + if (this.match(11)) { + optionalCommaStartLoc = this.state.startLoc; + break; + } + } + if (this.match(21)) { + const spreadNodeStartLoc = this.state.startLoc; + spreadStartLoc = this.state.startLoc; + exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc)); + if (!this.checkCommaAfterRest(41)) { + break; + } + } else { + exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(11, refExpressionErrors, this.parseParenItem)); + } + } + const innerEndLoc = this.state.lastTokEndLoc; + this.expect(11); + this.state.maybeInArrowParameters = oldMaybeInArrowParameters; + this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; + let arrowNode = this.startNodeAt(startLoc); + if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) { + this.checkDestructuringPrivate(refExpressionErrors); + this.expressionScope.validateAsPattern(); + this.expressionScope.exit(); + this.parseArrowExpression(arrowNode, exprList, false); + return arrowNode; + } + this.expressionScope.exit(); + if (!exprList.length) { + this.unexpected(this.state.lastTokStartLoc); + } + if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc); + if (spreadStartLoc) this.unexpected(spreadStartLoc); + this.checkExpressionErrors(refExpressionErrors, true); + this.toReferencedListDeep(exprList, true); + if (exprList.length > 1) { + val = this.startNodeAt(innerStartLoc); + val.expressions = exprList; + this.finishNode(val, "SequenceExpression"); + this.resetEndLocation(val, innerEndLoc); + } else { + val = exprList[0]; + } + return this.wrapParenthesis(startLoc, val); + } + wrapParenthesis(startLoc, expression) { + if (!(this.optionFlags & 1024)) { + this.addExtra(expression, "parenthesized", true); + this.addExtra(expression, "parenStart", startLoc.index); + this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index); + return expression; + } + const parenExpression = this.startNodeAt(startLoc); + parenExpression.expression = expression; + return this.finishNode(parenExpression, "ParenthesizedExpression"); + } + shouldParseArrow(params) { + return !this.canInsertSemicolon(); + } + parseArrow(node) { + if (this.eat(19)) { + return node; + } + } + parseParenItem(node, startLoc) { + return node; + } + parseNewOrNewTarget() { + const node = this.startNode(); + this.next(); + if (this.match(16)) { + const meta = this.createIdentifier(this.startNodeAtNode(node), "new"); + this.next(); + const metaProp = this.parseMetaProperty(node, meta, "target"); + if (!this.scope.allowNewTarget) { + this.raise(Errors.UnexpectedNewTarget, metaProp); + } + return metaProp; + } + return this.parseNew(node); + } + parseNew(node) { + this.parseNewCallee(node); + if (this.eat(10)) { + const args = this.parseExprList(11); + this.toReferencedList(args); + node.arguments = args; + } else { + node.arguments = []; + } + return this.finishNode(node, "NewExpression"); + } + parseNewCallee(node) { + const isImport = this.match(83); + const callee = this.parseNoCallExpr(); + node.callee = callee; + if (isImport && (callee.type === "Import" || callee.type === "ImportExpression")) { + this.raise(Errors.ImportCallNotNewExpression, callee); + } + } + parseTemplateElement(isTagged) { + const { + start, + startLoc, + end, + value + } = this.state; + const elemStart = start + 1; + const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1)); + if (value === null) { + if (!isTagged) { + this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)); + } + } + const isTail = this.match(24); + const endOffset = isTail ? -1 : -2; + const elemEnd = end + endOffset; + elem.value = { + raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"), + cooked: value === null ? null : value.slice(1, endOffset) + }; + elem.tail = isTail; + this.next(); + const finishedNode = this.finishNode(elem, "TemplateElement"); + this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset)); + return finishedNode; + } + parseTemplate(isTagged) { + const node = this.startNode(); + let curElt = this.parseTemplateElement(isTagged); + const quasis = [curElt]; + const substitutions = []; + while (!curElt.tail) { + substitutions.push(this.parseTemplateSubstitution()); + this.readTemplateContinuation(); + quasis.push(curElt = this.parseTemplateElement(isTagged)); + } + node.expressions = substitutions; + node.quasis = quasis; + return this.finishNode(node, "TemplateLiteral"); + } + parseTemplateSubstitution() { + return this.parseExpression(); + } + parseObjectLike(close, isPattern, isRecord, refExpressionErrors) { + if (isRecord) { + this.expectPlugin("recordAndTuple"); + } + const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; + this.state.inFSharpPipelineDirectBody = false; + let sawProto = false; + let first = true; + const node = this.startNode(); + node.properties = []; + this.next(); + while (!this.match(close)) { + if (first) { + first = false; + } else { + this.expect(12); + if (this.match(close)) { + this.addTrailingCommaExtraToNode(node); + break; + } + } + let prop; + if (isPattern) { + prop = this.parseBindingProperty(); + } else { + prop = this.parsePropertyDefinition(refExpressionErrors); + sawProto = this.checkProto(prop, isRecord, sawProto, refExpressionErrors); + } + if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") { + this.raise(Errors.InvalidRecordProperty, prop); + } + if (prop.shorthand) { + this.addExtra(prop, "shorthand", true); + } + node.properties.push(prop); + } + this.next(); + this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; + let type = "ObjectExpression"; + if (isPattern) { + type = "ObjectPattern"; + } else if (isRecord) { + type = "RecordExpression"; + } + return this.finishNode(node, type); + } + addTrailingCommaExtraToNode(node) { + this.addExtra(node, "trailingComma", this.state.lastTokStartLoc.index); + this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false); + } + maybeAsyncOrAccessorProp(prop) { + return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55)); + } + parsePropertyDefinition(refExpressionErrors) { + let decorators = []; + if (this.match(26)) { + if (this.hasPlugin("decorators")) { + this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc); + } + while (this.match(26)) { + decorators.push(this.parseDecorator()); + } + } + const prop = this.startNode(); + let isAsync = false; + let isAccessor = false; + let startLoc; + if (this.match(21)) { + if (decorators.length) this.unexpected(); + return this.parseSpread(); + } + if (decorators.length) { + prop.decorators = decorators; + decorators = []; + } + prop.method = false; + if (refExpressionErrors) { + startLoc = this.state.startLoc; + } + let isGenerator = this.eat(55); + this.parsePropertyNamePrefixOperator(prop); + const containsEsc = this.state.containsEsc; + this.parsePropertyName(prop, refExpressionErrors); + if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) { + const { + key + } = prop; + const keyName = key.name; + if (keyName === "async" && !this.hasPrecedingLineBreak()) { + isAsync = true; + this.resetPreviousNodeTrailingComments(key); + isGenerator = this.eat(55); + this.parsePropertyName(prop); + } + if (keyName === "get" || keyName === "set") { + isAccessor = true; + this.resetPreviousNodeTrailingComments(key); + prop.kind = keyName; + if (this.match(55)) { + isGenerator = true; + this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), { + kind: keyName + }); + this.next(); + } + this.parsePropertyName(prop); + } + } + return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors); + } + getGetterSetterExpectedParamCount(method) { + return method.kind === "get" ? 0 : 1; + } + getObjectOrClassMethodParams(method) { + return method.params; + } + checkGetterSetterParams(method) { + var _params; + const paramCount = this.getGetterSetterExpectedParamCount(method); + const params = this.getObjectOrClassMethodParams(method); + if (params.length !== paramCount) { + this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, method); + } + if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") { + this.raise(Errors.BadSetterRestParameter, method); + } + } + parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) { + if (isAccessor) { + const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod"); + this.checkGetterSetterParams(finishedProp); + return finishedProp; + } + if (isAsync || isGenerator || this.match(10)) { + if (isPattern) this.unexpected(); + prop.kind = "method"; + prop.method = true; + return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod"); + } + } + parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) { + prop.shorthand = false; + if (this.eat(14)) { + prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, refExpressionErrors); + return this.finishObjectProperty(prop); + } + if (!prop.computed && prop.key.type === "Identifier") { + this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false); + if (isPattern) { + prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key)); + } else if (this.match(29)) { + const shorthandAssignLoc = this.state.startLoc; + if (refExpressionErrors != null) { + if (refExpressionErrors.shorthandAssignLoc === null) { + refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc; + } + } else { + this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc); + } + prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key)); + } else { + prop.value = this.cloneIdentifier(prop.key); + } + prop.shorthand = true; + return this.finishObjectProperty(prop); + } + } + finishObjectProperty(node) { + return this.finishNode(node, "ObjectProperty"); + } + parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { + const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors); + if (!node) this.unexpected(); + return node; + } + parsePropertyName(prop, refExpressionErrors) { + if (this.eat(0)) { + prop.computed = true; + prop.key = this.parseMaybeAssignAllowIn(); + this.expect(3); + } else { + const { + type, + value + } = this.state; + let key; + if (tokenIsKeywordOrIdentifier(type)) { + key = this.parseIdentifier(true); + } else { + switch (type) { + case 135: + key = this.parseNumericLiteral(value); + break; + case 134: + key = this.parseStringLiteral(value); + break; + case 136: + key = this.parseBigIntLiteral(value); + break; + case 139: + { + const privateKeyLoc = this.state.startLoc; + if (refExpressionErrors != null) { + if (refExpressionErrors.privateKeyLoc === null) { + refExpressionErrors.privateKeyLoc = privateKeyLoc; + } + } else { + this.raise(Errors.UnexpectedPrivateField, privateKeyLoc); + } + key = this.parsePrivateName(); + break; + } + default: + if (type === 137) { + key = this.parseDecimalLiteral(value); + break; + } + this.unexpected(); + } + } + prop.key = key; + if (type !== 139) { + prop.computed = false; + } + } + } + initFunction(node, isAsync) { + node.id = null; + node.generator = false; + node.async = isAsync; + } + parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { + this.initFunction(node, isAsync); + node.generator = isGenerator; + this.scope.enter(514 | 16 | (inClassScope ? 576 : 0) | (allowDirectSuper ? 32 : 0)); + this.prodParam.enter(functionFlags(isAsync, node.generator)); + this.parseFunctionParams(node, isConstructor); + const finishedNode = this.parseFunctionBodyAndFinish(node, type, true); + this.prodParam.exit(); + this.scope.exit(); + return finishedNode; + } + parseArrayLike(close, isTuple, refExpressionErrors) { + if (isTuple) { + this.expectPlugin("recordAndTuple"); + } + const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; + this.state.inFSharpPipelineDirectBody = false; + const node = this.startNode(); + this.next(); + node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node); + this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; + return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression"); + } + parseArrowExpression(node, params, isAsync, trailingCommaLoc) { + this.scope.enter(514 | 4); + let flags = functionFlags(isAsync, false); + if (!this.match(5) && this.prodParam.hasIn) { + flags |= 8; + } + this.prodParam.enter(flags); + this.initFunction(node, isAsync); + const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; + if (params) { + this.state.maybeInArrowParameters = true; + this.setArrowFunctionParameters(node, params, trailingCommaLoc); + } + this.state.maybeInArrowParameters = false; + this.parseFunctionBody(node, true); + this.prodParam.exit(); + this.scope.exit(); + this.state.maybeInArrowParameters = oldMaybeInArrowParameters; + return this.finishNode(node, "ArrowFunctionExpression"); + } + setArrowFunctionParameters(node, params, trailingCommaLoc) { + this.toAssignableList(params, trailingCommaLoc, false); + node.params = params; + } + parseFunctionBodyAndFinish(node, type, isMethod = false) { + this.parseFunctionBody(node, false, isMethod); + return this.finishNode(node, type); + } + parseFunctionBody(node, allowExpression, isMethod = false) { + const isExpression = allowExpression && !this.match(5); + this.expressionScope.enter(newExpressionScope()); + if (isExpression) { + node.body = this.parseMaybeAssign(); + this.checkParams(node, false, allowExpression, false); + } else { + const oldStrict = this.state.strict; + const oldLabels = this.state.labels; + this.state.labels = []; + this.prodParam.enter(this.prodParam.currentFlags() | 4); + node.body = this.parseBlock(true, false, hasStrictModeDirective => { + const nonSimple = !this.isSimpleParamList(node.params); + if (hasStrictModeDirective && nonSimple) { + this.raise(Errors.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node); + } + const strictModeChanged = !oldStrict && this.state.strict; + this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged); + if (this.state.strict && node.id) { + this.checkIdentifier(node.id, 65, strictModeChanged); + } + }); + this.prodParam.exit(); + this.state.labels = oldLabels; + } + this.expressionScope.exit(); + } + isSimpleParameter(node) { + return node.type === "Identifier"; + } + isSimpleParamList(params) { + for (let i = 0, len = params.length; i < len; i++) { + if (!this.isSimpleParameter(params[i])) return false; + } + return true; + } + checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { + const checkClashes = !allowDuplicates && new Set(); + const formalParameters = { + type: "FormalParameters" + }; + for (const param of node.params) { + this.checkLVal(param, formalParameters, 5, checkClashes, strictModeChanged); + } + } + parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) { + const elts = []; + let first = true; + while (!this.eat(close)) { + if (first) { + first = false; + } else { + this.expect(12); + if (this.match(close)) { + if (nodeForExtra) { + this.addTrailingCommaExtraToNode(nodeForExtra); + } + this.next(); + break; + } + } + elts.push(this.parseExprListItem(close, allowEmpty, refExpressionErrors)); + } + return elts; + } + parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) { + let elt; + if (this.match(12)) { + if (!allowEmpty) { + this.raise(Errors.UnexpectedToken, this.state.curPosition(), { + unexpected: "," + }); + } + elt = null; + } else if (this.match(21)) { + const spreadNodeStartLoc = this.state.startLoc; + elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc); + } else if (this.match(17)) { + this.expectPlugin("partialApplication"); + if (!allowPlaceholder) { + this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc); + } + const node = this.startNode(); + this.next(); + elt = this.finishNode(node, "ArgumentPlaceholder"); + } else { + elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, this.parseParenItem); + } + return elt; + } + parseIdentifier(liberal) { + const node = this.startNode(); + const name = this.parseIdentifierName(liberal); + return this.createIdentifier(node, name); + } + createIdentifier(node, name) { + node.name = name; + node.loc.identifierName = name; + return this.finishNode(node, "Identifier"); + } + createIdentifierAt(node, name, endLoc) { + node.name = name; + node.loc.identifierName = name; + return this.finishNodeAt(node, "Identifier", endLoc); + } + parseIdentifierName(liberal) { + let name; + const { + startLoc, + type + } = this.state; + if (tokenIsKeywordOrIdentifier(type)) { + name = this.state.value; + } else { + this.unexpected(); + } + const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type); + if (liberal) { + if (tokenIsKeyword) { + this.replaceToken(132); + } + } else { + this.checkReservedWord(name, startLoc, tokenIsKeyword, false); + } + this.next(); + return name; + } + checkReservedWord(word, startLoc, checkKeywords, isBinding) { + if (word.length > 10) { + return; + } + if (!canBeReservedWord(word)) { + return; + } + if (checkKeywords && isKeyword(word)) { + this.raise(Errors.UnexpectedKeyword, startLoc, { + keyword: word + }); + return; + } + const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord; + if (reservedTest(word, this.inModule)) { + this.raise(Errors.UnexpectedReservedWord, startLoc, { + reservedWord: word + }); + return; + } else if (word === "yield") { + if (this.prodParam.hasYield) { + this.raise(Errors.YieldBindingIdentifier, startLoc); + return; + } + } else if (word === "await") { + if (this.prodParam.hasAwait) { + this.raise(Errors.AwaitBindingIdentifier, startLoc); + return; + } + if (this.scope.inStaticBlock) { + this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc); + return; + } + this.expressionScope.recordAsyncArrowParametersError(startLoc); + } else if (word === "arguments") { + if (this.scope.inClassAndNotInNonArrowFunction) { + this.raise(Errors.ArgumentsInClass, startLoc); + return; + } + } + } + recordAwaitIfAllowed() { + const isAwaitAllowed = this.prodParam.hasAwait; + if (isAwaitAllowed && !this.scope.inFunction) { + this.state.hasTopLevelAwait = true; + } + return isAwaitAllowed; + } + parseAwait(startLoc) { + const node = this.startNodeAt(startLoc); + this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node); + if (this.eat(55)) { + this.raise(Errors.ObsoleteAwaitStar, node); + } + if (!this.scope.inFunction && !(this.optionFlags & 1)) { + if (this.isAmbiguousPrefixOrIdentifier()) { + this.ambiguousScriptDifferentAst = true; + } else { + this.sawUnambiguousESM = true; + } + } + if (!this.state.soloAwait) { + node.argument = this.parseMaybeUnary(null, true); + } + return this.finishNode(node, "AwaitExpression"); + } + isAmbiguousPrefixOrIdentifier() { + if (this.hasPrecedingLineBreak()) return true; + const { + type + } = this.state; + return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 102 && !this.state.containsEsc || type === 138 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54; + } + parseYield(startLoc) { + const node = this.startNodeAt(startLoc); + this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node); + let delegating = false; + let argument = null; + if (!this.hasPrecedingLineBreak()) { + delegating = this.eat(55); + switch (this.state.type) { + case 13: + case 140: + case 8: + case 11: + case 3: + case 9: + case 14: + case 12: + if (!delegating) break; + default: + argument = this.parseMaybeAssign(); + } + } + node.delegate = delegating; + node.argument = argument; + return this.finishNode(node, "YieldExpression"); + } + parseImportCall(node) { + this.next(); + node.source = this.parseMaybeAssignAllowIn(); + node.options = null; + if (this.eat(12)) { + if (!this.match(11)) { + node.options = this.parseMaybeAssignAllowIn(); + if (this.eat(12)) { + this.addTrailingCommaExtraToNode(node.options); + if (!this.match(11)) { + do { + this.parseMaybeAssignAllowIn(); + } while (this.eat(12) && !this.match(11)); + this.raise(Errors.ImportCallArity, node); + } + } + } else { + this.addTrailingCommaExtraToNode(node.source); + } + } + this.expect(11); + return this.finishNode(node, "ImportExpression"); + } + checkPipelineAtInfixOperator(left, leftStartLoc) { + if (this.hasPlugin(["pipelineOperator", { + proposal: "smart" + }])) { + if (left.type === "SequenceExpression") { + this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc); + } + } + } + parseSmartPipelineBodyInStyle(childExpr, startLoc) { + if (this.isSimpleReference(childExpr)) { + const bodyNode = this.startNodeAt(startLoc); + bodyNode.callee = childExpr; + return this.finishNode(bodyNode, "PipelineBareFunction"); + } else { + const bodyNode = this.startNodeAt(startLoc); + this.checkSmartPipeTopicBodyEarlyErrors(startLoc); + bodyNode.expression = childExpr; + return this.finishNode(bodyNode, "PipelineTopicExpression"); + } + } + isSimpleReference(expression) { + switch (expression.type) { + case "MemberExpression": + return !expression.computed && this.isSimpleReference(expression.object); + case "Identifier": + return true; + default: + return false; + } + } + checkSmartPipeTopicBodyEarlyErrors(startLoc) { + if (this.match(19)) { + throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc); + } + if (!this.topicReferenceWasUsedInCurrentContext()) { + this.raise(Errors.PipelineTopicUnused, startLoc); + } + } + withTopicBindingContext(callback) { + const outerContextTopicState = this.state.topicContext; + this.state.topicContext = { + maxNumOfResolvableTopics: 1, + maxTopicIndex: null + }; + try { + return callback(); + } finally { + this.state.topicContext = outerContextTopicState; + } + } + withSmartMixTopicForbiddingContext(callback) { + if (this.hasPlugin(["pipelineOperator", { + proposal: "smart" + }])) { + const outerContextTopicState = this.state.topicContext; + this.state.topicContext = { + maxNumOfResolvableTopics: 0, + maxTopicIndex: null + }; + try { + return callback(); + } finally { + this.state.topicContext = outerContextTopicState; + } + } else { + return callback(); + } + } + withSoloAwaitPermittingContext(callback) { + const outerContextSoloAwaitState = this.state.soloAwait; + this.state.soloAwait = true; + try { + return callback(); + } finally { + this.state.soloAwait = outerContextSoloAwaitState; + } + } + allowInAnd(callback) { + const flags = this.prodParam.currentFlags(); + const prodParamToSet = 8 & ~flags; + if (prodParamToSet) { + this.prodParam.enter(flags | 8); + try { + return callback(); + } finally { + this.prodParam.exit(); + } + } + return callback(); + } + disallowInAnd(callback) { + const flags = this.prodParam.currentFlags(); + const prodParamToClear = 8 & flags; + if (prodParamToClear) { + this.prodParam.enter(flags & ~8); + try { + return callback(); + } finally { + this.prodParam.exit(); + } + } + return callback(); + } + registerTopicReference() { + this.state.topicContext.maxTopicIndex = 0; + } + topicReferenceIsAllowedInCurrentContext() { + return this.state.topicContext.maxNumOfResolvableTopics >= 1; + } + topicReferenceWasUsedInCurrentContext() { + return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0; + } + parseFSharpPipelineBody(prec) { + const startLoc = this.state.startLoc; + this.state.potentialArrowAt = this.state.start; + const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; + this.state.inFSharpPipelineDirectBody = true; + const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec); + this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; + return ret; + } + parseModuleExpression() { + this.expectPlugin("moduleBlocks"); + const node = this.startNode(); + this.next(); + if (!this.match(5)) { + this.unexpected(null, 5); + } + const program = this.startNodeAt(this.state.endLoc); + this.next(); + const revertScopes = this.initializeScopes(true); + this.enterInitialScopes(); + try { + node.body = this.parseProgram(program, 8, "module"); + } finally { + revertScopes(); + } + return this.finishNode(node, "ModuleExpression"); + } + parseVoidPattern(refExpressionErrors) { + this.expectPlugin("discardBinding"); + const node = this.startNode(); + if (refExpressionErrors != null) { + refExpressionErrors.voidPatternLoc = this.state.startLoc; + } + this.next(); + return this.finishNode(node, "VoidPattern"); + } + parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) { + if (refExpressionErrors != null && this.match(88)) { + const nextCode = this.lookaheadCharCode(); + if (nextCode === 44 || nextCode === (close === 3 ? 93 : close === 8 ? 125 : 41) || nextCode === 61) { + return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors)); + } + } + return this.parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse); + } + parsePropertyNamePrefixOperator(prop) {} +} +const loopLabel = { + kind: 1 + }, + switchLabel = { + kind: 2 + }; +const loneSurrogate = /[\uD800-\uDFFF]/u; +const keywordRelationalOperator = /in(?:stanceof)?/y; +function babel7CompatTokens(tokens, input, startIndex) { + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i]; + const { + type + } = token; + if (typeof type === "number") { + if (type === 139) { + const { + loc, + start, + value, + end + } = token; + const hashEndPos = start + 1; + const hashEndLoc = createPositionWithColumnOffset(loc.start, 1); + tokens.splice(i, 1, new Token({ + type: getExportedToken(27), + value: "#", + start: start, + end: hashEndPos, + startLoc: loc.start, + endLoc: hashEndLoc + }), new Token({ + type: getExportedToken(132), + value: value, + start: hashEndPos, + end: end, + startLoc: hashEndLoc, + endLoc: loc.end + })); + i++; + continue; + } + if (tokenIsTemplate(type)) { + const { + loc, + start, + value, + end + } = token; + const backquoteEnd = start + 1; + const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1); + let startToken; + if (input.charCodeAt(start - startIndex) === 96) { + startToken = new Token({ + type: getExportedToken(22), + value: "`", + start: start, + end: backquoteEnd, + startLoc: loc.start, + endLoc: backquoteEndLoc + }); + } else { + startToken = new Token({ + type: getExportedToken(8), + value: "}", + start: start, + end: backquoteEnd, + startLoc: loc.start, + endLoc: backquoteEndLoc + }); + } + let templateValue, templateElementEnd, templateElementEndLoc, endToken; + if (type === 24) { + templateElementEnd = end - 1; + templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1); + templateValue = value === null ? null : value.slice(1, -1); + endToken = new Token({ + type: getExportedToken(22), + value: "`", + start: templateElementEnd, + end: end, + startLoc: templateElementEndLoc, + endLoc: loc.end + }); + } else { + templateElementEnd = end - 2; + templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2); + templateValue = value === null ? null : value.slice(1, -2); + endToken = new Token({ + type: getExportedToken(23), + value: "${", + start: templateElementEnd, + end: end, + startLoc: templateElementEndLoc, + endLoc: loc.end + }); + } + tokens.splice(i, 1, startToken, new Token({ + type: getExportedToken(20), + value: templateValue, + start: backquoteEnd, + end: templateElementEnd, + startLoc: backquoteEndLoc, + endLoc: templateElementEndLoc + }), endToken); + i += 2; + continue; + } + token.type = getExportedToken(type); + } + } + return tokens; +} +class StatementParser extends ExpressionParser { + parseTopLevel(file, program) { + file.program = this.parseProgram(program, 140, this.options.sourceType === "module" ? "module" : "script"); + file.comments = this.comments; + if (this.optionFlags & 256) { + file.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex); + } + return this.finishNode(file, "File"); + } + parseProgram(program, end, sourceType) { + program.sourceType = sourceType; + program.interpreter = this.parseInterpreterDirective(); + this.parseBlockBody(program, true, true, end); + if (this.inModule) { + if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) { + for (const [localName, at] of Array.from(this.scope.undefinedExports)) { + this.raise(Errors.ModuleExportUndefined, at, { + localName + }); + } + } + this.addExtra(program, "topLevelAwait", this.state.hasTopLevelAwait); + } + let finishedProgram; + if (end === 140) { + finishedProgram = this.finishNode(program, "Program"); + } else { + finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1)); + } + return finishedProgram; + } + stmtToDirective(stmt) { + const directive = this.castNodeTo(stmt, "Directive"); + const directiveLiteral = this.castNodeTo(stmt.expression, "DirectiveLiteral"); + const expressionValue = directiveLiteral.value; + const raw = this.input.slice(this.offsetToSourcePos(directiveLiteral.start), this.offsetToSourcePos(directiveLiteral.end)); + const val = directiveLiteral.value = raw.slice(1, -1); + this.addExtra(directiveLiteral, "raw", raw); + this.addExtra(directiveLiteral, "rawValue", val); + this.addExtra(directiveLiteral, "expressionValue", expressionValue); + directive.value = directiveLiteral; + delete stmt.expression; + return directive; + } + parseInterpreterDirective() { + if (!this.match(28)) { + return null; + } + const node = this.startNode(); + node.value = this.state.value; + this.next(); + return this.finishNode(node, "InterpreterDirective"); + } + isLet() { + if (!this.isContextual(100)) { + return false; + } + return this.hasFollowingBindingAtom(); + } + isUsing() { + if (!this.isContextual(107)) { + return false; + } + return this.nextTokenIsIdentifierOnSameLine(); + } + isForUsing() { + if (!this.isContextual(107)) { + return false; + } + const next = this.nextTokenInLineStart(); + const nextCh = this.codePointAtPos(next); + if (this.isUnparsedContextual(next, "of")) { + const nextCharAfterOf = this.lookaheadCharCodeSince(next + 2); + if (nextCharAfterOf !== 61 && nextCharAfterOf !== 58 && nextCharAfterOf !== 59) { + return false; + } + } + if (this.chStartsBindingIdentifier(nextCh, next) || this.isUnparsedContextual(next, "void")) { + return true; + } + return false; + } + nextTokenIsIdentifierOnSameLine() { + const next = this.nextTokenInLineStart(); + const nextCh = this.codePointAtPos(next); + return this.chStartsBindingIdentifier(nextCh, next); + } + isAwaitUsing() { + if (!this.isContextual(96)) { + return false; + } + let next = this.nextTokenInLineStart(); + if (this.isUnparsedContextual(next, "using")) { + next = this.nextTokenInLineStartSince(next + 5); + const nextCh = this.codePointAtPos(next); + if (this.chStartsBindingIdentifier(nextCh, next)) { + return true; + } + } + return false; + } + chStartsBindingIdentifier(ch, pos) { + if (isIdentifierStart(ch)) { + keywordRelationalOperator.lastIndex = pos; + if (keywordRelationalOperator.test(this.input)) { + const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex); + if (!isIdentifierChar(endCh) && endCh !== 92) { + return false; + } + } + return true; + } else if (ch === 92) { + return true; + } else { + return false; + } + } + chStartsBindingPattern(ch) { + return ch === 91 || ch === 123; + } + hasFollowingBindingAtom() { + const next = this.nextTokenStart(); + const nextCh = this.codePointAtPos(next); + return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next); + } + hasInLineFollowingBindingIdentifierOrBrace() { + const next = this.nextTokenInLineStart(); + const nextCh = this.codePointAtPos(next); + return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next); + } + allowsUsing() { + return (this.scope.inModule || !this.scope.inTopLevel) && !this.scope.inBareCaseStatement; + } + parseModuleItem() { + return this.parseStatementLike(1 | 2 | 4 | 8); + } + parseStatementListItem() { + return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8)); + } + parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) { + let flags = 0; + if (this.options.annexB && !this.state.strict) { + flags |= 4; + if (allowLabeledFunction) { + flags |= 8; + } + } + return this.parseStatementLike(flags); + } + parseStatement() { + return this.parseStatementLike(0); + } + parseStatementLike(flags) { + let decorators = null; + if (this.match(26)) { + decorators = this.parseDecorators(true); + } + return this.parseStatementContent(flags, decorators); + } + parseStatementContent(flags, decorators) { + const startType = this.state.type; + const node = this.startNode(); + const allowDeclaration = !!(flags & 2); + const allowFunctionDeclaration = !!(flags & 4); + const topLevel = flags & 1; + switch (startType) { + case 60: + return this.parseBreakContinueStatement(node, true); + case 63: + return this.parseBreakContinueStatement(node, false); + case 64: + return this.parseDebuggerStatement(node); + case 90: + return this.parseDoWhileStatement(node); + case 91: + return this.parseForStatement(node); + case 68: + if (this.lookaheadCharCode() === 46) break; + if (!allowFunctionDeclaration) { + this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc); + } + return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration); + case 80: + if (!allowDeclaration) this.unexpected(); + return this.parseClass(this.maybeTakeDecorators(decorators, node), true); + case 69: + return this.parseIfStatement(node); + case 70: + return this.parseReturnStatement(node); + case 71: + return this.parseSwitchStatement(node); + case 72: + return this.parseThrowStatement(node); + case 73: + return this.parseTryStatement(node); + case 96: + if (this.isAwaitUsing()) { + if (!this.allowsUsing()) { + this.raise(Errors.UnexpectedUsingDeclaration, node); + } else if (!allowDeclaration) { + this.raise(Errors.UnexpectedLexicalDeclaration, node); + } else if (!this.recordAwaitIfAllowed()) { + this.raise(Errors.AwaitUsingNotInAsyncContext, node); + } + this.next(); + return this.parseVarStatement(node, "await using"); + } + break; + case 107: + if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) { + break; + } + if (!this.allowsUsing()) { + this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc); + } else if (!allowDeclaration) { + this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc); + } + return this.parseVarStatement(node, "using"); + case 100: + { + if (this.state.containsEsc) { + break; + } + const next = this.nextTokenStart(); + const nextCh = this.codePointAtPos(next); + if (nextCh !== 91) { + if (!allowDeclaration && this.hasFollowingLineBreak()) break; + if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) { + break; + } + } + } + case 75: + { + if (!allowDeclaration) { + this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc); + } + } + case 74: + { + const kind = this.state.value; + return this.parseVarStatement(node, kind); + } + case 92: + return this.parseWhileStatement(node); + case 76: + return this.parseWithStatement(node); + case 5: + return this.parseBlock(); + case 13: + return this.parseEmptyStatement(node); + case 83: + { + const nextTokenCharCode = this.lookaheadCharCode(); + if (nextTokenCharCode === 40 || nextTokenCharCode === 46) { + break; + } + } + case 82: + { + if (!(this.optionFlags & 8) && !topLevel) { + this.raise(Errors.UnexpectedImportExport, this.state.startLoc); + } + this.next(); + let result; + if (startType === 83) { + result = this.parseImport(node); + } else { + result = this.parseExport(node, decorators); + } + this.assertModuleNodeAllowed(result); + return result; + } + default: + { + if (this.isAsyncFunction()) { + if (!allowDeclaration) { + this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc); + } + this.next(); + return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration); + } + } + } + const maybeName = this.state.value; + const expr = this.parseExpression(); + if (tokenIsIdentifier(startType) && expr.type === "Identifier" && this.eat(14)) { + return this.parseLabeledStatement(node, maybeName, expr, flags); + } else { + return this.parseExpressionStatement(node, expr, decorators); + } + } + assertModuleNodeAllowed(node) { + if (!(this.optionFlags & 8) && !this.inModule) { + this.raise(Errors.ImportOutsideModule, node); + } + } + decoratorsEnabledBeforeExport() { + if (this.hasPlugin("decorators-legacy")) return true; + return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false; + } + maybeTakeDecorators(maybeDecorators, classNode, exportNode) { + if (maybeDecorators) { + var _classNode$decorators; + if ((_classNode$decorators = classNode.decorators) != null && _classNode$decorators.length) { + if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") { + this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]); + } + classNode.decorators.unshift(...maybeDecorators); + } else { + classNode.decorators = maybeDecorators; + } + this.resetStartLocationFromNode(classNode, maybeDecorators[0]); + if (exportNode) this.resetStartLocationFromNode(exportNode, classNode); + } + return classNode; + } + canHaveLeadingDecorator() { + return this.match(80); + } + parseDecorators(allowExport) { + const decorators = []; + do { + decorators.push(this.parseDecorator()); + } while (this.match(26)); + if (this.match(82)) { + if (!allowExport) { + this.unexpected(); + } + if (!this.decoratorsEnabledBeforeExport()) { + this.raise(Errors.DecoratorExportClass, this.state.startLoc); + } + } else if (!this.canHaveLeadingDecorator()) { + throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc); + } + return decorators; + } + parseDecorator() { + this.expectOnePlugin(["decorators", "decorators-legacy"]); + const node = this.startNode(); + this.next(); + if (this.hasPlugin("decorators")) { + const startLoc = this.state.startLoc; + let expr; + if (this.match(10)) { + const startLoc = this.state.startLoc; + this.next(); + expr = this.parseExpression(); + this.expect(11); + expr = this.wrapParenthesis(startLoc, expr); + const paramsStartLoc = this.state.startLoc; + node.expression = this.parseMaybeDecoratorArguments(expr, startLoc); + if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) { + this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc); + } + } else { + expr = this.parseIdentifier(false); + while (this.eat(16)) { + const node = this.startNodeAt(startLoc); + node.object = expr; + if (this.match(139)) { + this.classScope.usePrivateName(this.state.value, this.state.startLoc); + node.property = this.parsePrivateName(); + } else { + node.property = this.parseIdentifier(true); + } + node.computed = false; + expr = this.finishNode(node, "MemberExpression"); + } + node.expression = this.parseMaybeDecoratorArguments(expr, startLoc); + } + } else { + node.expression = this.parseExprSubscripts(); + } + return this.finishNode(node, "Decorator"); + } + parseMaybeDecoratorArguments(expr, startLoc) { + if (this.eat(10)) { + const node = this.startNodeAt(startLoc); + node.callee = expr; + node.arguments = this.parseCallExpressionArguments(); + this.toReferencedList(node.arguments); + return this.finishNode(node, "CallExpression"); + } + return expr; + } + parseBreakContinueStatement(node, isBreak) { + this.next(); + if (this.isLineTerminator()) { + node.label = null; + } else { + node.label = this.parseIdentifier(); + this.semicolon(); + } + this.verifyBreakContinue(node, isBreak); + return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement"); + } + verifyBreakContinue(node, isBreak) { + let i; + for (i = 0; i < this.state.labels.length; ++i) { + const lab = this.state.labels[i]; + if (node.label == null || lab.name === node.label.name) { + if (lab.kind != null && (isBreak || lab.kind === 1)) { + break; + } + if (node.label && isBreak) break; + } + } + if (i === this.state.labels.length) { + const type = isBreak ? "BreakStatement" : "ContinueStatement"; + this.raise(Errors.IllegalBreakContinue, node, { + type + }); + } + } + parseDebuggerStatement(node) { + this.next(); + this.semicolon(); + return this.finishNode(node, "DebuggerStatement"); + } + parseHeaderExpression() { + this.expect(10); + const val = this.parseExpression(); + this.expect(11); + return val; + } + parseDoWhileStatement(node) { + this.next(); + this.state.labels.push(loopLabel); + node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()); + this.state.labels.pop(); + this.expect(92); + node.test = this.parseHeaderExpression(); + this.eat(13); + return this.finishNode(node, "DoWhileStatement"); + } + parseForStatement(node) { + this.next(); + this.state.labels.push(loopLabel); + let awaitAt = null; + if (this.isContextual(96) && this.recordAwaitIfAllowed()) { + awaitAt = this.state.startLoc; + this.next(); + } + this.scope.enter(0); + this.expect(10); + if (this.match(13)) { + if (awaitAt !== null) { + this.unexpected(awaitAt); + } + return this.parseFor(node, null); + } + const startsWithLet = this.isContextual(100); + { + const startsWithAwaitUsing = this.isAwaitUsing(); + const starsWithUsingDeclaration = startsWithAwaitUsing || this.isForUsing(); + const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration; + if (this.match(74) || this.match(75) || isLetOrUsing) { + const initNode = this.startNode(); + let kind; + if (startsWithAwaitUsing) { + kind = "await using"; + if (!this.recordAwaitIfAllowed()) { + this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc); + } + this.next(); + } else { + kind = this.state.value; + } + this.next(); + this.parseVar(initNode, true, kind); + const init = this.finishNode(initNode, "VariableDeclaration"); + const isForIn = this.match(58); + if (isForIn && starsWithUsingDeclaration) { + this.raise(Errors.ForInUsing, init); + } + if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) { + return this.parseForIn(node, init, awaitAt); + } + if (awaitAt !== null) { + this.unexpected(awaitAt); + } + return this.parseFor(node, init); + } + } + const startsWithAsync = this.isContextual(95); + const refExpressionErrors = new ExpressionErrors(); + const init = this.parseExpression(true, refExpressionErrors); + const isForOf = this.isContextual(102); + if (isForOf) { + if (startsWithLet) { + this.raise(Errors.ForOfLet, init); + } + if (awaitAt === null && startsWithAsync && init.type === "Identifier") { + this.raise(Errors.ForOfAsync, init); + } + } + if (isForOf || this.match(58)) { + this.checkDestructuringPrivate(refExpressionErrors); + this.toAssignable(init, true); + const type = isForOf ? "ForOfStatement" : "ForInStatement"; + this.checkLVal(init, { + type + }); + return this.parseForIn(node, init, awaitAt); + } else { + this.checkExpressionErrors(refExpressionErrors, true); + } + if (awaitAt !== null) { + this.unexpected(awaitAt); + } + return this.parseFor(node, init); + } + parseFunctionStatement(node, isAsync, isHangingDeclaration) { + this.next(); + return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0)); + } + parseIfStatement(node) { + this.next(); + node.test = this.parseHeaderExpression(); + node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration(); + node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null; + return this.finishNode(node, "IfStatement"); + } + parseReturnStatement(node) { + if (!this.prodParam.hasReturn) { + this.raise(Errors.IllegalReturn, this.state.startLoc); + } + this.next(); + if (this.isLineTerminator()) { + node.argument = null; + } else { + node.argument = this.parseExpression(); + this.semicolon(); + } + return this.finishNode(node, "ReturnStatement"); + } + parseSwitchStatement(node) { + this.next(); + node.discriminant = this.parseHeaderExpression(); + const cases = node.cases = []; + this.expect(5); + this.state.labels.push(switchLabel); + this.scope.enter(256); + let cur; + for (let sawDefault; !this.match(8);) { + if (this.match(61) || this.match(65)) { + const isCase = this.match(61); + if (cur) this.finishNode(cur, "SwitchCase"); + cases.push(cur = this.startNode()); + cur.consequent = []; + this.next(); + if (isCase) { + cur.test = this.parseExpression(); + } else { + if (sawDefault) { + this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc); + } + sawDefault = true; + cur.test = null; + } + this.expect(14); + } else { + if (cur) { + cur.consequent.push(this.parseStatementListItem()); + } else { + this.unexpected(); + } + } + } + this.scope.exit(); + if (cur) this.finishNode(cur, "SwitchCase"); + this.next(); + this.state.labels.pop(); + return this.finishNode(node, "SwitchStatement"); + } + parseThrowStatement(node) { + this.next(); + if (this.hasPrecedingLineBreak()) { + this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc); + } + node.argument = this.parseExpression(); + this.semicolon(); + return this.finishNode(node, "ThrowStatement"); + } + parseCatchClauseParam() { + const param = this.parseBindingAtom(); + this.scope.enter(this.options.annexB && param.type === "Identifier" ? 8 : 0); + this.checkLVal(param, { + type: "CatchClause" + }, 9); + return param; + } + parseTryStatement(node) { + this.next(); + node.block = this.parseBlock(); + node.handler = null; + if (this.match(62)) { + const clause = this.startNode(); + this.next(); + if (this.match(10)) { + this.expect(10); + clause.param = this.parseCatchClauseParam(); + this.expect(11); + } else { + clause.param = null; + this.scope.enter(0); + } + clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false)); + this.scope.exit(); + node.handler = this.finishNode(clause, "CatchClause"); + } + node.finalizer = this.eat(67) ? this.parseBlock() : null; + if (!node.handler && !node.finalizer) { + this.raise(Errors.NoCatchOrFinally, node); + } + return this.finishNode(node, "TryStatement"); + } + parseVarStatement(node, kind, allowMissingInitializer = false) { + this.next(); + this.parseVar(node, false, kind, allowMissingInitializer); + this.semicolon(); + return this.finishNode(node, "VariableDeclaration"); + } + parseWhileStatement(node) { + this.next(); + node.test = this.parseHeaderExpression(); + this.state.labels.push(loopLabel); + node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()); + this.state.labels.pop(); + return this.finishNode(node, "WhileStatement"); + } + parseWithStatement(node) { + if (this.state.strict) { + this.raise(Errors.StrictWith, this.state.startLoc); + } + this.next(); + node.object = this.parseHeaderExpression(); + node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()); + return this.finishNode(node, "WithStatement"); + } + parseEmptyStatement(node) { + this.next(); + return this.finishNode(node, "EmptyStatement"); + } + parseLabeledStatement(node, maybeName, expr, flags) { + for (const label of this.state.labels) { + if (label.name === maybeName) { + this.raise(Errors.LabelRedeclaration, expr, { + labelName: maybeName + }); + } + } + const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null; + for (let i = this.state.labels.length - 1; i >= 0; i--) { + const label = this.state.labels[i]; + if (label.statementStart === node.start) { + label.statementStart = this.sourceToOffsetPos(this.state.start); + label.kind = kind; + } else { + break; + } + } + this.state.labels.push({ + name: maybeName, + kind: kind, + statementStart: this.sourceToOffsetPos(this.state.start) + }); + node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement(); + this.state.labels.pop(); + node.label = expr; + return this.finishNode(node, "LabeledStatement"); + } + parseExpressionStatement(node, expr, decorators) { + node.expression = expr; + this.semicolon(); + return this.finishNode(node, "ExpressionStatement"); + } + parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) { + const node = this.startNode(); + if (allowDirectives) { + this.state.strictErrors.clear(); + } + this.expect(5); + if (createNewLexicalScope) { + this.scope.enter(0); + } + this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse); + if (createNewLexicalScope) { + this.scope.exit(); + } + return this.finishNode(node, "BlockStatement"); + } + isValidDirective(stmt) { + return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized; + } + parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) { + const body = node.body = []; + const directives = node.directives = []; + this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse); + } + parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) { + const oldStrict = this.state.strict; + let hasStrictModeDirective = false; + let parsedNonDirective = false; + while (!this.match(end)) { + const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem(); + if (directives && !parsedNonDirective) { + if (this.isValidDirective(stmt)) { + const directive = this.stmtToDirective(stmt); + directives.push(directive); + if (!hasStrictModeDirective && directive.value.value === "use strict") { + hasStrictModeDirective = true; + this.setStrict(true); + } + continue; + } + parsedNonDirective = true; + this.state.strictErrors.clear(); + } + body.push(stmt); + } + afterBlockParse == null || afterBlockParse.call(this, hasStrictModeDirective); + if (!oldStrict) { + this.setStrict(false); + } + this.next(); + } + parseFor(node, init) { + node.init = init; + this.semicolon(false); + node.test = this.match(13) ? null : this.parseExpression(); + this.semicolon(false); + node.update = this.match(11) ? null : this.parseExpression(); + this.expect(11); + node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()); + this.scope.exit(); + this.state.labels.pop(); + return this.finishNode(node, "ForStatement"); + } + parseForIn(node, init, awaitAt) { + const isForIn = this.match(58); + this.next(); + if (isForIn) { + if (awaitAt !== null) this.unexpected(awaitAt); + } else { + node.await = awaitAt !== null; + } + if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) { + this.raise(Errors.ForInOfLoopInitializer, init, { + type: isForIn ? "ForInStatement" : "ForOfStatement" + }); + } + if (init.type === "AssignmentPattern") { + this.raise(Errors.InvalidLhs, init, { + ancestor: { + type: "ForStatement" + } + }); + } + node.left = init; + node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn(); + this.expect(11); + node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()); + this.scope.exit(); + this.state.labels.pop(); + return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement"); + } + parseVar(node, isFor, kind, allowMissingInitializer = false) { + const declarations = node.declarations = []; + node.kind = kind; + for (;;) { + const decl = this.startNode(); + this.parseVarId(decl, kind); + decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn(); + if (decl.init === null && !allowMissingInitializer) { + if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(102)))) { + this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { + kind: "destructuring" + }); + } else if ((kind === "const" || kind === "using" || kind === "await using") && !(this.match(58) || this.isContextual(102))) { + this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { + kind + }); + } + } + declarations.push(this.finishNode(decl, "VariableDeclarator")); + if (!this.eat(12)) break; + } + return node; + } + parseVarId(decl, kind) { + const id = this.parseBindingAtom(); + if (kind === "using" || kind === "await using") { + if (id.type === "ArrayPattern" || id.type === "ObjectPattern") { + this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start); + } + } else { + if (id.type === "VoidPattern") { + this.raise(Errors.UnexpectedVoidPattern, id.loc.start); + } + } + this.checkLVal(id, { + type: "VariableDeclarator" + }, kind === "var" ? 5 : 8201); + decl.id = id; + } + parseAsyncFunctionExpression(node) { + return this.parseFunction(node, 8); + } + parseFunction(node, flags = 0) { + const hangingDeclaration = flags & 2; + const isDeclaration = !!(flags & 1); + const requireId = isDeclaration && !(flags & 4); + const isAsync = !!(flags & 8); + this.initFunction(node, isAsync); + if (this.match(55)) { + if (hangingDeclaration) { + this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc); + } + this.next(); + node.generator = true; + } + if (isDeclaration) { + node.id = this.parseFunctionId(requireId); + } + const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; + this.state.maybeInArrowParameters = false; + this.scope.enter(514); + this.prodParam.enter(functionFlags(isAsync, node.generator)); + if (!isDeclaration) { + node.id = this.parseFunctionId(); + } + this.parseFunctionParams(node, false); + this.withSmartMixTopicForbiddingContext(() => { + this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression"); + }); + this.prodParam.exit(); + this.scope.exit(); + if (isDeclaration && !hangingDeclaration) { + this.registerFunctionStatementId(node); + } + this.state.maybeInArrowParameters = oldMaybeInArrowParameters; + return node; + } + parseFunctionId(requireId) { + return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null; + } + parseFunctionParams(node, isConstructor) { + this.expect(10); + this.expressionScope.enter(newParameterDeclarationScope()); + node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0)); + this.expressionScope.exit(); + } + registerFunctionStatementId(node) { + if (!node.id) return; + this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start); + } + parseClass(node, isStatement, optionalId) { + this.next(); + const oldStrict = this.state.strict; + this.state.strict = true; + this.parseClassId(node, isStatement, optionalId); + this.parseClassSuper(node); + node.body = this.parseClassBody(!!node.superClass, oldStrict); + return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression"); + } + isClassProperty() { + return this.match(29) || this.match(13) || this.match(8); + } + isClassMethod() { + return this.match(10); + } + nameIsConstructor(key) { + return key.type === "Identifier" && key.name === "constructor" || key.type === "StringLiteral" && key.value === "constructor"; + } + isNonstaticConstructor(method) { + return !method.computed && !method.static && this.nameIsConstructor(method.key); + } + parseClassBody(hadSuperClass, oldStrict) { + this.classScope.enter(); + const state = { + hadConstructor: false, + hadSuperClass + }; + let decorators = []; + const classBody = this.startNode(); + classBody.body = []; + this.expect(5); + this.withSmartMixTopicForbiddingContext(() => { + while (!this.match(8)) { + if (this.eat(13)) { + if (decorators.length > 0) { + throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc); + } + continue; + } + if (this.match(26)) { + decorators.push(this.parseDecorator()); + continue; + } + const member = this.startNode(); + if (decorators.length) { + member.decorators = decorators; + this.resetStartLocationFromNode(member, decorators[0]); + decorators = []; + } + this.parseClassMember(classBody, member, state); + if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) { + this.raise(Errors.DecoratorConstructor, member); + } + } + }); + this.state.strict = oldStrict; + this.next(); + if (decorators.length) { + throw this.raise(Errors.TrailingDecorator, this.state.startLoc); + } + this.classScope.exit(); + return this.finishNode(classBody, "ClassBody"); + } + parseClassMemberFromModifier(classBody, member) { + const key = this.parseIdentifier(true); + if (this.isClassMethod()) { + const method = member; + method.kind = "method"; + method.computed = false; + method.key = key; + method.static = false; + this.pushClassMethod(classBody, method, false, false, false, false); + return true; + } else if (this.isClassProperty()) { + const prop = member; + prop.computed = false; + prop.key = key; + prop.static = false; + classBody.body.push(this.parseClassProperty(prop)); + return true; + } + this.resetPreviousNodeTrailingComments(key); + return false; + } + parseClassMember(classBody, member, state) { + const isStatic = this.isContextual(106); + if (isStatic) { + if (this.parseClassMemberFromModifier(classBody, member)) { + return; + } + if (this.eat(5)) { + this.parseClassStaticBlock(classBody, member); + return; + } + } + this.parseClassMemberWithIsStatic(classBody, member, state, isStatic); + } + parseClassMemberWithIsStatic(classBody, member, state, isStatic) { + const publicMethod = member; + const privateMethod = member; + const publicProp = member; + const privateProp = member; + const accessorProp = member; + const method = publicMethod; + const publicMember = publicMethod; + member.static = isStatic; + this.parsePropertyNamePrefixOperator(member); + if (this.eat(55)) { + method.kind = "method"; + const isPrivateName = this.match(139); + this.parseClassElementName(method); + this.parsePostMemberNameModifiers(method); + if (isPrivateName) { + this.pushClassPrivateMethod(classBody, privateMethod, true, false); + return; + } + if (this.isNonstaticConstructor(publicMethod)) { + this.raise(Errors.ConstructorIsGenerator, publicMethod.key); + } + this.pushClassMethod(classBody, publicMethod, true, false, false, false); + return; + } + const isContextual = !this.state.containsEsc && tokenIsIdentifier(this.state.type); + const key = this.parseClassElementName(member); + const maybeContextualKw = isContextual ? key.name : null; + const isPrivate = this.isPrivateName(key); + const maybeQuestionTokenStartLoc = this.state.startLoc; + this.parsePostMemberNameModifiers(publicMember); + if (this.isClassMethod()) { + method.kind = "method"; + if (isPrivate) { + this.pushClassPrivateMethod(classBody, privateMethod, false, false); + return; + } + const isConstructor = this.isNonstaticConstructor(publicMethod); + let allowsDirectSuper = false; + if (isConstructor) { + publicMethod.kind = "constructor"; + if (state.hadConstructor && !this.hasPlugin("typescript")) { + this.raise(Errors.DuplicateConstructor, key); + } + if (isConstructor && this.hasPlugin("typescript") && member.override) { + this.raise(Errors.OverrideOnConstructor, key); + } + state.hadConstructor = true; + allowsDirectSuper = state.hadSuperClass; + } + this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper); + } else if (this.isClassProperty()) { + if (isPrivate) { + this.pushClassPrivateProperty(classBody, privateProp); + } else { + this.pushClassProperty(classBody, publicProp); + } + } else if (maybeContextualKw === "async" && !this.isLineTerminator()) { + this.resetPreviousNodeTrailingComments(key); + const isGenerator = this.eat(55); + if (publicMember.optional) { + this.unexpected(maybeQuestionTokenStartLoc); + } + method.kind = "method"; + const isPrivate = this.match(139); + this.parseClassElementName(method); + this.parsePostMemberNameModifiers(publicMember); + if (isPrivate) { + this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true); + } else { + if (this.isNonstaticConstructor(publicMethod)) { + this.raise(Errors.ConstructorIsAsync, publicMethod.key); + } + this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false); + } + } else if ((maybeContextualKw === "get" || maybeContextualKw === "set") && !(this.match(55) && this.isLineTerminator())) { + this.resetPreviousNodeTrailingComments(key); + method.kind = maybeContextualKw; + const isPrivate = this.match(139); + this.parseClassElementName(publicMethod); + if (isPrivate) { + this.pushClassPrivateMethod(classBody, privateMethod, false, false); + } else { + if (this.isNonstaticConstructor(publicMethod)) { + this.raise(Errors.ConstructorIsAccessor, publicMethod.key); + } + this.pushClassMethod(classBody, publicMethod, false, false, false, false); + } + this.checkGetterSetterParams(publicMethod); + } else if (maybeContextualKw === "accessor" && !this.isLineTerminator()) { + this.expectPlugin("decoratorAutoAccessors"); + this.resetPreviousNodeTrailingComments(key); + const isPrivate = this.match(139); + this.parseClassElementName(publicProp); + this.pushClassAccessorProperty(classBody, accessorProp, isPrivate); + } else if (this.isLineTerminator()) { + if (isPrivate) { + this.pushClassPrivateProperty(classBody, privateProp); + } else { + this.pushClassProperty(classBody, publicProp); + } + } else { + this.unexpected(); + } + } + parseClassElementName(member) { + const { + type, + value + } = this.state; + if ((type === 132 || type === 134) && member.static && value === "prototype") { + this.raise(Errors.StaticPrototype, this.state.startLoc); + } + if (type === 139) { + if (value === "constructor") { + this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc); + } + const key = this.parsePrivateName(); + member.key = key; + return key; + } + this.parsePropertyName(member); + return member.key; + } + parseClassStaticBlock(classBody, member) { + var _member$decorators; + this.scope.enter(576 | 128 | 16); + const oldLabels = this.state.labels; + this.state.labels = []; + this.prodParam.enter(0); + const body = member.body = []; + this.parseBlockOrModuleBlockBody(body, undefined, false, 8); + this.prodParam.exit(); + this.scope.exit(); + this.state.labels = oldLabels; + classBody.body.push(this.finishNode(member, "StaticBlock")); + if ((_member$decorators = member.decorators) != null && _member$decorators.length) { + this.raise(Errors.DecoratorStaticBlock, member); + } + } + pushClassProperty(classBody, prop) { + if (!prop.computed && this.nameIsConstructor(prop.key)) { + this.raise(Errors.ConstructorClassField, prop.key); + } + classBody.body.push(this.parseClassProperty(prop)); + } + pushClassPrivateProperty(classBody, prop) { + const node = this.parseClassPrivateProperty(prop); + classBody.body.push(node); + this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start); + } + pushClassAccessorProperty(classBody, prop, isPrivate) { + if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) { + this.raise(Errors.ConstructorClassField, prop.key); + } + const node = this.parseClassAccessorProperty(prop); + classBody.body.push(node); + if (isPrivate) { + this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start); + } + } + pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { + classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true)); + } + pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { + const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true); + classBody.body.push(node); + const kind = node.kind === "get" ? node.static ? 6 : 2 : node.kind === "set" ? node.static ? 5 : 1 : 0; + this.declareClassPrivateMethodInScope(node, kind); + } + declareClassPrivateMethodInScope(node, kind) { + this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start); + } + parsePostMemberNameModifiers(methodOrProp) {} + parseClassPrivateProperty(node) { + this.parseInitializer(node); + this.semicolon(); + return this.finishNode(node, "ClassPrivateProperty"); + } + parseClassProperty(node) { + this.parseInitializer(node); + this.semicolon(); + return this.finishNode(node, "ClassProperty"); + } + parseClassAccessorProperty(node) { + this.parseInitializer(node); + this.semicolon(); + return this.finishNode(node, "ClassAccessorProperty"); + } + parseInitializer(node) { + this.scope.enter(576 | 16); + this.expressionScope.enter(newExpressionScope()); + this.prodParam.enter(0); + node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null; + this.expressionScope.exit(); + this.prodParam.exit(); + this.scope.exit(); + } + parseClassId(node, isStatement, optionalId, bindingType = 8331) { + if (tokenIsIdentifier(this.state.type)) { + node.id = this.parseIdentifier(); + if (isStatement) { + this.declareNameFromIdentifier(node.id, bindingType); + } + } else { + if (optionalId || !isStatement) { + node.id = null; + } else { + throw this.raise(Errors.MissingClassName, this.state.startLoc); + } + } + } + parseClassSuper(node) { + node.superClass = this.eat(81) ? this.parseExprSubscripts() : null; + } + parseExport(node, decorators) { + const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true); + const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier); + const parseAfterDefault = !hasDefault || this.eat(12); + const hasStar = parseAfterDefault && this.eatExportStar(node); + const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node); + const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12)); + const isFromRequired = hasDefault || hasStar; + if (hasStar && !hasNamespace) { + if (hasDefault) this.unexpected(); + if (decorators) { + throw this.raise(Errors.UnsupportedDecoratorExport, node); + } + this.parseExportFrom(node, true); + this.sawUnambiguousESM = true; + return this.finishNode(node, "ExportAllDeclaration"); + } + const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node); + if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) { + this.unexpected(null, 5); + } + if (hasNamespace && parseAfterNamespace) { + this.unexpected(null, 98); + } + let hasDeclaration; + if (isFromRequired || hasSpecifiers) { + hasDeclaration = false; + if (decorators) { + throw this.raise(Errors.UnsupportedDecoratorExport, node); + } + this.parseExportFrom(node, isFromRequired); + } else { + hasDeclaration = this.maybeParseExportDeclaration(node); + } + if (isFromRequired || hasSpecifiers || hasDeclaration) { + var _node2$declaration; + const node2 = node; + this.checkExport(node2, true, false, !!node2.source); + if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") { + this.maybeTakeDecorators(decorators, node2.declaration, node2); + } else if (decorators) { + throw this.raise(Errors.UnsupportedDecoratorExport, node); + } + this.sawUnambiguousESM = true; + return this.finishNode(node2, "ExportNamedDeclaration"); + } + if (this.eat(65)) { + const node2 = node; + const decl = this.parseExportDefaultExpression(); + node2.declaration = decl; + if (decl.type === "ClassDeclaration") { + this.maybeTakeDecorators(decorators, decl, node2); + } else if (decorators) { + throw this.raise(Errors.UnsupportedDecoratorExport, node); + } + this.checkExport(node2, true, true); + this.sawUnambiguousESM = true; + return this.finishNode(node2, "ExportDefaultDeclaration"); + } + throw this.unexpected(null, 5); + } + eatExportStar(node) { + return this.eat(55); + } + maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) { + if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) { + this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start); + const id = maybeDefaultIdentifier || this.parseIdentifier(true); + const specifier = this.startNodeAtNode(id); + specifier.exported = id; + node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; + return true; + } + return false; + } + maybeParseExportNamespaceSpecifier(node) { + if (this.isContextual(93)) { + var _ref, _ref$specifiers; + (_ref$specifiers = (_ref = node).specifiers) != null ? _ref$specifiers : _ref.specifiers = []; + const specifier = this.startNodeAt(this.state.lastTokStartLoc); + this.next(); + specifier.exported = this.parseModuleExportName(); + node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier")); + return true; + } + return false; + } + maybeParseExportNamedSpecifiers(node) { + if (this.match(5)) { + const node2 = node; + if (!node2.specifiers) node2.specifiers = []; + const isTypeExport = node2.exportKind === "type"; + node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport)); + node2.source = null; + if (this.hasPlugin("importAssertions")) { + node2.assertions = []; + } else { + node2.attributes = []; + } + node2.declaration = null; + return true; + } + return false; + } + maybeParseExportDeclaration(node) { + if (this.shouldParseExportDeclaration()) { + node.specifiers = []; + node.source = null; + if (this.hasPlugin("importAssertions")) { + node.assertions = []; + } else { + node.attributes = []; + } + node.declaration = this.parseExportDeclaration(node); + return true; + } + return false; + } + isAsyncFunction() { + if (!this.isContextual(95)) return false; + const next = this.nextTokenInLineStart(); + return this.isUnparsedContextual(next, "function"); + } + parseExportDefaultExpression() { + const expr = this.startNode(); + if (this.match(68)) { + this.next(); + return this.parseFunction(expr, 1 | 4); + } else if (this.isAsyncFunction()) { + this.next(); + this.next(); + return this.parseFunction(expr, 1 | 4 | 8); + } + if (this.match(80)) { + return this.parseClass(expr, true, true); + } + if (this.match(26)) { + if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) { + this.raise(Errors.DecoratorBeforeExport, this.state.startLoc); + } + return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true); + } + if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) { + throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc); + } + const res = this.parseMaybeAssignAllowIn(); + this.semicolon(); + return res; + } + parseExportDeclaration(node) { + if (this.match(80)) { + const node = this.parseClass(this.startNode(), true, false); + return node; + } + return this.parseStatementListItem(); + } + isExportDefaultSpecifier() { + const { + type + } = this.state; + if (tokenIsIdentifier(type)) { + if (type === 95 && !this.state.containsEsc || type === 100) { + return false; + } + if ((type === 130 || type === 129) && !this.state.containsEsc) { + const next = this.nextTokenStart(); + const nextChar = this.input.charCodeAt(next); + if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.input.startsWith("from", next)) { + this.expectOnePlugin(["flow", "typescript"]); + return false; + } + } + } else if (!this.match(65)) { + return false; + } + const next = this.nextTokenStart(); + const hasFrom = this.isUnparsedContextual(next, "from"); + if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) { + return true; + } + if (this.match(65) && hasFrom) { + const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4)); + return nextAfterFrom === 34 || nextAfterFrom === 39; + } + return false; + } + parseExportFrom(node, expect) { + if (this.eatContextual(98)) { + node.source = this.parseImportSource(); + this.checkExport(node); + this.maybeParseImportAttributes(node); + this.checkJSONModuleImport(node); + } else if (expect) { + this.unexpected(); + } + this.semicolon(); + } + shouldParseExportDeclaration() { + const { + type + } = this.state; + if (type === 26) { + this.expectOnePlugin(["decorators", "decorators-legacy"]); + if (this.hasPlugin("decorators")) { + if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) { + this.raise(Errors.DecoratorBeforeExport, this.state.startLoc); + } + return true; + } + } + if (this.isUsing()) { + this.raise(Errors.UsingDeclarationExport, this.state.startLoc); + return true; + } + if (this.isAwaitUsing()) { + this.raise(Errors.UsingDeclarationExport, this.state.startLoc); + return true; + } + return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction(); + } + checkExport(node, checkNames, isDefault, isFrom) { + if (checkNames) { + var _node$specifiers; + if (isDefault) { + this.checkDuplicateExports(node, "default"); + if (this.hasPlugin("exportDefaultFrom")) { + var _declaration$extra; + const declaration = node.declaration; + if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) { + this.raise(Errors.ExportDefaultFromAsIdentifier, declaration); + } + } + } else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) { + for (const specifier of node.specifiers) { + const { + exported + } = specifier; + const exportName = exported.type === "Identifier" ? exported.name : exported.value; + this.checkDuplicateExports(specifier, exportName); + if (!isFrom && specifier.local) { + const { + local + } = specifier; + if (local.type !== "Identifier") { + this.raise(Errors.ExportBindingIsString, specifier, { + localName: local.value, + exportName + }); + } else { + this.checkReservedWord(local.name, local.loc.start, true, false); + this.scope.checkLocalExport(local); + } + } + } + } else if (node.declaration) { + const decl = node.declaration; + if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") { + const { + id + } = decl; + if (!id) throw new Error("Assertion failure"); + this.checkDuplicateExports(node, id.name); + } else if (decl.type === "VariableDeclaration") { + for (const declaration of decl.declarations) { + this.checkDeclaration(declaration.id); + } + } + } + } + } + checkDeclaration(node) { + if (node.type === "Identifier") { + this.checkDuplicateExports(node, node.name); + } else if (node.type === "ObjectPattern") { + for (const prop of node.properties) { + this.checkDeclaration(prop); + } + } else if (node.type === "ArrayPattern") { + for (const elem of node.elements) { + if (elem) { + this.checkDeclaration(elem); + } + } + } else if (node.type === "ObjectProperty") { + this.checkDeclaration(node.value); + } else if (node.type === "RestElement") { + this.checkDeclaration(node.argument); + } else if (node.type === "AssignmentPattern") { + this.checkDeclaration(node.left); + } + } + checkDuplicateExports(node, exportName) { + if (this.exportedIdentifiers.has(exportName)) { + if (exportName === "default") { + this.raise(Errors.DuplicateDefaultExport, node); + } else { + this.raise(Errors.DuplicateExport, node, { + exportName + }); + } + } + this.exportedIdentifiers.add(exportName); + } + parseExportSpecifiers(isInTypeExport) { + const nodes = []; + let first = true; + this.expect(5); + while (!this.eat(8)) { + if (first) { + first = false; + } else { + this.expect(12); + if (this.eat(8)) break; + } + const isMaybeTypeOnly = this.isContextual(130); + const isString = this.match(134); + const node = this.startNode(); + node.local = this.parseModuleExportName(); + nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly)); + } + return nodes; + } + parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { + if (this.eatContextual(93)) { + node.exported = this.parseModuleExportName(); + } else if (isString) { + node.exported = this.cloneStringLiteral(node.local); + } else if (!node.exported) { + node.exported = this.cloneIdentifier(node.local); + } + return this.finishNode(node, "ExportSpecifier"); + } + parseModuleExportName() { + if (this.match(134)) { + const result = this.parseStringLiteral(this.state.value); + const surrogate = loneSurrogate.exec(result.value); + if (surrogate) { + this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, { + surrogateCharCode: surrogate[0].charCodeAt(0) + }); + } + return result; + } + return this.parseIdentifier(true); + } + isJSONModuleImport(node) { + if (node.assertions != null) { + return node.assertions.some(({ + key, + value + }) => { + return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type"); + }); + } + return false; + } + checkImportReflection(node) { + const { + specifiers + } = node; + const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null; + if (node.phase === "source") { + if (singleBindingType !== "ImportDefaultSpecifier") { + this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start); + } + } else if (node.phase === "defer") { + if (singleBindingType !== "ImportNamespaceSpecifier") { + this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start); + } + } else if (node.module) { + var _node$assertions; + if (singleBindingType !== "ImportDefaultSpecifier") { + this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start); + } + if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) { + this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start); + } + } + } + checkJSONModuleImport(node) { + if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") { + const { + specifiers + } = node; + if (specifiers != null) { + const nonDefaultNamedSpecifier = specifiers.find(specifier => { + let imported; + if (specifier.type === "ExportSpecifier") { + imported = specifier.local; + } else if (specifier.type === "ImportSpecifier") { + imported = specifier.imported; + } + if (imported !== undefined) { + return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default"; + } + }); + if (nonDefaultNamedSpecifier !== undefined) { + this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start); + } + } + } + } + isPotentialImportPhase(isExport) { + if (isExport) return false; + return this.isContextual(105) || this.isContextual(97) || this.isContextual(127); + } + applyImportPhase(node, isExport, phase, loc) { + if (isExport) { + return; + } + if (phase === "module") { + this.expectPlugin("importReflection", loc); + node.module = true; + } else if (this.hasPlugin("importReflection")) { + node.module = false; + } + if (phase === "source") { + this.expectPlugin("sourcePhaseImports", loc); + node.phase = "source"; + } else if (phase === "defer") { + this.expectPlugin("deferredImportEvaluation", loc); + node.phase = "defer"; + } else if (this.hasPlugin("sourcePhaseImports")) { + node.phase = null; + } + } + parseMaybeImportPhase(node, isExport) { + if (!this.isPotentialImportPhase(isExport)) { + this.applyImportPhase(node, isExport, null); + return null; + } + const phaseIdentifier = this.startNode(); + const phaseIdentifierName = this.parseIdentifierName(true); + const { + type + } = this.state; + const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12; + if (isImportPhase) { + this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start); + return null; + } else { + this.applyImportPhase(node, isExport, null); + return this.createIdentifier(phaseIdentifier, phaseIdentifierName); + } + } + isPrecedingIdImportPhase(phase) { + const { + type + } = this.state; + return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12; + } + parseImport(node) { + if (this.match(134)) { + return this.parseImportSourceAndAttributes(node); + } + return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false)); + } + parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) { + node.specifiers = []; + const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier); + const parseNext = !hasDefault || this.eat(12); + const hasStar = parseNext && this.maybeParseStarImportSpecifier(node); + if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node); + this.expectContextual(98); + return this.parseImportSourceAndAttributes(node); + } + parseImportSourceAndAttributes(node) { + var _node$specifiers2; + (_node$specifiers2 = node.specifiers) != null ? _node$specifiers2 : node.specifiers = []; + node.source = this.parseImportSource(); + this.maybeParseImportAttributes(node); + this.checkImportReflection(node); + this.checkJSONModuleImport(node); + this.semicolon(); + this.sawUnambiguousESM = true; + return this.finishNode(node, "ImportDeclaration"); + } + parseImportSource() { + if (!this.match(134)) this.unexpected(); + return this.parseExprAtom(); + } + parseImportSpecifierLocal(node, specifier, type) { + specifier.local = this.parseIdentifier(); + node.specifiers.push(this.finishImportSpecifier(specifier, type)); + } + finishImportSpecifier(specifier, type, bindingType = 8201) { + this.checkLVal(specifier.local, { + type + }, bindingType); + return this.finishNode(specifier, type); + } + parseImportAttributes() { + this.expect(5); + const attrs = []; + const attrNames = new Set(); + do { + if (this.match(8)) { + break; + } + const node = this.startNode(); + const keyName = this.state.value; + if (attrNames.has(keyName)) { + this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, { + key: keyName + }); + } + attrNames.add(keyName); + if (this.match(134)) { + node.key = this.parseStringLiteral(keyName); + } else { + node.key = this.parseIdentifier(true); + } + this.expect(14); + if (!this.match(134)) { + throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc); + } + node.value = this.parseStringLiteral(this.state.value); + attrs.push(this.finishNode(node, "ImportAttribute")); + } while (this.eat(12)); + this.expect(8); + return attrs; + } + parseModuleAttributes() { + const attrs = []; + const attributes = new Set(); + do { + const node = this.startNode(); + node.key = this.parseIdentifier(true); + if (node.key.name !== "type") { + this.raise(Errors.ModuleAttributeDifferentFromType, node.key); + } + if (attributes.has(node.key.name)) { + this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, { + key: node.key.name + }); + } + attributes.add(node.key.name); + this.expect(14); + if (!this.match(134)) { + throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc); + } + node.value = this.parseStringLiteral(this.state.value); + attrs.push(this.finishNode(node, "ImportAttribute")); + } while (this.eat(12)); + return attrs; + } + maybeParseImportAttributes(node) { + let attributes; + var useWith = false; + if (this.match(76)) { + if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) { + return; + } + this.next(); + if (this.hasPlugin("moduleAttributes")) { + attributes = this.parseModuleAttributes(); + this.addExtra(node, "deprecatedWithLegacySyntax", true); + } else { + attributes = this.parseImportAttributes(); + } + useWith = true; + } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) { + if (!this.hasPlugin("deprecatedImportAssert") && !this.hasPlugin("importAssertions")) { + this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc); + } + if (!this.hasPlugin("importAssertions")) { + this.addExtra(node, "deprecatedAssertSyntax", true); + } + this.next(); + attributes = this.parseImportAttributes(); + } else { + attributes = []; + } + if (!useWith && this.hasPlugin("importAssertions")) { + node.assertions = attributes; + } else { + node.attributes = attributes; + } + } + maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) { + if (maybeDefaultIdentifier) { + const specifier = this.startNodeAtNode(maybeDefaultIdentifier); + specifier.local = maybeDefaultIdentifier; + node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier")); + return true; + } else if (tokenIsKeywordOrIdentifier(this.state.type)) { + this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier"); + return true; + } + return false; + } + maybeParseStarImportSpecifier(node) { + if (this.match(55)) { + const specifier = this.startNode(); + this.next(); + this.expectContextual(93); + this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier"); + return true; + } + return false; + } + parseNamedImportSpecifiers(node) { + let first = true; + this.expect(5); + while (!this.eat(8)) { + if (first) { + first = false; + } else { + if (this.eat(14)) { + throw this.raise(Errors.DestructureNamedImport, this.state.startLoc); + } + this.expect(12); + if (this.eat(8)) break; + } + const specifier = this.startNode(); + const importedIsString = this.match(134); + const isMaybeTypeOnly = this.isContextual(130); + specifier.imported = this.parseModuleExportName(); + const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined); + node.specifiers.push(importSpecifier); + } + } + parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { + if (this.eatContextual(93)) { + specifier.local = this.parseIdentifier(); + } else { + const { + imported + } = specifier; + if (importedIsString) { + throw this.raise(Errors.ImportBindingIsString, specifier, { + importName: imported.value + }); + } + this.checkReservedWord(imported.name, specifier.loc.start, true, true); + if (!specifier.local) { + specifier.local = this.cloneIdentifier(imported); + } + } + return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType); + } + isThisParam(param) { + return param.type === "Identifier" && param.name === "this"; + } +} +class Parser extends StatementParser { + constructor(options, input, pluginsMap) { + const normalizedOptions = getOptions(options); + super(normalizedOptions, input); + this.options = normalizedOptions; + this.initializeScopes(); + this.plugins = pluginsMap; + this.filename = normalizedOptions.sourceFilename; + this.startIndex = normalizedOptions.startIndex; + let optionFlags = 0; + if (normalizedOptions.allowAwaitOutsideFunction) { + optionFlags |= 1; + } + if (normalizedOptions.allowReturnOutsideFunction) { + optionFlags |= 2; + } + if (normalizedOptions.allowImportExportEverywhere) { + optionFlags |= 8; + } + if (normalizedOptions.allowSuperOutsideMethod) { + optionFlags |= 16; + } + if (normalizedOptions.allowUndeclaredExports) { + optionFlags |= 64; + } + if (normalizedOptions.allowNewTargetOutsideFunction) { + optionFlags |= 4; + } + if (normalizedOptions.allowYieldOutsideFunction) { + optionFlags |= 32; + } + if (normalizedOptions.ranges) { + optionFlags |= 128; + } + if (normalizedOptions.tokens) { + optionFlags |= 256; + } + if (normalizedOptions.createImportExpressions) { + optionFlags |= 512; + } + if (normalizedOptions.createParenthesizedExpressions) { + optionFlags |= 1024; + } + if (normalizedOptions.errorRecovery) { + optionFlags |= 2048; + } + if (normalizedOptions.attachComment) { + optionFlags |= 4096; + } + if (normalizedOptions.annexB) { + optionFlags |= 8192; + } + this.optionFlags = optionFlags; + } + getScopeHandler() { + return ScopeHandler; + } + parse() { + this.enterInitialScopes(); + const file = this.startNode(); + const program = this.startNode(); + this.nextToken(); + file.errors = null; + const result = this.parseTopLevel(file, program); + result.errors = this.state.errors; + result.comments.length = this.state.commentsLen; + return result; + } +} +function parse(input, options) { + var _options; + if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") { + options = Object.assign({}, options); + try { + options.sourceType = "module"; + const parser = getParser(options, input); + const ast = parser.parse(); + if (parser.sawUnambiguousESM) { + return ast; + } + if (parser.ambiguousScriptDifferentAst) { + try { + options.sourceType = "script"; + return getParser(options, input).parse(); + } catch (_unused) {} + } else { + ast.program.sourceType = "script"; + } + return ast; + } catch (moduleError) { + try { + options.sourceType = "script"; + return getParser(options, input).parse(); + } catch (_unused2) {} + throw moduleError; + } + } else { + return getParser(options, input).parse(); + } +} +function parseExpression(input, options) { + const parser = getParser(options, input); + if (parser.options.strictMode) { + parser.state.strict = true; + } + return parser.getExpression(); +} +function generateExportedTokenTypes(internalTokenTypes) { + const tokenTypes = {}; + for (const typeName of Object.keys(internalTokenTypes)) { + tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]); + } + return tokenTypes; +} +const tokTypes = generateExportedTokenTypes(tt); +function getParser(options, input) { + let cls = Parser; + const pluginsMap = new Map(); + if (options != null && options.plugins) { + for (const plugin of options.plugins) { + let name, opts; + if (typeof plugin === "string") { + name = plugin; + } else { + [name, opts] = plugin; + } + if (!pluginsMap.has(name)) { + pluginsMap.set(name, opts || {}); + } + } + validatePlugins(pluginsMap); + cls = getParserClass(pluginsMap); + } + return new cls(options, input, pluginsMap); +} +const parserClassCache = new Map(); +function getParserClass(pluginsMap) { + const pluginList = []; + for (const name of mixinPluginNames) { + if (pluginsMap.has(name)) { + pluginList.push(name); + } + } + const key = pluginList.join("|"); + let cls = parserClassCache.get(key); + if (!cls) { + cls = Parser; + for (const plugin of pluginList) { + cls = mixinPlugins[plugin](cls); + } + parserClassCache.set(key, cls); + } + return cls; +} +exports.parse = parse; +exports.parseExpression = parseExpression; +exports.tokTypes = tokTypes; +//# sourceMappingURL=index.js.map + +}, function(modId) {var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509018); +})() +//miniprogram-npm-outsideDeps=[] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/parser/index.js.map b/miniapp/miniprogram_npm/@babel/parser/index.js.map new file mode 100644 index 0000000..98fc0e1 --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/parser/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\nfunction _objectWithoutPropertiesLoose(r, e) {\n if (null == r) return {};\n var t = {};\n for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n if (-1 !== e.indexOf(n)) continue;\n t[n] = r[n];\n }\n return t;\n}\nclass Position {\n constructor(line, col, index) {\n this.line = void 0;\n this.column = void 0;\n this.index = void 0;\n this.line = line;\n this.column = col;\n this.index = index;\n }\n}\nclass SourceLocation {\n constructor(start, end) {\n this.start = void 0;\n this.end = void 0;\n this.filename = void 0;\n this.identifierName = void 0;\n this.start = start;\n this.end = end;\n }\n}\nfunction createPositionWithColumnOffset(position, columnOffset) {\n const {\n line,\n column,\n index\n } = position;\n return new Position(line, column + columnOffset, index + columnOffset);\n}\nconst code = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\";\nvar ModuleErrors = {\n ImportMetaOutsideModule: {\n message: `import.meta may appear only with 'sourceType: \"module\"'`,\n code\n },\n ImportOutsideModule: {\n message: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n code\n }\n};\nconst NodeDescriptions = {\n ArrayPattern: \"array destructuring pattern\",\n AssignmentExpression: \"assignment expression\",\n AssignmentPattern: \"assignment expression\",\n ArrowFunctionExpression: \"arrow function expression\",\n ConditionalExpression: \"conditional expression\",\n CatchClause: \"catch clause\",\n ForOfStatement: \"for-of statement\",\n ForInStatement: \"for-in statement\",\n ForStatement: \"for-loop\",\n FormalParameters: \"function parameter list\",\n Identifier: \"identifier\",\n ImportSpecifier: \"import specifier\",\n ImportDefaultSpecifier: \"import default specifier\",\n ImportNamespaceSpecifier: \"import namespace specifier\",\n ObjectPattern: \"object destructuring pattern\",\n ParenthesizedExpression: \"parenthesized expression\",\n RestElement: \"rest element\",\n UpdateExpression: {\n true: \"prefix operation\",\n false: \"postfix operation\"\n },\n VariableDeclarator: \"variable declaration\",\n YieldExpression: \"yield expression\"\n};\nconst toNodeDescription = node => node.type === \"UpdateExpression\" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];\nvar StandardErrors = {\n AccessorIsGenerator: ({\n kind\n }) => `A ${kind}ter cannot be a generator.`,\n ArgumentsInClass: \"'arguments' is only allowed in functions and class methods.\",\n AsyncFunctionInSingleStatementContext: \"Async functions can only be declared at the top level or inside a block.\",\n AwaitBindingIdentifier: \"Can not use 'await' as identifier inside an async function.\",\n AwaitBindingIdentifierInStaticBlock: \"Can not use 'await' as identifier inside a static block.\",\n AwaitExpressionFormalParameter: \"'await' is not allowed in async function parameters.\",\n AwaitUsingNotInAsyncContext: \"'await using' is only allowed within async functions and at the top levels of modules.\",\n AwaitNotInAsyncContext: \"'await' is only allowed within async functions and at the top levels of modules.\",\n BadGetterArity: \"A 'get' accessor must not have any formal parameters.\",\n BadSetterArity: \"A 'set' accessor must have exactly one formal parameter.\",\n BadSetterRestParameter: \"A 'set' accessor function argument must not be a rest parameter.\",\n ConstructorClassField: \"Classes may not have a field named 'constructor'.\",\n ConstructorClassPrivateField: \"Classes may not have a private field named '#constructor'.\",\n ConstructorIsAccessor: \"Class constructor may not be an accessor.\",\n ConstructorIsAsync: \"Constructor can't be an async function.\",\n ConstructorIsGenerator: \"Constructor can't be a generator.\",\n DeclarationMissingInitializer: ({\n kind\n }) => `Missing initializer in ${kind} declaration.`,\n DecoratorArgumentsOutsideParentheses: \"Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.\",\n DecoratorBeforeExport: \"Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.\",\n DecoratorsBeforeAfterExport: \"Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.\",\n DecoratorConstructor: \"Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?\",\n DecoratorExportClass: \"Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.\",\n DecoratorSemicolon: \"Decorators must not be followed by a semicolon.\",\n DecoratorStaticBlock: \"Decorators can't be used with a static block.\",\n DeferImportRequiresNamespace: 'Only `import defer * as x from \"./module\"` is valid.',\n DeletePrivateField: \"Deleting a private field is not allowed.\",\n DestructureNamedImport: \"ES2015 named imports do not destructure. Use another statement for destructuring after the import.\",\n DuplicateConstructor: \"Duplicate constructor in the same class.\",\n DuplicateDefaultExport: \"Only one default export allowed per module.\",\n DuplicateExport: ({\n exportName\n }) => `\\`${exportName}\\` has already been exported. Exported identifiers must be unique.`,\n DuplicateProto: \"Redefinition of __proto__ property.\",\n DuplicateRegExpFlags: \"Duplicate regular expression flag.\",\n ElementAfterRest: \"Rest element must be last element.\",\n EscapedCharNotAnIdentifier: \"Invalid Unicode escape.\",\n ExportBindingIsString: ({\n localName,\n exportName\n }) => `A string literal cannot be used as an exported binding without \\`from\\`.\\n- Did you mean \\`export { '${localName}' as '${exportName}' } from 'some-module'\\`?`,\n ExportDefaultFromAsIdentifier: \"'from' is not allowed as an identifier after 'export default'.\",\n ForInOfLoopInitializer: ({\n type\n }) => `'${type === \"ForInStatement\" ? \"for-in\" : \"for-of\"}' loop variable declaration may not have an initializer.`,\n ForInUsing: \"For-in loop may not start with 'using' declaration.\",\n ForOfAsync: \"The left-hand side of a for-of loop may not be 'async'.\",\n ForOfLet: \"The left-hand side of a for-of loop may not start with 'let'.\",\n GeneratorInSingleStatementContext: \"Generators can only be declared at the top level or inside a block.\",\n IllegalBreakContinue: ({\n type\n }) => `Unsyntactic ${type === \"BreakStatement\" ? \"break\" : \"continue\"}.`,\n IllegalLanguageModeDirective: \"Illegal 'use strict' directive in function with non-simple parameter list.\",\n IllegalReturn: \"'return' outside of function.\",\n ImportAttributesUseAssert: \"The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.\",\n ImportBindingIsString: ({\n importName\n }) => `A string literal cannot be used as an imported binding.\\n- Did you mean \\`import { \"${importName}\" as foo }\\`?`,\n ImportCallArity: `\\`import()\\` requires exactly one or two arguments.`,\n ImportCallNotNewExpression: \"Cannot use new with import(...).\",\n ImportCallSpreadArgument: \"`...` is not allowed in `import()`.\",\n ImportJSONBindingNotDefault: \"A JSON module can only be imported with `default`.\",\n ImportReflectionHasAssertion: \"`import module x` cannot have assertions.\",\n ImportReflectionNotBinding: 'Only `import module x from \"./module\"` is valid.',\n IncompatibleRegExpUVFlags: \"The 'u' and 'v' regular expression flags cannot be enabled at the same time.\",\n InvalidBigIntLiteral: \"Invalid BigIntLiteral.\",\n InvalidCodePoint: \"Code point out of bounds.\",\n InvalidCoverDiscardElement: \"'void' must be followed by an expression when not used in a binding position.\",\n InvalidCoverInitializedName: \"Invalid shorthand property initializer.\",\n InvalidDecimal: \"Invalid decimal.\",\n InvalidDigit: ({\n radix\n }) => `Expected number in radix ${radix}.`,\n InvalidEscapeSequence: \"Bad character escape sequence.\",\n InvalidEscapeSequenceTemplate: \"Invalid escape sequence in template.\",\n InvalidEscapedReservedWord: ({\n reservedWord\n }) => `Escape sequence in keyword ${reservedWord}.`,\n InvalidIdentifier: ({\n identifierName\n }) => `Invalid identifier ${identifierName}.`,\n InvalidLhs: ({\n ancestor\n }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n InvalidLhsBinding: ({\n ancestor\n }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,\n InvalidLhsOptionalChaining: ({\n ancestor\n }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,\n InvalidNumber: \"Invalid number.\",\n InvalidOrMissingExponent: \"Floating-point numbers require a valid exponent after the 'e'.\",\n InvalidOrUnexpectedToken: ({\n unexpected\n }) => `Unexpected character '${unexpected}'.`,\n InvalidParenthesizedAssignment: \"Invalid parenthesized assignment pattern.\",\n InvalidPrivateFieldResolution: ({\n identifierName\n }) => `Private name #${identifierName} is not defined.`,\n InvalidPropertyBindingPattern: \"Binding member expression.\",\n InvalidRecordProperty: \"Only properties and spread elements are allowed in record definitions.\",\n InvalidRestAssignmentPattern: \"Invalid rest operator's argument.\",\n LabelRedeclaration: ({\n labelName\n }) => `Label '${labelName}' is already declared.`,\n LetInLexicalBinding: \"'let' is disallowed as a lexically bound name.\",\n LineTerminatorBeforeArrow: \"No line break is allowed before '=>'.\",\n MalformedRegExpFlags: \"Invalid regular expression flag.\",\n MissingClassName: \"A class name is required.\",\n MissingEqInAssignment: \"Only '=' operator can be used for specifying default value.\",\n MissingSemicolon: \"Missing semicolon.\",\n MissingPlugin: ({\n missingPlugin\n }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(\", \")}.`,\n MissingOneOfPlugins: ({\n missingPlugin\n }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(\", \")}.`,\n MissingUnicodeEscape: \"Expecting Unicode escape sequence \\\\uXXXX.\",\n MixingCoalesceWithLogical: \"Nullish coalescing operator(??) requires parens when mixing with logical operators.\",\n ModuleAttributeDifferentFromType: \"The only accepted module attribute is `type`.\",\n ModuleAttributeInvalidValue: \"Only string literals are allowed as module attribute values.\",\n ModuleAttributesWithDuplicateKeys: ({\n key\n }) => `Duplicate key \"${key}\" is not allowed in module attributes.`,\n ModuleExportNameHasLoneSurrogate: ({\n surrogateCharCode\n }) => `An export name cannot include a lone surrogate, found '\\\\u${surrogateCharCode.toString(16)}'.`,\n ModuleExportUndefined: ({\n localName\n }) => `Export '${localName}' is not defined.`,\n MultipleDefaultsInSwitch: \"Multiple default clauses.\",\n NewlineAfterThrow: \"Illegal newline after throw.\",\n NoCatchOrFinally: \"Missing catch or finally clause.\",\n NumberIdentifier: \"Identifier directly after number.\",\n NumericSeparatorInEscapeSequence: \"Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.\",\n ObsoleteAwaitStar: \"'await*' has been removed from the async functions proposal. Use Promise.all() instead.\",\n OptionalChainingNoNew: \"Constructors in/after an Optional Chain are not allowed.\",\n OptionalChainingNoTemplate: \"Tagged Template Literals are not allowed in optionalChain.\",\n OverrideOnConstructor: \"'override' modifier cannot appear on a constructor declaration.\",\n ParamDupe: \"Argument name clash.\",\n PatternHasAccessor: \"Object pattern can't contain getter or setter.\",\n PatternHasMethod: \"Object pattern can't contain methods.\",\n PrivateInExpectedIn: ({\n identifierName\n }) => `Private names are only allowed in property accesses (\\`obj.#${identifierName}\\`) or in \\`in\\` expressions (\\`#${identifierName} in obj\\`).`,\n PrivateNameRedeclaration: ({\n identifierName\n }) => `Duplicate private name #${identifierName}.`,\n RecordExpressionBarIncorrectEndSyntaxType: \"Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n RecordExpressionBarIncorrectStartSyntaxType: \"Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n RecordExpressionHashIncorrectStartSyntaxType: \"Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.\",\n RecordNoProto: \"'__proto__' is not allowed in Record expressions.\",\n RestTrailingComma: \"Unexpected trailing comma after rest element.\",\n SloppyFunction: \"In non-strict mode code, functions can only be declared at top level or inside a block.\",\n SloppyFunctionAnnexB: \"In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.\",\n SourcePhaseImportRequiresDefault: 'Only `import source x from \"./module\"` is valid.',\n StaticPrototype: \"Classes may not have static property named prototype.\",\n SuperNotAllowed: \"`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?\",\n SuperPrivateField: \"Private fields can't be accessed on super.\",\n TrailingDecorator: \"Decorators must be attached to a class element.\",\n TupleExpressionBarIncorrectEndSyntaxType: \"Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n TupleExpressionBarIncorrectStartSyntaxType: \"Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.\",\n TupleExpressionHashIncorrectStartSyntaxType: \"Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.\",\n UnexpectedArgumentPlaceholder: \"Unexpected argument placeholder.\",\n UnexpectedAwaitAfterPipelineBody: 'Unexpected \"await\" after pipeline body; await must have parentheses in minimal proposal.',\n UnexpectedDigitAfterHash: \"Unexpected digit after hash token.\",\n UnexpectedImportExport: \"'import' and 'export' may only appear at the top level.\",\n UnexpectedKeyword: ({\n keyword\n }) => `Unexpected keyword '${keyword}'.`,\n UnexpectedLeadingDecorator: \"Leading decorators must be attached to a class declaration.\",\n UnexpectedLexicalDeclaration: \"Lexical declaration cannot appear in a single-statement context.\",\n UnexpectedNewTarget: \"`new.target` can only be used in functions or class properties.\",\n UnexpectedNumericSeparator: \"A numeric separator is only allowed between two digits.\",\n UnexpectedPrivateField: \"Unexpected private name.\",\n UnexpectedReservedWord: ({\n reservedWord\n }) => `Unexpected reserved word '${reservedWord}'.`,\n UnexpectedSuper: \"'super' is only allowed in object methods and classes.\",\n UnexpectedToken: ({\n expected,\n unexpected\n }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : \"\"}${expected ? `, expected \"${expected}\"` : \"\"}`,\n UnexpectedTokenUnaryExponentiation: \"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.\",\n UnexpectedUsingDeclaration: \"Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.\",\n UnexpectedVoidPattern: \"Unexpected void binding.\",\n UnsupportedBind: \"Binding should be performed on object property.\",\n UnsupportedDecoratorExport: \"A decorated export must export a class declaration.\",\n UnsupportedDefaultExport: \"Only expressions, functions or classes are allowed as the `default` export.\",\n UnsupportedImport: \"`import` can only be used in `import()` or `import.meta`.\",\n UnsupportedMetaProperty: ({\n target,\n onlyValidPropertyName\n }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,\n UnsupportedParameterDecorator: \"Decorators cannot be used to decorate parameters.\",\n UnsupportedPropertyDecorator: \"Decorators cannot be used to decorate object literal properties.\",\n UnsupportedSuper: \"'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).\",\n UnterminatedComment: \"Unterminated comment.\",\n UnterminatedRegExp: \"Unterminated regular expression.\",\n UnterminatedString: \"Unterminated string constant.\",\n UnterminatedTemplate: \"Unterminated template.\",\n UsingDeclarationExport: \"Using declaration cannot be exported.\",\n UsingDeclarationHasBindingPattern: \"Using declaration cannot have destructuring patterns.\",\n VarRedeclaration: ({\n identifierName\n }) => `Identifier '${identifierName}' has already been declared.`,\n VoidPatternCatchClauseParam: \"A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.\",\n VoidPatternInitializer: \"A void binding may not have an initializer.\",\n YieldBindingIdentifier: \"Can not use 'yield' as identifier inside a generator.\",\n YieldInParameter: \"Yield expression is not allowed in formal parameters.\",\n YieldNotInGeneratorFunction: \"'yield' is only allowed within generator functions.\",\n ZeroDigitNumericSeparator: \"Numeric separator can not be used after leading 0.\"\n};\nvar StrictModeErrors = {\n StrictDelete: \"Deleting local variable in strict mode.\",\n StrictEvalArguments: ({\n referenceName\n }) => `Assigning to '${referenceName}' in strict mode.`,\n StrictEvalArgumentsBinding: ({\n bindingName\n }) => `Binding '${bindingName}' in strict mode.`,\n StrictFunction: \"In strict mode code, functions can only be declared at top level or inside a block.\",\n StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'.\",\n StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n StrictWith: \"'with' in strict mode.\"\n};\nvar ParseExpressionErrors = {\n ParseExpressionEmptyInput: \"Unexpected parseExpression() input: The input is empty or contains only comments.\",\n ParseExpressionExpectsEOF: ({\n unexpected\n }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \\`${String.fromCodePoint(unexpected)}\\`.`\n};\nconst UnparenthesizedPipeBodyDescriptions = new Set([\"ArrowFunctionExpression\", \"AssignmentExpression\", \"ConditionalExpression\", \"YieldExpression\"]);\nvar PipelineOperatorErrors = Object.assign({\n PipeBodyIsTighter: \"Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.\",\n PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n PipeTopicUnbound: \"Topic reference is unbound; it must be inside a pipe body.\",\n PipeTopicUnconfiguredToken: ({\n token\n }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"${token}\" }.`,\n PipeTopicUnused: \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n PipeUnparenthesizedBody: ({\n type\n }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n type\n })}; please wrap it in parentheses.`\n}, {\n PipelineBodyNoArrow: 'Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized.',\n PipelineBodySequenceExpression: \"Pipeline body may not be a comma-separated sequence expression.\",\n PipelineHeadSequenceExpression: \"Pipeline head should not be a comma-separated sequence expression.\",\n PipelineTopicUnused: \"Pipeline is in topic style but does not use topic reference.\",\n PrimaryTopicNotAllowed: \"Topic reference was used in a lexical context without topic binding.\",\n PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.'\n});\nconst _excluded = [\"message\"];\nfunction defineHidden(obj, key, value) {\n Object.defineProperty(obj, key, {\n enumerable: false,\n configurable: true,\n value\n });\n}\nfunction toParseErrorConstructor({\n toMessage,\n code,\n reasonCode,\n syntaxPlugin\n}) {\n const hasMissingPlugin = reasonCode === \"MissingPlugin\" || reasonCode === \"MissingOneOfPlugins\";\n const oldReasonCodes = {\n AccessorCannotDeclareThisParameter: \"AccesorCannotDeclareThisParameter\",\n AccessorCannotHaveTypeParameters: \"AccesorCannotHaveTypeParameters\",\n ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: \"ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference\",\n SetAccessorCannotHaveOptionalParameter: \"SetAccesorCannotHaveOptionalParameter\",\n SetAccessorCannotHaveRestParameter: \"SetAccesorCannotHaveRestParameter\",\n SetAccessorCannotHaveReturnType: \"SetAccesorCannotHaveReturnType\"\n };\n if (oldReasonCodes[reasonCode]) {\n reasonCode = oldReasonCodes[reasonCode];\n }\n return function constructor(loc, details) {\n const error = new SyntaxError();\n error.code = code;\n error.reasonCode = reasonCode;\n error.loc = loc;\n error.pos = loc.index;\n error.syntaxPlugin = syntaxPlugin;\n if (hasMissingPlugin) {\n error.missingPlugin = details.missingPlugin;\n }\n defineHidden(error, \"clone\", function clone(overrides = {}) {\n var _overrides$loc;\n const {\n line,\n column,\n index\n } = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc;\n return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details));\n });\n defineHidden(error, \"details\", details);\n Object.defineProperty(error, \"message\", {\n configurable: true,\n get() {\n const message = `${toMessage(details)} (${loc.line}:${loc.column})`;\n this.message = message;\n return message;\n },\n set(value) {\n Object.defineProperty(this, \"message\", {\n value,\n writable: true\n });\n }\n });\n return error;\n };\n}\nfunction ParseErrorEnum(argument, syntaxPlugin) {\n if (Array.isArray(argument)) {\n return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);\n }\n const ParseErrorConstructors = {};\n for (const reasonCode of Object.keys(argument)) {\n const template = argument[reasonCode];\n const _ref = typeof template === \"string\" ? {\n message: () => template\n } : typeof template === \"function\" ? {\n message: template\n } : template,\n {\n message\n } = _ref,\n rest = _objectWithoutPropertiesLoose(_ref, _excluded);\n const toMessage = typeof message === \"string\" ? () => message : message;\n ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({\n code: \"BABEL_PARSER_SYNTAX_ERROR\",\n reasonCode,\n toMessage\n }, syntaxPlugin ? {\n syntaxPlugin\n } : {}, rest));\n }\n return ParseErrorConstructors;\n}\nconst Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));\nfunction createDefaultOptions() {\n return {\n sourceType: \"script\",\n sourceFilename: undefined,\n startIndex: 0,\n startColumn: 0,\n startLine: 1,\n allowAwaitOutsideFunction: false,\n allowReturnOutsideFunction: false,\n allowNewTargetOutsideFunction: false,\n allowImportExportEverywhere: false,\n allowSuperOutsideMethod: false,\n allowUndeclaredExports: false,\n allowYieldOutsideFunction: false,\n plugins: [],\n strictMode: undefined,\n ranges: false,\n tokens: false,\n createImportExpressions: false,\n createParenthesizedExpressions: false,\n errorRecovery: false,\n attachComment: true,\n annexB: true\n };\n}\nfunction getOptions(opts) {\n const options = createDefaultOptions();\n if (opts == null) {\n return options;\n }\n if (opts.annexB != null && opts.annexB !== false) {\n throw new Error(\"The `annexB` option can only be set to `false`.\");\n }\n for (const key of Object.keys(options)) {\n if (opts[key] != null) options[key] = opts[key];\n }\n if (options.startLine === 1) {\n if (opts.startIndex == null && options.startColumn > 0) {\n options.startIndex = options.startColumn;\n } else if (opts.startColumn == null && options.startIndex > 0) {\n options.startColumn = options.startIndex;\n }\n } else if (opts.startColumn == null || opts.startIndex == null) {\n if (opts.startIndex != null) {\n throw new Error(\"With a `startLine > 1` you must also specify `startIndex` and `startColumn`.\");\n }\n }\n if (options.sourceType === \"commonjs\") {\n if (opts.allowAwaitOutsideFunction != null) {\n throw new Error(\"The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`.\");\n }\n if (opts.allowReturnOutsideFunction != null) {\n throw new Error(\"`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`.\");\n }\n if (opts.allowNewTargetOutsideFunction != null) {\n throw new Error(\"`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`.\");\n }\n }\n return options;\n}\nconst {\n defineProperty\n} = Object;\nconst toUnenumerable = (object, key) => {\n if (object) {\n defineProperty(object, key, {\n enumerable: false,\n value: object[key]\n });\n }\n};\nfunction toESTreeLocation(node) {\n toUnenumerable(node.loc.start, \"index\");\n toUnenumerable(node.loc.end, \"index\");\n return node;\n}\nvar estree = superClass => class ESTreeParserMixin extends superClass {\n parse() {\n const file = toESTreeLocation(super.parse());\n if (this.optionFlags & 256) {\n file.tokens = file.tokens.map(toESTreeLocation);\n }\n return file;\n }\n parseRegExpLiteral({\n pattern,\n flags\n }) {\n let regex = null;\n try {\n regex = new RegExp(pattern, flags);\n } catch (_) {}\n const node = this.estreeParseLiteral(regex);\n node.regex = {\n pattern,\n flags\n };\n return node;\n }\n parseBigIntLiteral(value) {\n let bigInt;\n try {\n bigInt = BigInt(value);\n } catch (_unused) {\n bigInt = null;\n }\n const node = this.estreeParseLiteral(bigInt);\n node.bigint = String(node.value || value);\n return node;\n }\n parseDecimalLiteral(value) {\n const decimal = null;\n const node = this.estreeParseLiteral(decimal);\n node.decimal = String(node.value || value);\n return node;\n }\n estreeParseLiteral(value) {\n return this.parseLiteral(value, \"Literal\");\n }\n parseStringLiteral(value) {\n return this.estreeParseLiteral(value);\n }\n parseNumericLiteral(value) {\n return this.estreeParseLiteral(value);\n }\n parseNullLiteral() {\n return this.estreeParseLiteral(null);\n }\n parseBooleanLiteral(value) {\n return this.estreeParseLiteral(value);\n }\n estreeParseChainExpression(node, endLoc) {\n const chain = this.startNodeAtNode(node);\n chain.expression = node;\n return this.finishNodeAt(chain, \"ChainExpression\", endLoc);\n }\n directiveToStmt(directive) {\n const expression = directive.value;\n delete directive.value;\n this.castNodeTo(expression, \"Literal\");\n expression.raw = expression.extra.raw;\n expression.value = expression.extra.expressionValue;\n const stmt = this.castNodeTo(directive, \"ExpressionStatement\");\n stmt.expression = expression;\n stmt.directive = expression.extra.rawValue;\n delete expression.extra;\n return stmt;\n }\n fillOptionalPropertiesForTSESLint(node) {}\n cloneEstreeStringLiteral(node) {\n const {\n start,\n end,\n loc,\n range,\n raw,\n value\n } = node;\n const cloned = Object.create(node.constructor.prototype);\n cloned.type = \"Literal\";\n cloned.start = start;\n cloned.end = end;\n cloned.loc = loc;\n cloned.range = range;\n cloned.raw = raw;\n cloned.value = value;\n return cloned;\n }\n initFunction(node, isAsync) {\n super.initFunction(node, isAsync);\n node.expression = false;\n }\n checkDeclaration(node) {\n if (node != null && this.isObjectProperty(node)) {\n this.checkDeclaration(node.value);\n } else {\n super.checkDeclaration(node);\n }\n }\n getObjectOrClassMethodParams(method) {\n return method.value.params;\n }\n isValidDirective(stmt) {\n var _stmt$expression$extr;\n return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"Literal\" && typeof stmt.expression.value === \"string\" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);\n }\n parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {\n super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);\n const directiveStatements = node.directives.map(d => this.directiveToStmt(d));\n node.body = directiveStatements.concat(node.body);\n delete node.directives;\n }\n parsePrivateName() {\n const node = super.parsePrivateName();\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return node;\n }\n return this.convertPrivateNameToPrivateIdentifier(node);\n }\n convertPrivateNameToPrivateIdentifier(node) {\n const name = super.getPrivateNameSV(node);\n delete node.id;\n node.name = name;\n return this.castNodeTo(node, \"PrivateIdentifier\");\n }\n isPrivateName(node) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return super.isPrivateName(node);\n }\n return node.type === \"PrivateIdentifier\";\n }\n getPrivateNameSV(node) {\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return super.getPrivateNameSV(node);\n }\n return node.name;\n }\n parseLiteral(value, type) {\n const node = super.parseLiteral(value, type);\n node.raw = node.extra.raw;\n delete node.extra;\n return node;\n }\n parseFunctionBody(node, allowExpression, isMethod = false) {\n super.parseFunctionBody(node, allowExpression, isMethod);\n node.expression = node.body.type !== \"BlockStatement\";\n }\n parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {\n let funcNode = this.startNode();\n funcNode.kind = node.kind;\n funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);\n delete funcNode.kind;\n const {\n typeParameters\n } = node;\n if (typeParameters) {\n delete node.typeParameters;\n funcNode.typeParameters = typeParameters;\n this.resetStartLocationFromNode(funcNode, typeParameters);\n }\n const valueNode = this.castNodeTo(funcNode, \"FunctionExpression\");\n node.value = valueNode;\n if (type === \"ClassPrivateMethod\") {\n node.computed = false;\n }\n if (type === \"ObjectMethod\") {\n if (node.kind === \"method\") {\n node.kind = \"init\";\n }\n node.shorthand = false;\n return this.finishNode(node, \"Property\");\n } else {\n return this.finishNode(node, \"MethodDefinition\");\n }\n }\n nameIsConstructor(key) {\n if (key.type === \"Literal\") return key.value === \"constructor\";\n return super.nameIsConstructor(key);\n }\n parseClassProperty(...args) {\n const propertyNode = super.parseClassProperty(...args);\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return propertyNode;\n }\n this.castNodeTo(propertyNode, \"PropertyDefinition\");\n return propertyNode;\n }\n parseClassPrivateProperty(...args) {\n const propertyNode = super.parseClassPrivateProperty(...args);\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return propertyNode;\n }\n this.castNodeTo(propertyNode, \"PropertyDefinition\");\n propertyNode.computed = false;\n return propertyNode;\n }\n parseClassAccessorProperty(node) {\n const accessorPropertyNode = super.parseClassAccessorProperty(node);\n if (!this.getPluginOption(\"estree\", \"classFeatures\")) {\n return accessorPropertyNode;\n }\n if (accessorPropertyNode.abstract && this.hasPlugin(\"typescript\")) {\n delete accessorPropertyNode.abstract;\n this.castNodeTo(accessorPropertyNode, \"TSAbstractAccessorProperty\");\n } else {\n this.castNodeTo(accessorPropertyNode, \"AccessorProperty\");\n }\n return accessorPropertyNode;\n }\n parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {\n const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);\n if (node) {\n node.kind = \"init\";\n this.castNodeTo(node, \"Property\");\n }\n return node;\n }\n finishObjectProperty(node) {\n node.kind = \"init\";\n return this.finishNode(node, \"Property\");\n }\n isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {\n return type === \"Property\" ? \"value\" : super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding);\n }\n isAssignable(node, isBinding) {\n if (node != null && this.isObjectProperty(node)) {\n return this.isAssignable(node.value, isBinding);\n }\n return super.isAssignable(node, isBinding);\n }\n toAssignable(node, isLHS = false) {\n if (node != null && this.isObjectProperty(node)) {\n const {\n key,\n value\n } = node;\n if (this.isPrivateName(key)) {\n this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);\n }\n this.toAssignable(value, isLHS);\n } else {\n super.toAssignable(node, isLHS);\n }\n }\n toAssignableObjectExpressionProp(prop, isLast, isLHS) {\n if (prop.type === \"Property\" && (prop.kind === \"get\" || prop.kind === \"set\")) {\n this.raise(Errors.PatternHasAccessor, prop.key);\n } else if (prop.type === \"Property\" && prop.method) {\n this.raise(Errors.PatternHasMethod, prop.key);\n } else {\n super.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n }\n }\n finishCallExpression(unfinished, optional) {\n const node = super.finishCallExpression(unfinished, optional);\n if (node.callee.type === \"Import\") {\n var _ref, _ref2;\n this.castNodeTo(node, \"ImportExpression\");\n node.source = node.arguments[0];\n node.options = (_ref = node.arguments[1]) != null ? _ref : null;\n node.attributes = (_ref2 = node.arguments[1]) != null ? _ref2 : null;\n delete node.arguments;\n delete node.callee;\n } else if (node.type === \"OptionalCallExpression\") {\n this.castNodeTo(node, \"CallExpression\");\n } else {\n node.optional = false;\n }\n return node;\n }\n toReferencedArguments(node) {\n if (node.type === \"ImportExpression\") {\n return;\n }\n super.toReferencedArguments(node);\n }\n parseExport(unfinished, decorators) {\n const exportStartLoc = this.state.lastTokStartLoc;\n const node = super.parseExport(unfinished, decorators);\n switch (node.type) {\n case \"ExportAllDeclaration\":\n node.exported = null;\n break;\n case \"ExportNamedDeclaration\":\n if (node.specifiers.length === 1 && node.specifiers[0].type === \"ExportNamespaceSpecifier\") {\n this.castNodeTo(node, \"ExportAllDeclaration\");\n node.exported = node.specifiers[0].exported;\n delete node.specifiers;\n }\n case \"ExportDefaultDeclaration\":\n {\n var _declaration$decorato;\n const {\n declaration\n } = node;\n if ((declaration == null ? void 0 : declaration.type) === \"ClassDeclaration\" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {\n this.resetStartLocation(node, exportStartLoc);\n }\n }\n break;\n }\n return node;\n }\n stopParseSubscript(base, state) {\n const node = super.stopParseSubscript(base, state);\n if (state.optionalChainMember) {\n return this.estreeParseChainExpression(node, base.loc.end);\n }\n return node;\n }\n parseMember(base, startLoc, state, computed, optional) {\n const node = super.parseMember(base, startLoc, state, computed, optional);\n if (node.type === \"OptionalMemberExpression\") {\n this.castNodeTo(node, \"MemberExpression\");\n } else {\n node.optional = false;\n }\n return node;\n }\n isOptionalMemberExpression(node) {\n if (node.type === \"ChainExpression\") {\n return node.expression.type === \"MemberExpression\";\n }\n return super.isOptionalMemberExpression(node);\n }\n hasPropertyAsPrivateName(node) {\n if (node.type === \"ChainExpression\") {\n node = node.expression;\n }\n return super.hasPropertyAsPrivateName(node);\n }\n isObjectProperty(node) {\n return node.type === \"Property\" && node.kind === \"init\" && !node.method;\n }\n isObjectMethod(node) {\n return node.type === \"Property\" && (node.method || node.kind === \"get\" || node.kind === \"set\");\n }\n castNodeTo(node, type) {\n const result = super.castNodeTo(node, type);\n this.fillOptionalPropertiesForTSESLint(result);\n return result;\n }\n cloneIdentifier(node) {\n const cloned = super.cloneIdentifier(node);\n this.fillOptionalPropertiesForTSESLint(cloned);\n return cloned;\n }\n cloneStringLiteral(node) {\n if (node.type === \"Literal\") {\n return this.cloneEstreeStringLiteral(node);\n }\n return super.cloneStringLiteral(node);\n }\n finishNodeAt(node, type, endLoc) {\n return toESTreeLocation(super.finishNodeAt(node, type, endLoc));\n }\n finishNode(node, type) {\n const result = super.finishNode(node, type);\n this.fillOptionalPropertiesForTSESLint(result);\n return result;\n }\n resetStartLocation(node, startLoc) {\n super.resetStartLocation(node, startLoc);\n toESTreeLocation(node);\n }\n resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {\n super.resetEndLocation(node, endLoc);\n toESTreeLocation(node);\n }\n};\nclass TokContext {\n constructor(token, preserveSpace) {\n this.token = void 0;\n this.preserveSpace = void 0;\n this.token = token;\n this.preserveSpace = !!preserveSpace;\n }\n}\nconst types = {\n brace: new TokContext(\"{\"),\n j_oTag: new TokContext(\"...\", true)\n};\ntypes.template = new TokContext(\"`\", true);\nconst beforeExpr = true;\nconst startsExpr = true;\nconst isLoop = true;\nconst isAssign = true;\nconst prefix = true;\nconst postfix = true;\nclass ExportedTokenType {\n constructor(label, conf = {}) {\n this.label = void 0;\n this.keyword = void 0;\n this.beforeExpr = void 0;\n this.startsExpr = void 0;\n this.rightAssociative = void 0;\n this.isLoop = void 0;\n this.isAssign = void 0;\n this.prefix = void 0;\n this.postfix = void 0;\n this.binop = void 0;\n this.label = label;\n this.keyword = conf.keyword;\n this.beforeExpr = !!conf.beforeExpr;\n this.startsExpr = !!conf.startsExpr;\n this.rightAssociative = !!conf.rightAssociative;\n this.isLoop = !!conf.isLoop;\n this.isAssign = !!conf.isAssign;\n this.prefix = !!conf.prefix;\n this.postfix = !!conf.postfix;\n this.binop = conf.binop != null ? conf.binop : null;\n this.updateContext = null;\n }\n}\nconst keywords$1 = new Map();\nfunction createKeyword(name, options = {}) {\n options.keyword = name;\n const token = createToken(name, options);\n keywords$1.set(name, token);\n return token;\n}\nfunction createBinop(name, binop) {\n return createToken(name, {\n beforeExpr,\n binop\n });\n}\nlet tokenTypeCounter = -1;\nconst tokenTypes = [];\nconst tokenLabels = [];\nconst tokenBinops = [];\nconst tokenBeforeExprs = [];\nconst tokenStartsExprs = [];\nconst tokenPrefixes = [];\nfunction createToken(name, options = {}) {\n var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;\n ++tokenTypeCounter;\n tokenLabels.push(name);\n tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);\n tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);\n tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);\n tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);\n tokenTypes.push(new ExportedTokenType(name, options));\n return tokenTypeCounter;\n}\nfunction createKeywordLike(name, options = {}) {\n var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;\n ++tokenTypeCounter;\n keywords$1.set(name, tokenTypeCounter);\n tokenLabels.push(name);\n tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);\n tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);\n tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);\n tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);\n tokenTypes.push(new ExportedTokenType(\"name\", options));\n return tokenTypeCounter;\n}\nconst tt = {\n bracketL: createToken(\"[\", {\n beforeExpr,\n startsExpr\n }),\n bracketHashL: createToken(\"#[\", {\n beforeExpr,\n startsExpr\n }),\n bracketBarL: createToken(\"[|\", {\n beforeExpr,\n startsExpr\n }),\n bracketR: createToken(\"]\"),\n bracketBarR: createToken(\"|]\"),\n braceL: createToken(\"{\", {\n beforeExpr,\n startsExpr\n }),\n braceBarL: createToken(\"{|\", {\n beforeExpr,\n startsExpr\n }),\n braceHashL: createToken(\"#{\", {\n beforeExpr,\n startsExpr\n }),\n braceR: createToken(\"}\"),\n braceBarR: createToken(\"|}\"),\n parenL: createToken(\"(\", {\n beforeExpr,\n startsExpr\n }),\n parenR: createToken(\")\"),\n comma: createToken(\",\", {\n beforeExpr\n }),\n semi: createToken(\";\", {\n beforeExpr\n }),\n colon: createToken(\":\", {\n beforeExpr\n }),\n doubleColon: createToken(\"::\", {\n beforeExpr\n }),\n dot: createToken(\".\"),\n question: createToken(\"?\", {\n beforeExpr\n }),\n questionDot: createToken(\"?.\"),\n arrow: createToken(\"=>\", {\n beforeExpr\n }),\n template: createToken(\"template\"),\n ellipsis: createToken(\"...\", {\n beforeExpr\n }),\n backQuote: createToken(\"`\", {\n startsExpr\n }),\n dollarBraceL: createToken(\"${\", {\n beforeExpr,\n startsExpr\n }),\n templateTail: createToken(\"...`\", {\n startsExpr\n }),\n templateNonTail: createToken(\"...${\", {\n beforeExpr,\n startsExpr\n }),\n at: createToken(\"@\"),\n hash: createToken(\"#\", {\n startsExpr\n }),\n interpreterDirective: createToken(\"#!...\"),\n eq: createToken(\"=\", {\n beforeExpr,\n isAssign\n }),\n assign: createToken(\"_=\", {\n beforeExpr,\n isAssign\n }),\n slashAssign: createToken(\"_=\", {\n beforeExpr,\n isAssign\n }),\n xorAssign: createToken(\"_=\", {\n beforeExpr,\n isAssign\n }),\n moduloAssign: createToken(\"_=\", {\n beforeExpr,\n isAssign\n }),\n incDec: createToken(\"++/--\", {\n prefix,\n postfix,\n startsExpr\n }),\n bang: createToken(\"!\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n tilde: createToken(\"~\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n doubleCaret: createToken(\"^^\", {\n startsExpr\n }),\n doubleAt: createToken(\"@@\", {\n startsExpr\n }),\n pipeline: createBinop(\"|>\", 0),\n nullishCoalescing: createBinop(\"??\", 1),\n logicalOR: createBinop(\"||\", 1),\n logicalAND: createBinop(\"&&\", 2),\n bitwiseOR: createBinop(\"|\", 3),\n bitwiseXOR: createBinop(\"^\", 4),\n bitwiseAND: createBinop(\"&\", 5),\n equality: createBinop(\"==/!=/===/!==\", 6),\n lt: createBinop(\"/<=/>=\", 7),\n gt: createBinop(\"/<=/>=\", 7),\n relational: createBinop(\"/<=/>=\", 7),\n bitShift: createBinop(\"<>/>>>\", 8),\n bitShiftL: createBinop(\"<>/>>>\", 8),\n bitShiftR: createBinop(\"<>/>>>\", 8),\n plusMin: createToken(\"+/-\", {\n beforeExpr,\n binop: 9,\n prefix,\n startsExpr\n }),\n modulo: createToken(\"%\", {\n binop: 10,\n startsExpr\n }),\n star: createToken(\"*\", {\n binop: 10\n }),\n slash: createBinop(\"/\", 10),\n exponent: createToken(\"**\", {\n beforeExpr,\n binop: 11,\n rightAssociative: true\n }),\n _in: createKeyword(\"in\", {\n beforeExpr,\n binop: 7\n }),\n _instanceof: createKeyword(\"instanceof\", {\n beforeExpr,\n binop: 7\n }),\n _break: createKeyword(\"break\"),\n _case: createKeyword(\"case\", {\n beforeExpr\n }),\n _catch: createKeyword(\"catch\"),\n _continue: createKeyword(\"continue\"),\n _debugger: createKeyword(\"debugger\"),\n _default: createKeyword(\"default\", {\n beforeExpr\n }),\n _else: createKeyword(\"else\", {\n beforeExpr\n }),\n _finally: createKeyword(\"finally\"),\n _function: createKeyword(\"function\", {\n startsExpr\n }),\n _if: createKeyword(\"if\"),\n _return: createKeyword(\"return\", {\n beforeExpr\n }),\n _switch: createKeyword(\"switch\"),\n _throw: createKeyword(\"throw\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n _try: createKeyword(\"try\"),\n _var: createKeyword(\"var\"),\n _const: createKeyword(\"const\"),\n _with: createKeyword(\"with\"),\n _new: createKeyword(\"new\", {\n beforeExpr,\n startsExpr\n }),\n _this: createKeyword(\"this\", {\n startsExpr\n }),\n _super: createKeyword(\"super\", {\n startsExpr\n }),\n _class: createKeyword(\"class\", {\n startsExpr\n }),\n _extends: createKeyword(\"extends\", {\n beforeExpr\n }),\n _export: createKeyword(\"export\"),\n _import: createKeyword(\"import\", {\n startsExpr\n }),\n _null: createKeyword(\"null\", {\n startsExpr\n }),\n _true: createKeyword(\"true\", {\n startsExpr\n }),\n _false: createKeyword(\"false\", {\n startsExpr\n }),\n _typeof: createKeyword(\"typeof\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n _void: createKeyword(\"void\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n _delete: createKeyword(\"delete\", {\n beforeExpr,\n prefix,\n startsExpr\n }),\n _do: createKeyword(\"do\", {\n isLoop,\n beforeExpr\n }),\n _for: createKeyword(\"for\", {\n isLoop\n }),\n _while: createKeyword(\"while\", {\n isLoop\n }),\n _as: createKeywordLike(\"as\", {\n startsExpr\n }),\n _assert: createKeywordLike(\"assert\", {\n startsExpr\n }),\n _async: createKeywordLike(\"async\", {\n startsExpr\n }),\n _await: createKeywordLike(\"await\", {\n startsExpr\n }),\n _defer: createKeywordLike(\"defer\", {\n startsExpr\n }),\n _from: createKeywordLike(\"from\", {\n startsExpr\n }),\n _get: createKeywordLike(\"get\", {\n startsExpr\n }),\n _let: createKeywordLike(\"let\", {\n startsExpr\n }),\n _meta: createKeywordLike(\"meta\", {\n startsExpr\n }),\n _of: createKeywordLike(\"of\", {\n startsExpr\n }),\n _sent: createKeywordLike(\"sent\", {\n startsExpr\n }),\n _set: createKeywordLike(\"set\", {\n startsExpr\n }),\n _source: createKeywordLike(\"source\", {\n startsExpr\n }),\n _static: createKeywordLike(\"static\", {\n startsExpr\n }),\n _using: createKeywordLike(\"using\", {\n startsExpr\n }),\n _yield: createKeywordLike(\"yield\", {\n startsExpr\n }),\n _asserts: createKeywordLike(\"asserts\", {\n startsExpr\n }),\n _checks: createKeywordLike(\"checks\", {\n startsExpr\n }),\n _exports: createKeywordLike(\"exports\", {\n startsExpr\n }),\n _global: createKeywordLike(\"global\", {\n startsExpr\n }),\n _implements: createKeywordLike(\"implements\", {\n startsExpr\n }),\n _intrinsic: createKeywordLike(\"intrinsic\", {\n startsExpr\n }),\n _infer: createKeywordLike(\"infer\", {\n startsExpr\n }),\n _is: createKeywordLike(\"is\", {\n startsExpr\n }),\n _mixins: createKeywordLike(\"mixins\", {\n startsExpr\n }),\n _proto: createKeywordLike(\"proto\", {\n startsExpr\n }),\n _require: createKeywordLike(\"require\", {\n startsExpr\n }),\n _satisfies: createKeywordLike(\"satisfies\", {\n startsExpr\n }),\n _keyof: createKeywordLike(\"keyof\", {\n startsExpr\n }),\n _readonly: createKeywordLike(\"readonly\", {\n startsExpr\n }),\n _unique: createKeywordLike(\"unique\", {\n startsExpr\n }),\n _abstract: createKeywordLike(\"abstract\", {\n startsExpr\n }),\n _declare: createKeywordLike(\"declare\", {\n startsExpr\n }),\n _enum: createKeywordLike(\"enum\", {\n startsExpr\n }),\n _module: createKeywordLike(\"module\", {\n startsExpr\n }),\n _namespace: createKeywordLike(\"namespace\", {\n startsExpr\n }),\n _interface: createKeywordLike(\"interface\", {\n startsExpr\n }),\n _type: createKeywordLike(\"type\", {\n startsExpr\n }),\n _opaque: createKeywordLike(\"opaque\", {\n startsExpr\n }),\n name: createToken(\"name\", {\n startsExpr\n }),\n placeholder: createToken(\"%%\", {\n startsExpr\n }),\n string: createToken(\"string\", {\n startsExpr\n }),\n num: createToken(\"num\", {\n startsExpr\n }),\n bigint: createToken(\"bigint\", {\n startsExpr\n }),\n decimal: createToken(\"decimal\", {\n startsExpr\n }),\n regexp: createToken(\"regexp\", {\n startsExpr\n }),\n privateName: createToken(\"#name\", {\n startsExpr\n }),\n eof: createToken(\"eof\"),\n jsxName: createToken(\"jsxName\"),\n jsxText: createToken(\"jsxText\", {\n beforeExpr\n }),\n jsxTagStart: createToken(\"jsxTagStart\", {\n startsExpr\n }),\n jsxTagEnd: createToken(\"jsxTagEnd\")\n};\nfunction tokenIsIdentifier(token) {\n return token >= 93 && token <= 133;\n}\nfunction tokenKeywordOrIdentifierIsKeyword(token) {\n return token <= 92;\n}\nfunction tokenIsKeywordOrIdentifier(token) {\n return token >= 58 && token <= 133;\n}\nfunction tokenIsLiteralPropertyName(token) {\n return token >= 58 && token <= 137;\n}\nfunction tokenComesBeforeExpression(token) {\n return tokenBeforeExprs[token];\n}\nfunction tokenCanStartExpression(token) {\n return tokenStartsExprs[token];\n}\nfunction tokenIsAssignment(token) {\n return token >= 29 && token <= 33;\n}\nfunction tokenIsFlowInterfaceOrTypeOrOpaque(token) {\n return token >= 129 && token <= 131;\n}\nfunction tokenIsLoop(token) {\n return token >= 90 && token <= 92;\n}\nfunction tokenIsKeyword(token) {\n return token >= 58 && token <= 92;\n}\nfunction tokenIsOperator(token) {\n return token >= 39 && token <= 59;\n}\nfunction tokenIsPostfix(token) {\n return token === 34;\n}\nfunction tokenIsPrefix(token) {\n return tokenPrefixes[token];\n}\nfunction tokenIsTSTypeOperator(token) {\n return token >= 121 && token <= 123;\n}\nfunction tokenIsTSDeclarationStart(token) {\n return token >= 124 && token <= 130;\n}\nfunction tokenLabelName(token) {\n return tokenLabels[token];\n}\nfunction tokenOperatorPrecedence(token) {\n return tokenBinops[token];\n}\nfunction tokenIsRightAssociative(token) {\n return token === 57;\n}\nfunction tokenIsTemplate(token) {\n return token >= 24 && token <= 25;\n}\nfunction getExportedToken(token) {\n return tokenTypes[token];\n}\ntokenTypes[8].updateContext = context => {\n context.pop();\n};\ntokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => {\n context.push(types.brace);\n};\ntokenTypes[22].updateContext = context => {\n if (context[context.length - 1] === types.template) {\n context.pop();\n } else {\n context.push(types.template);\n }\n};\ntokenTypes[143].updateContext = context => {\n context.push(types.j_expr, types.j_oTag);\n};\nlet nonASCIIidentifierStartChars = \"\\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\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\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\\u0860-\\u086a\\u0870-\\u0887\\u0889-\\u088f\\u08a0-\\u08c9\\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\\u09fc\\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\\u0c5c\\u0c5d\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cdc-\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\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-\\u1711\\u171f-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4c\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c8a\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\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-\\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-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7dc\\ua7f1-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\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-\\uab69\\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\";\nlet nonASCIIidentifierChars = \"\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u0897-\\u089f\\u08ca-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3c\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0cf3\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ece\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1715\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u180f-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf-\\u1add\\u1ae0-\\u1aeb\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1dff\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\u30fb\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\\uff65\";\nconst nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nconst nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\nconst astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];\nconst astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];\nfunction isInAstralSet(code, set) {\n let pos = 0x10000;\n for (let i = 0, length = set.length; i < length; i += 2) {\n pos += set[i];\n if (pos > code) return false;\n pos += set[i + 1];\n if (pos >= code) return true;\n }\n return false;\n}\nfunction isIdentifierStart(code) {\n if (code < 65) return code === 36;\n if (code <= 90) return true;\n if (code < 97) return code === 95;\n if (code <= 122) return true;\n if (code <= 0xffff) {\n return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n }\n return isInAstralSet(code, astralIdentifierStartCodes);\n}\nfunction isIdentifierChar(code) {\n if (code < 48) return code === 36;\n if (code < 58) return true;\n if (code < 65) return false;\n if (code <= 90) return true;\n if (code < 97) return code === 95;\n if (code <= 122) return true;\n if (code <= 0xffff) {\n return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n }\n return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n}\nconst reservedWords = {\n keyword: [\"break\", \"case\", \"catch\", \"continue\", \"debugger\", \"default\", \"do\", \"else\", \"finally\", \"for\", \"function\", \"if\", \"return\", \"switch\", \"throw\", \"try\", \"var\", \"const\", \"while\", \"with\", \"new\", \"this\", \"super\", \"class\", \"extends\", \"export\", \"import\", \"null\", \"true\", \"false\", \"in\", \"instanceof\", \"typeof\", \"void\", \"delete\"],\n strict: [\"implements\", \"interface\", \"let\", \"package\", \"private\", \"protected\", \"public\", \"static\", \"yield\"],\n strictBind: [\"eval\", \"arguments\"]\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\nfunction isReservedWord(word, inModule) {\n return inModule && word === \"await\" || word === \"enum\";\n}\nfunction isStrictReservedWord(word, inModule) {\n return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\nfunction isStrictBindOnlyReservedWord(word) {\n return reservedWordsStrictBindSet.has(word);\n}\nfunction isStrictBindReservedWord(word, inModule) {\n return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);\n}\nfunction isKeyword(word) {\n return keywords.has(word);\n}\nfunction isIteratorStart(current, next, next2) {\n return current === 64 && next === 64 && isIdentifierStart(next2);\n}\nconst reservedWordLikeSet = new Set([\"break\", \"case\", \"catch\", \"continue\", \"debugger\", \"default\", \"do\", \"else\", \"finally\", \"for\", \"function\", \"if\", \"return\", \"switch\", \"throw\", \"try\", \"var\", \"const\", \"while\", \"with\", \"new\", \"this\", \"super\", \"class\", \"extends\", \"export\", \"import\", \"null\", \"true\", \"false\", \"in\", \"instanceof\", \"typeof\", \"void\", \"delete\", \"implements\", \"interface\", \"let\", \"package\", \"private\", \"protected\", \"public\", \"static\", \"yield\", \"eval\", \"arguments\", \"enum\", \"await\"]);\nfunction canBeReservedWord(word) {\n return reservedWordLikeSet.has(word);\n}\nclass Scope {\n constructor(flags) {\n this.flags = 0;\n this.names = new Map();\n this.firstLexicalName = \"\";\n this.flags = flags;\n }\n}\nclass ScopeHandler {\n constructor(parser, inModule) {\n this.parser = void 0;\n this.scopeStack = [];\n this.inModule = void 0;\n this.undefinedExports = new Map();\n this.parser = parser;\n this.inModule = inModule;\n }\n get inTopLevel() {\n return (this.currentScope().flags & 1) > 0;\n }\n get inFunction() {\n return (this.currentVarScopeFlags() & 2) > 0;\n }\n get allowSuper() {\n return (this.currentThisScopeFlags() & 16) > 0;\n }\n get allowDirectSuper() {\n return (this.currentThisScopeFlags() & 32) > 0;\n }\n get allowNewTarget() {\n return (this.currentThisScopeFlags() & 512) > 0;\n }\n get inClass() {\n return (this.currentThisScopeFlags() & 64) > 0;\n }\n get inClassAndNotInNonArrowFunction() {\n const flags = this.currentThisScopeFlags();\n return (flags & 64) > 0 && (flags & 2) === 0;\n }\n get inStaticBlock() {\n for (let i = this.scopeStack.length - 1;; i--) {\n const {\n flags\n } = this.scopeStack[i];\n if (flags & 128) {\n return true;\n }\n if (flags & (1667 | 64)) {\n return false;\n }\n }\n }\n get inNonArrowFunction() {\n return (this.currentThisScopeFlags() & 2) > 0;\n }\n get inBareCaseStatement() {\n return (this.currentScope().flags & 256) > 0;\n }\n get treatFunctionsAsVar() {\n return this.treatFunctionsAsVarInScope(this.currentScope());\n }\n createScope(flags) {\n return new Scope(flags);\n }\n enter(flags) {\n this.scopeStack.push(this.createScope(flags));\n }\n exit() {\n const scope = this.scopeStack.pop();\n return scope.flags;\n }\n treatFunctionsAsVarInScope(scope) {\n return !!(scope.flags & (2 | 128) || !this.parser.inModule && scope.flags & 1);\n }\n declareName(name, bindingType, loc) {\n let scope = this.currentScope();\n if (bindingType & 8 || bindingType & 16) {\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n let type = scope.names.get(name) || 0;\n if (bindingType & 16) {\n type = type | 4;\n } else {\n if (!scope.firstLexicalName) {\n scope.firstLexicalName = name;\n }\n type = type | 2;\n }\n scope.names.set(name, type);\n if (bindingType & 8) {\n this.maybeExportDefined(scope, name);\n }\n } else if (bindingType & 4) {\n for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n scope = this.scopeStack[i];\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n scope.names.set(name, (scope.names.get(name) || 0) | 1);\n this.maybeExportDefined(scope, name);\n if (scope.flags & 1667) break;\n }\n }\n if (this.parser.inModule && scope.flags & 1) {\n this.undefinedExports.delete(name);\n }\n }\n maybeExportDefined(scope, name) {\n if (this.parser.inModule && scope.flags & 1) {\n this.undefinedExports.delete(name);\n }\n }\n checkRedeclarationInScope(scope, name, bindingType, loc) {\n if (this.isRedeclaredInScope(scope, name, bindingType)) {\n this.parser.raise(Errors.VarRedeclaration, loc, {\n identifierName: name\n });\n }\n }\n isRedeclaredInScope(scope, name, bindingType) {\n if (!(bindingType & 1)) return false;\n if (bindingType & 8) {\n return scope.names.has(name);\n }\n const type = scope.names.get(name) || 0;\n if (bindingType & 16) {\n return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope) && (type & 1) > 0;\n }\n return (type & 2) > 0 && !(scope.flags & 8 && scope.firstLexicalName === name) || !this.treatFunctionsAsVarInScope(scope) && (type & 4) > 0;\n }\n checkLocalExport(id) {\n const {\n name\n } = id;\n const topLevelScope = this.scopeStack[0];\n if (!topLevelScope.names.has(name)) {\n this.undefinedExports.set(name, id.loc.start);\n }\n }\n currentScope() {\n return this.scopeStack[this.scopeStack.length - 1];\n }\n currentVarScopeFlags() {\n for (let i = this.scopeStack.length - 1;; i--) {\n const {\n flags\n } = this.scopeStack[i];\n if (flags & 1667) {\n return flags;\n }\n }\n }\n currentThisScopeFlags() {\n for (let i = this.scopeStack.length - 1;; i--) {\n const {\n flags\n } = this.scopeStack[i];\n if (flags & (1667 | 64) && !(flags & 4)) {\n return flags;\n }\n }\n }\n}\nclass FlowScope extends Scope {\n constructor(...args) {\n super(...args);\n this.declareFunctions = new Set();\n }\n}\nclass FlowScopeHandler extends ScopeHandler {\n createScope(flags) {\n return new FlowScope(flags);\n }\n declareName(name, bindingType, loc) {\n const scope = this.currentScope();\n if (bindingType & 2048) {\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n this.maybeExportDefined(scope, name);\n scope.declareFunctions.add(name);\n return;\n }\n super.declareName(name, bindingType, loc);\n }\n isRedeclaredInScope(scope, name, bindingType) {\n if (super.isRedeclaredInScope(scope, name, bindingType)) return true;\n if (bindingType & 2048 && !scope.declareFunctions.has(name)) {\n const type = scope.names.get(name);\n return (type & 4) > 0 || (type & 2) > 0;\n }\n return false;\n }\n checkLocalExport(id) {\n if (!this.scopeStack[0].declareFunctions.has(id.name)) {\n super.checkLocalExport(id);\n }\n }\n}\nconst reservedTypes = new Set([\"_\", \"any\", \"bool\", \"boolean\", \"empty\", \"extends\", \"false\", \"interface\", \"mixed\", \"null\", \"number\", \"static\", \"string\", \"true\", \"typeof\", \"void\"]);\nconst FlowErrors = ParseErrorEnum`flow`({\n AmbiguousConditionalArrow: \"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.\",\n AmbiguousDeclareModuleKind: \"Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.\",\n AssignReservedType: ({\n reservedType\n }) => `Cannot overwrite reserved type ${reservedType}.`,\n DeclareClassElement: \"The `declare` modifier can only appear on class fields.\",\n DeclareClassFieldInitializer: \"Initializers are not allowed in fields with the `declare` modifier.\",\n DuplicateDeclareModuleExports: \"Duplicate `declare module.exports` statement.\",\n EnumBooleanMemberNotInitialized: ({\n memberName,\n enumName\n }) => `Boolean enum members need to be initialized. Use either \\`${memberName} = true,\\` or \\`${memberName} = false,\\` in enum \\`${enumName}\\`.`,\n EnumDuplicateMemberName: ({\n memberName,\n enumName\n }) => `Enum member names need to be unique, but the name \\`${memberName}\\` has already been used before in enum \\`${enumName}\\`.`,\n EnumInconsistentMemberValues: ({\n enumName\n }) => `Enum \\`${enumName}\\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,\n EnumInvalidExplicitType: ({\n invalidEnumType,\n enumName\n }) => `Enum type \\`${invalidEnumType}\\` is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n EnumInvalidExplicitTypeUnknownSupplied: ({\n enumName\n }) => `Supplied enum type is not valid. Use one of \\`boolean\\`, \\`number\\`, \\`string\\`, or \\`symbol\\` in enum \\`${enumName}\\`.`,\n EnumInvalidMemberInitializerPrimaryType: ({\n enumName,\n memberName,\n explicitType\n }) => `Enum \\`${enumName}\\` has type \\`${explicitType}\\`, so the initializer of \\`${memberName}\\` needs to be a ${explicitType} literal.`,\n EnumInvalidMemberInitializerSymbolType: ({\n enumName,\n memberName\n }) => `Symbol enum members cannot be initialized. Use \\`${memberName},\\` in enum \\`${enumName}\\`.`,\n EnumInvalidMemberInitializerUnknownType: ({\n enumName,\n memberName\n }) => `The enum member initializer for \\`${memberName}\\` needs to be a literal (either a boolean, number, or string) in enum \\`${enumName}\\`.`,\n EnumInvalidMemberName: ({\n enumName,\n memberName,\n suggestion\n }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \\`${memberName}\\`, consider using \\`${suggestion}\\`, in enum \\`${enumName}\\`.`,\n EnumNumberMemberNotInitialized: ({\n enumName,\n memberName\n }) => `Number enum members need to be initialized, e.g. \\`${memberName} = 1\\` in enum \\`${enumName}\\`.`,\n EnumStringMemberInconsistentlyInitialized: ({\n enumName\n }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \\`${enumName}\\`.`,\n GetterMayNotHaveThisParam: \"A getter cannot have a `this` parameter.\",\n ImportReflectionHasImportType: \"An `import module` declaration can not use `type` or `typeof` keyword.\",\n ImportTypeShorthandOnlyInPureImport: \"The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.\",\n InexactInsideExact: \"Explicit inexact syntax cannot appear inside an explicit exact object type.\",\n InexactInsideNonObject: \"Explicit inexact syntax cannot appear in class or interface definitions.\",\n InexactVariance: \"Explicit inexact syntax cannot have variance.\",\n InvalidNonTypeImportInDeclareModule: \"Imports within a `declare module` body must always be `import type` or `import typeof`.\",\n MissingTypeParamDefault: \"Type parameter declaration needs a default, since a preceding type parameter declaration has a default.\",\n NestedDeclareModule: \"`declare module` cannot be used inside another `declare module`.\",\n NestedFlowComment: \"Cannot have a flow comment inside another flow comment.\",\n PatternIsOptional: Object.assign({\n message: \"A binding pattern parameter cannot be optional in an implementation signature.\"\n }, {\n reasonCode: \"OptionalBindingPattern\"\n }),\n SetterMayNotHaveThisParam: \"A setter cannot have a `this` parameter.\",\n SpreadVariance: \"Spread properties cannot have variance.\",\n ThisParamAnnotationRequired: \"A type annotation is required for the `this` parameter.\",\n ThisParamBannedInConstructor: \"Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.\",\n ThisParamMayNotBeOptional: \"The `this` parameter cannot be optional.\",\n ThisParamMustBeFirst: \"The `this` parameter must be the first function parameter.\",\n ThisParamNoDefault: \"The `this` parameter may not have a default value.\",\n TypeBeforeInitializer: \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n TypeCastInPattern: \"The type cast expression is expected to be wrapped with parenthesis.\",\n UnexpectedExplicitInexactInObject: \"Explicit inexact syntax must appear at the end of an inexact object.\",\n UnexpectedReservedType: ({\n reservedType\n }) => `Unexpected reserved type ${reservedType}.`,\n UnexpectedReservedUnderscore: \"`_` is only allowed as a type argument to call or new.\",\n UnexpectedSpaceBetweenModuloChecks: \"Spaces between `%` and `checks` are not allowed here.\",\n UnexpectedSpreadType: \"Spread operator cannot appear in class or interface definitions.\",\n UnexpectedSubtractionOperand: 'Unexpected token, expected \"number\" or \"bigint\".',\n UnexpectedTokenAfterTypeParameter: \"Expected an arrow function after this type parameter declaration.\",\n UnexpectedTypeParameterBeforeAsyncArrowFunction: \"Type parameters must come after the async keyword, e.g. instead of ` async () => {}`, use `async () => {}`.\",\n UnsupportedDeclareExportKind: ({\n unsupportedExportKind,\n suggestion\n }) => `\\`declare export ${unsupportedExportKind}\\` is not supported. Use \\`${suggestion}\\` instead.`,\n UnsupportedStatementInDeclareModule: \"Only declares and type imports are allowed inside declare module.\",\n UnterminatedFlowComment: \"Unterminated flow-comment.\"\n});\nfunction isEsModuleType(bodyElement) {\n return bodyElement.type === \"DeclareExportAllDeclaration\" || bodyElement.type === \"DeclareExportDeclaration\" && (!bodyElement.declaration || bodyElement.declaration.type !== \"TypeAlias\" && bodyElement.declaration.type !== \"InterfaceDeclaration\");\n}\nfunction hasTypeImportKind(node) {\n return node.importKind === \"type\" || node.importKind === \"typeof\";\n}\nconst exportSuggestions = {\n const: \"declare export var\",\n let: \"declare export var\",\n type: \"export type\",\n interface: \"export interface\"\n};\nfunction partition(list, test) {\n const list1 = [];\n const list2 = [];\n for (let i = 0; i < list.length; i++) {\n (test(list[i], i, list) ? list1 : list2).push(list[i]);\n }\n return [list1, list2];\n}\nconst FLOW_PRAGMA_REGEX = /\\*?\\s*@((?:no)?flow)\\b/;\nvar flow = superClass => class FlowParserMixin extends superClass {\n constructor(...args) {\n super(...args);\n this.flowPragma = undefined;\n }\n getScopeHandler() {\n return FlowScopeHandler;\n }\n shouldParseTypes() {\n return this.getPluginOption(\"flow\", \"all\") || this.flowPragma === \"flow\";\n }\n finishToken(type, val) {\n if (type !== 134 && type !== 13 && type !== 28) {\n if (this.flowPragma === undefined) {\n this.flowPragma = null;\n }\n }\n super.finishToken(type, val);\n }\n addComment(comment) {\n if (this.flowPragma === undefined) {\n const matches = FLOW_PRAGMA_REGEX.exec(comment.value);\n if (!matches) ;else if (matches[1] === \"flow\") {\n this.flowPragma = \"flow\";\n } else if (matches[1] === \"noflow\") {\n this.flowPragma = \"noflow\";\n } else {\n throw new Error(\"Unexpected flow pragma\");\n }\n }\n super.addComment(comment);\n }\n flowParseTypeInitialiser(tok) {\n const oldInType = this.state.inType;\n this.state.inType = true;\n this.expect(tok || 14);\n const type = this.flowParseType();\n this.state.inType = oldInType;\n return type;\n }\n flowParsePredicate() {\n const node = this.startNode();\n const moduloLoc = this.state.startLoc;\n this.next();\n this.expectContextual(110);\n if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {\n this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);\n }\n if (this.eat(10)) {\n node.value = super.parseExpression();\n this.expect(11);\n return this.finishNode(node, \"DeclaredPredicate\");\n } else {\n return this.finishNode(node, \"InferredPredicate\");\n }\n }\n flowParseTypeAndPredicateInitialiser() {\n const oldInType = this.state.inType;\n this.state.inType = true;\n this.expect(14);\n let type = null;\n let predicate = null;\n if (this.match(54)) {\n this.state.inType = oldInType;\n predicate = this.flowParsePredicate();\n } else {\n type = this.flowParseType();\n this.state.inType = oldInType;\n if (this.match(54)) {\n predicate = this.flowParsePredicate();\n }\n }\n return [type, predicate];\n }\n flowParseDeclareClass(node) {\n this.next();\n this.flowParseInterfaceish(node, true);\n return this.finishNode(node, \"DeclareClass\");\n }\n flowParseDeclareFunction(node) {\n this.next();\n const id = node.id = this.parseIdentifier();\n const typeNode = this.startNode();\n const typeContainer = this.startNode();\n if (this.match(47)) {\n typeNode.typeParameters = this.flowParseTypeParameterDeclaration();\n } else {\n typeNode.typeParameters = null;\n }\n this.expect(10);\n const tmp = this.flowParseFunctionTypeParams();\n typeNode.params = tmp.params;\n typeNode.rest = tmp.rest;\n typeNode.this = tmp._this;\n this.expect(11);\n [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n typeContainer.typeAnnotation = this.finishNode(typeNode, \"FunctionTypeAnnotation\");\n id.typeAnnotation = this.finishNode(typeContainer, \"TypeAnnotation\");\n this.resetEndLocation(id);\n this.semicolon();\n this.scope.declareName(node.id.name, 2048, node.id.loc.start);\n return this.finishNode(node, \"DeclareFunction\");\n }\n flowParseDeclare(node, insideModule) {\n if (this.match(80)) {\n return this.flowParseDeclareClass(node);\n } else if (this.match(68)) {\n return this.flowParseDeclareFunction(node);\n } else if (this.match(74)) {\n return this.flowParseDeclareVariable(node);\n } else if (this.eatContextual(127)) {\n if (this.match(16)) {\n return this.flowParseDeclareModuleExports(node);\n } else {\n if (insideModule) {\n this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);\n }\n return this.flowParseDeclareModule(node);\n }\n } else if (this.isContextual(130)) {\n return this.flowParseDeclareTypeAlias(node);\n } else if (this.isContextual(131)) {\n return this.flowParseDeclareOpaqueType(node);\n } else if (this.isContextual(129)) {\n return this.flowParseDeclareInterface(node);\n } else if (this.match(82)) {\n return this.flowParseDeclareExportDeclaration(node, insideModule);\n }\n throw this.unexpected();\n }\n flowParseDeclareVariable(node) {\n this.next();\n node.id = this.flowParseTypeAnnotatableIdentifier(true);\n this.scope.declareName(node.id.name, 5, node.id.loc.start);\n this.semicolon();\n return this.finishNode(node, \"DeclareVariable\");\n }\n flowParseDeclareModule(node) {\n this.scope.enter(0);\n if (this.match(134)) {\n node.id = super.parseExprAtom();\n } else {\n node.id = this.parseIdentifier();\n }\n const bodyNode = node.body = this.startNode();\n const body = bodyNode.body = [];\n this.expect(5);\n while (!this.match(8)) {\n const bodyNode = this.startNode();\n if (this.match(83)) {\n this.next();\n if (!this.isContextual(130) && !this.match(87)) {\n this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);\n }\n body.push(super.parseImport(bodyNode));\n } else {\n this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);\n body.push(this.flowParseDeclare(bodyNode, true));\n }\n }\n this.scope.exit();\n this.expect(8);\n this.finishNode(bodyNode, \"BlockStatement\");\n let kind = null;\n let hasModuleExport = false;\n body.forEach(bodyElement => {\n if (isEsModuleType(bodyElement)) {\n if (kind === \"CommonJS\") {\n this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);\n }\n kind = \"ES\";\n } else if (bodyElement.type === \"DeclareModuleExports\") {\n if (hasModuleExport) {\n this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);\n }\n if (kind === \"ES\") {\n this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);\n }\n kind = \"CommonJS\";\n hasModuleExport = true;\n }\n });\n node.kind = kind || \"CommonJS\";\n return this.finishNode(node, \"DeclareModule\");\n }\n flowParseDeclareExportDeclaration(node, insideModule) {\n this.expect(82);\n if (this.eat(65)) {\n if (this.match(68) || this.match(80)) {\n node.declaration = this.flowParseDeclare(this.startNode());\n } else {\n node.declaration = this.flowParseType();\n this.semicolon();\n }\n node.default = true;\n return this.finishNode(node, \"DeclareExportDeclaration\");\n } else {\n if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {\n const label = this.state.value;\n throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {\n unsupportedExportKind: label,\n suggestion: exportSuggestions[label]\n });\n }\n if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {\n node.declaration = this.flowParseDeclare(this.startNode());\n node.default = false;\n return this.finishNode(node, \"DeclareExportDeclaration\");\n } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {\n node = this.parseExport(node, null);\n if (node.type === \"ExportNamedDeclaration\") {\n node.default = false;\n delete node.exportKind;\n return this.castNodeTo(node, \"DeclareExportDeclaration\");\n } else {\n return this.castNodeTo(node, \"DeclareExportAllDeclaration\");\n }\n }\n }\n throw this.unexpected();\n }\n flowParseDeclareModuleExports(node) {\n this.next();\n this.expectContextual(111);\n node.typeAnnotation = this.flowParseTypeAnnotation();\n this.semicolon();\n return this.finishNode(node, \"DeclareModuleExports\");\n }\n flowParseDeclareTypeAlias(node) {\n this.next();\n const finished = this.flowParseTypeAlias(node);\n this.castNodeTo(finished, \"DeclareTypeAlias\");\n return finished;\n }\n flowParseDeclareOpaqueType(node) {\n this.next();\n const finished = this.flowParseOpaqueType(node, true);\n this.castNodeTo(finished, \"DeclareOpaqueType\");\n return finished;\n }\n flowParseDeclareInterface(node) {\n this.next();\n this.flowParseInterfaceish(node, false);\n return this.finishNode(node, \"DeclareInterface\");\n }\n flowParseInterfaceish(node, isClass) {\n node.id = this.flowParseRestrictedIdentifier(!isClass, true);\n this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n } else {\n node.typeParameters = null;\n }\n node.extends = [];\n if (this.eat(81)) {\n do {\n node.extends.push(this.flowParseInterfaceExtends());\n } while (!isClass && this.eat(12));\n }\n if (isClass) {\n node.implements = [];\n node.mixins = [];\n if (this.eatContextual(117)) {\n do {\n node.mixins.push(this.flowParseInterfaceExtends());\n } while (this.eat(12));\n }\n if (this.eatContextual(113)) {\n do {\n node.implements.push(this.flowParseInterfaceExtends());\n } while (this.eat(12));\n }\n }\n node.body = this.flowParseObjectType({\n allowStatic: isClass,\n allowExact: false,\n allowSpread: false,\n allowProto: isClass,\n allowInexact: false\n });\n }\n flowParseInterfaceExtends() {\n const node = this.startNode();\n node.id = this.flowParseQualifiedTypeIdentifier();\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterInstantiation();\n } else {\n node.typeParameters = null;\n }\n return this.finishNode(node, \"InterfaceExtends\");\n }\n flowParseInterface(node) {\n this.flowParseInterfaceish(node, false);\n return this.finishNode(node, \"InterfaceDeclaration\");\n }\n checkNotUnderscore(word) {\n if (word === \"_\") {\n this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);\n }\n }\n checkReservedType(word, startLoc, declaration) {\n if (!reservedTypes.has(word)) return;\n this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {\n reservedType: word\n });\n }\n flowParseRestrictedIdentifier(liberal, declaration) {\n this.checkReservedType(this.state.value, this.state.startLoc, declaration);\n return this.parseIdentifier(liberal);\n }\n flowParseTypeAlias(node) {\n node.id = this.flowParseRestrictedIdentifier(false, true);\n this.scope.declareName(node.id.name, 8201, node.id.loc.start);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n } else {\n node.typeParameters = null;\n }\n node.right = this.flowParseTypeInitialiser(29);\n this.semicolon();\n return this.finishNode(node, \"TypeAlias\");\n }\n flowParseOpaqueType(node, declare) {\n this.expectContextual(130);\n node.id = this.flowParseRestrictedIdentifier(true, true);\n this.scope.declareName(node.id.name, 8201, node.id.loc.start);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n } else {\n node.typeParameters = null;\n }\n node.supertype = null;\n if (this.match(14)) {\n node.supertype = this.flowParseTypeInitialiser(14);\n }\n node.impltype = null;\n if (!declare) {\n node.impltype = this.flowParseTypeInitialiser(29);\n }\n this.semicolon();\n return this.finishNode(node, \"OpaqueType\");\n }\n flowParseTypeParameter(requireDefault = false) {\n const nodeStartLoc = this.state.startLoc;\n const node = this.startNode();\n const variance = this.flowParseVariance();\n const ident = this.flowParseTypeAnnotatableIdentifier();\n node.name = ident.name;\n node.variance = variance;\n node.bound = ident.typeAnnotation;\n if (this.match(29)) {\n this.eat(29);\n node.default = this.flowParseType();\n } else {\n if (requireDefault) {\n this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);\n }\n }\n return this.finishNode(node, \"TypeParameter\");\n }\n flowParseTypeParameterDeclaration() {\n const oldInType = this.state.inType;\n const node = this.startNode();\n node.params = [];\n this.state.inType = true;\n if (this.match(47) || this.match(143)) {\n this.next();\n } else {\n this.unexpected();\n }\n let defaultRequired = false;\n do {\n const typeParameter = this.flowParseTypeParameter(defaultRequired);\n node.params.push(typeParameter);\n if (typeParameter.default) {\n defaultRequired = true;\n }\n if (!this.match(48)) {\n this.expect(12);\n }\n } while (!this.match(48));\n this.expect(48);\n this.state.inType = oldInType;\n return this.finishNode(node, \"TypeParameterDeclaration\");\n }\n flowInTopLevelContext(cb) {\n if (this.curContext() !== types.brace) {\n const oldContext = this.state.context;\n this.state.context = [oldContext[0]];\n try {\n return cb();\n } finally {\n this.state.context = oldContext;\n }\n } else {\n return cb();\n }\n }\n flowParseTypeParameterInstantiationInExpression() {\n if (this.reScan_lt() !== 47) return;\n return this.flowParseTypeParameterInstantiation();\n }\n flowParseTypeParameterInstantiation() {\n const node = this.startNode();\n const oldInType = this.state.inType;\n this.state.inType = true;\n node.params = [];\n this.flowInTopLevelContext(() => {\n this.expect(47);\n const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n this.state.noAnonFunctionType = false;\n while (!this.match(48)) {\n node.params.push(this.flowParseType());\n if (!this.match(48)) {\n this.expect(12);\n }\n }\n this.state.noAnonFunctionType = oldNoAnonFunctionType;\n });\n this.state.inType = oldInType;\n if (!this.state.inType && this.curContext() === types.brace) {\n this.reScan_lt_gt();\n }\n this.expect(48);\n return this.finishNode(node, \"TypeParameterInstantiation\");\n }\n flowParseTypeParameterInstantiationCallOrNew() {\n if (this.reScan_lt() !== 47) return null;\n const node = this.startNode();\n const oldInType = this.state.inType;\n node.params = [];\n this.state.inType = true;\n this.expect(47);\n while (!this.match(48)) {\n node.params.push(this.flowParseTypeOrImplicitInstantiation());\n if (!this.match(48)) {\n this.expect(12);\n }\n }\n this.expect(48);\n this.state.inType = oldInType;\n return this.finishNode(node, \"TypeParameterInstantiation\");\n }\n flowParseInterfaceType() {\n const node = this.startNode();\n this.expectContextual(129);\n node.extends = [];\n if (this.eat(81)) {\n do {\n node.extends.push(this.flowParseInterfaceExtends());\n } while (this.eat(12));\n }\n node.body = this.flowParseObjectType({\n allowStatic: false,\n allowExact: false,\n allowSpread: false,\n allowProto: false,\n allowInexact: false\n });\n return this.finishNode(node, \"InterfaceTypeAnnotation\");\n }\n flowParseObjectPropertyKey() {\n return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(true);\n }\n flowParseObjectTypeIndexer(node, isStatic, variance) {\n node.static = isStatic;\n if (this.lookahead().type === 14) {\n node.id = this.flowParseObjectPropertyKey();\n node.key = this.flowParseTypeInitialiser();\n } else {\n node.id = null;\n node.key = this.flowParseType();\n }\n this.expect(3);\n node.value = this.flowParseTypeInitialiser();\n node.variance = variance;\n return this.finishNode(node, \"ObjectTypeIndexer\");\n }\n flowParseObjectTypeInternalSlot(node, isStatic) {\n node.static = isStatic;\n node.id = this.flowParseObjectPropertyKey();\n this.expect(3);\n this.expect(3);\n if (this.match(47) || this.match(10)) {\n node.method = true;\n node.optional = false;\n node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));\n } else {\n node.method = false;\n if (this.eat(17)) {\n node.optional = true;\n }\n node.value = this.flowParseTypeInitialiser();\n }\n return this.finishNode(node, \"ObjectTypeInternalSlot\");\n }\n flowParseObjectTypeMethodish(node) {\n node.params = [];\n node.rest = null;\n node.typeParameters = null;\n node.this = null;\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n }\n this.expect(10);\n if (this.match(78)) {\n node.this = this.flowParseFunctionTypeParam(true);\n node.this.name = null;\n if (!this.match(11)) {\n this.expect(12);\n }\n }\n while (!this.match(11) && !this.match(21)) {\n node.params.push(this.flowParseFunctionTypeParam(false));\n if (!this.match(11)) {\n this.expect(12);\n }\n }\n if (this.eat(21)) {\n node.rest = this.flowParseFunctionTypeParam(false);\n }\n this.expect(11);\n node.returnType = this.flowParseTypeInitialiser();\n return this.finishNode(node, \"FunctionTypeAnnotation\");\n }\n flowParseObjectTypeCallProperty(node, isStatic) {\n const valueNode = this.startNode();\n node.static = isStatic;\n node.value = this.flowParseObjectTypeMethodish(valueNode);\n return this.finishNode(node, \"ObjectTypeCallProperty\");\n }\n flowParseObjectType({\n allowStatic,\n allowExact,\n allowSpread,\n allowProto,\n allowInexact\n }) {\n const oldInType = this.state.inType;\n this.state.inType = true;\n const nodeStart = this.startNode();\n nodeStart.callProperties = [];\n nodeStart.properties = [];\n nodeStart.indexers = [];\n nodeStart.internalSlots = [];\n let endDelim;\n let exact;\n let inexact = false;\n if (allowExact && this.match(6)) {\n this.expect(6);\n endDelim = 9;\n exact = true;\n } else {\n this.expect(5);\n endDelim = 8;\n exact = false;\n }\n nodeStart.exact = exact;\n while (!this.match(endDelim)) {\n let isStatic = false;\n let protoStartLoc = null;\n let inexactStartLoc = null;\n const node = this.startNode();\n if (allowProto && this.isContextual(118)) {\n const lookahead = this.lookahead();\n if (lookahead.type !== 14 && lookahead.type !== 17) {\n this.next();\n protoStartLoc = this.state.startLoc;\n allowStatic = false;\n }\n }\n if (allowStatic && this.isContextual(106)) {\n const lookahead = this.lookahead();\n if (lookahead.type !== 14 && lookahead.type !== 17) {\n this.next();\n isStatic = true;\n }\n }\n const variance = this.flowParseVariance();\n if (this.eat(0)) {\n if (protoStartLoc != null) {\n this.unexpected(protoStartLoc);\n }\n if (this.eat(0)) {\n if (variance) {\n this.unexpected(variance.loc.start);\n }\n nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));\n } else {\n nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));\n }\n } else if (this.match(10) || this.match(47)) {\n if (protoStartLoc != null) {\n this.unexpected(protoStartLoc);\n }\n if (variance) {\n this.unexpected(variance.loc.start);\n }\n nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));\n } else {\n let kind = \"init\";\n if (this.isContextual(99) || this.isContextual(104)) {\n const lookahead = this.lookahead();\n if (tokenIsLiteralPropertyName(lookahead.type)) {\n kind = this.state.value;\n this.next();\n }\n }\n const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);\n if (propOrInexact === null) {\n inexact = true;\n inexactStartLoc = this.state.lastTokStartLoc;\n } else {\n nodeStart.properties.push(propOrInexact);\n }\n }\n this.flowObjectTypeSemicolon();\n if (inexactStartLoc && !this.match(8) && !this.match(9)) {\n this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);\n }\n }\n this.expect(endDelim);\n if (allowSpread) {\n nodeStart.inexact = inexact;\n }\n const out = this.finishNode(nodeStart, \"ObjectTypeAnnotation\");\n this.state.inType = oldInType;\n return out;\n }\n flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {\n if (this.eat(21)) {\n const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);\n if (isInexactToken) {\n if (!allowSpread) {\n this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);\n } else if (!allowInexact) {\n this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);\n }\n if (variance) {\n this.raise(FlowErrors.InexactVariance, variance);\n }\n return null;\n }\n if (!allowSpread) {\n this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);\n }\n if (protoStartLoc != null) {\n this.unexpected(protoStartLoc);\n }\n if (variance) {\n this.raise(FlowErrors.SpreadVariance, variance);\n }\n node.argument = this.flowParseType();\n return this.finishNode(node, \"ObjectTypeSpreadProperty\");\n } else {\n node.key = this.flowParseObjectPropertyKey();\n node.static = isStatic;\n node.proto = protoStartLoc != null;\n node.kind = kind;\n let optional = false;\n if (this.match(47) || this.match(10)) {\n node.method = true;\n if (protoStartLoc != null) {\n this.unexpected(protoStartLoc);\n }\n if (variance) {\n this.unexpected(variance.loc.start);\n }\n node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));\n if (kind === \"get\" || kind === \"set\") {\n this.flowCheckGetterSetterParams(node);\n }\n if (!allowSpread && node.key.name === \"constructor\" && node.value.this) {\n this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);\n }\n } else {\n if (kind !== \"init\") this.unexpected();\n node.method = false;\n if (this.eat(17)) {\n optional = true;\n }\n node.value = this.flowParseTypeInitialiser();\n node.variance = variance;\n }\n node.optional = optional;\n return this.finishNode(node, \"ObjectTypeProperty\");\n }\n }\n flowCheckGetterSetterParams(property) {\n const paramCount = property.kind === \"get\" ? 0 : 1;\n const length = property.value.params.length + (property.value.rest ? 1 : 0);\n if (property.value.this) {\n this.raise(property.kind === \"get\" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);\n }\n if (length !== paramCount) {\n this.raise(property.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity, property);\n }\n if (property.kind === \"set\" && property.value.rest) {\n this.raise(Errors.BadSetterRestParameter, property);\n }\n }\n flowObjectTypeSemicolon() {\n if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {\n this.unexpected();\n }\n }\n flowParseQualifiedTypeIdentifier(startLoc, id) {\n startLoc != null ? startLoc : startLoc = this.state.startLoc;\n let node = id || this.flowParseRestrictedIdentifier(true);\n while (this.eat(16)) {\n const node2 = this.startNodeAt(startLoc);\n node2.qualification = node;\n node2.id = this.flowParseRestrictedIdentifier(true);\n node = this.finishNode(node2, \"QualifiedTypeIdentifier\");\n }\n return node;\n }\n flowParseGenericType(startLoc, id) {\n const node = this.startNodeAt(startLoc);\n node.typeParameters = null;\n node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterInstantiation();\n }\n return this.finishNode(node, \"GenericTypeAnnotation\");\n }\n flowParseTypeofType() {\n const node = this.startNode();\n this.expect(87);\n node.argument = this.flowParsePrimaryType();\n return this.finishNode(node, \"TypeofTypeAnnotation\");\n }\n flowParseTupleType() {\n const node = this.startNode();\n node.types = [];\n this.expect(0);\n while (this.state.pos < this.length && !this.match(3)) {\n node.types.push(this.flowParseType());\n if (this.match(3)) break;\n this.expect(12);\n }\n this.expect(3);\n return this.finishNode(node, \"TupleTypeAnnotation\");\n }\n flowParseFunctionTypeParam(first) {\n let name = null;\n let optional = false;\n let typeAnnotation = null;\n const node = this.startNode();\n const lh = this.lookahead();\n const isThis = this.state.type === 78;\n if (lh.type === 14 || lh.type === 17) {\n if (isThis && !first) {\n this.raise(FlowErrors.ThisParamMustBeFirst, node);\n }\n name = this.parseIdentifier(isThis);\n if (this.eat(17)) {\n optional = true;\n if (isThis) {\n this.raise(FlowErrors.ThisParamMayNotBeOptional, node);\n }\n }\n typeAnnotation = this.flowParseTypeInitialiser();\n } else {\n typeAnnotation = this.flowParseType();\n }\n node.name = name;\n node.optional = optional;\n node.typeAnnotation = typeAnnotation;\n return this.finishNode(node, \"FunctionTypeParam\");\n }\n reinterpretTypeAsFunctionTypeParam(type) {\n const node = this.startNodeAt(type.loc.start);\n node.name = null;\n node.optional = false;\n node.typeAnnotation = type;\n return this.finishNode(node, \"FunctionTypeParam\");\n }\n flowParseFunctionTypeParams(params = []) {\n let rest = null;\n let _this = null;\n if (this.match(78)) {\n _this = this.flowParseFunctionTypeParam(true);\n _this.name = null;\n if (!this.match(11)) {\n this.expect(12);\n }\n }\n while (!this.match(11) && !this.match(21)) {\n params.push(this.flowParseFunctionTypeParam(false));\n if (!this.match(11)) {\n this.expect(12);\n }\n }\n if (this.eat(21)) {\n rest = this.flowParseFunctionTypeParam(false);\n }\n return {\n params,\n rest,\n _this\n };\n }\n flowIdentToTypeAnnotation(startLoc, node, id) {\n switch (id.name) {\n case \"any\":\n return this.finishNode(node, \"AnyTypeAnnotation\");\n case \"bool\":\n case \"boolean\":\n return this.finishNode(node, \"BooleanTypeAnnotation\");\n case \"mixed\":\n return this.finishNode(node, \"MixedTypeAnnotation\");\n case \"empty\":\n return this.finishNode(node, \"EmptyTypeAnnotation\");\n case \"number\":\n return this.finishNode(node, \"NumberTypeAnnotation\");\n case \"string\":\n return this.finishNode(node, \"StringTypeAnnotation\");\n case \"symbol\":\n return this.finishNode(node, \"SymbolTypeAnnotation\");\n default:\n this.checkNotUnderscore(id.name);\n return this.flowParseGenericType(startLoc, id);\n }\n }\n flowParsePrimaryType() {\n const startLoc = this.state.startLoc;\n const node = this.startNode();\n let tmp;\n let type;\n let isGroupedType = false;\n const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n switch (this.state.type) {\n case 5:\n return this.flowParseObjectType({\n allowStatic: false,\n allowExact: false,\n allowSpread: true,\n allowProto: false,\n allowInexact: true\n });\n case 6:\n return this.flowParseObjectType({\n allowStatic: false,\n allowExact: true,\n allowSpread: true,\n allowProto: false,\n allowInexact: false\n });\n case 0:\n this.state.noAnonFunctionType = false;\n type = this.flowParseTupleType();\n this.state.noAnonFunctionType = oldNoAnonFunctionType;\n return type;\n case 47:\n {\n const node = this.startNode();\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n this.expect(10);\n tmp = this.flowParseFunctionTypeParams();\n node.params = tmp.params;\n node.rest = tmp.rest;\n node.this = tmp._this;\n this.expect(11);\n this.expect(19);\n node.returnType = this.flowParseType();\n return this.finishNode(node, \"FunctionTypeAnnotation\");\n }\n case 10:\n {\n const node = this.startNode();\n this.next();\n if (!this.match(11) && !this.match(21)) {\n if (tokenIsIdentifier(this.state.type) || this.match(78)) {\n const token = this.lookahead().type;\n isGroupedType = token !== 17 && token !== 14;\n } else {\n isGroupedType = true;\n }\n }\n if (isGroupedType) {\n this.state.noAnonFunctionType = false;\n type = this.flowParseType();\n this.state.noAnonFunctionType = oldNoAnonFunctionType;\n if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {\n this.expect(11);\n return type;\n } else {\n this.eat(12);\n }\n }\n if (type) {\n tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);\n } else {\n tmp = this.flowParseFunctionTypeParams();\n }\n node.params = tmp.params;\n node.rest = tmp.rest;\n node.this = tmp._this;\n this.expect(11);\n this.expect(19);\n node.returnType = this.flowParseType();\n node.typeParameters = null;\n return this.finishNode(node, \"FunctionTypeAnnotation\");\n }\n case 134:\n return this.parseLiteral(this.state.value, \"StringLiteralTypeAnnotation\");\n case 85:\n case 86:\n node.value = this.match(85);\n this.next();\n return this.finishNode(node, \"BooleanLiteralTypeAnnotation\");\n case 53:\n if (this.state.value === \"-\") {\n this.next();\n if (this.match(135)) {\n return this.parseLiteralAtNode(-this.state.value, \"NumberLiteralTypeAnnotation\", node);\n }\n if (this.match(136)) {\n return this.parseLiteralAtNode(-this.state.value, \"BigIntLiteralTypeAnnotation\", node);\n }\n throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);\n }\n throw this.unexpected();\n case 135:\n return this.parseLiteral(this.state.value, \"NumberLiteralTypeAnnotation\");\n case 136:\n return this.parseLiteral(this.state.value, \"BigIntLiteralTypeAnnotation\");\n case 88:\n this.next();\n return this.finishNode(node, \"VoidTypeAnnotation\");\n case 84:\n this.next();\n return this.finishNode(node, \"NullLiteralTypeAnnotation\");\n case 78:\n this.next();\n return this.finishNode(node, \"ThisTypeAnnotation\");\n case 55:\n this.next();\n return this.finishNode(node, \"ExistsTypeAnnotation\");\n case 87:\n return this.flowParseTypeofType();\n default:\n if (tokenIsKeyword(this.state.type)) {\n const label = tokenLabelName(this.state.type);\n this.next();\n return super.createIdentifier(node, label);\n } else if (tokenIsIdentifier(this.state.type)) {\n if (this.isContextual(129)) {\n return this.flowParseInterfaceType();\n }\n return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());\n }\n }\n throw this.unexpected();\n }\n flowParsePostfixType() {\n const startLoc = this.state.startLoc;\n let type = this.flowParsePrimaryType();\n let seenOptionalIndexedAccess = false;\n while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {\n const node = this.startNodeAt(startLoc);\n const optional = this.eat(18);\n seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;\n this.expect(0);\n if (!optional && this.match(3)) {\n node.elementType = type;\n this.next();\n type = this.finishNode(node, \"ArrayTypeAnnotation\");\n } else {\n node.objectType = type;\n node.indexType = this.flowParseType();\n this.expect(3);\n if (seenOptionalIndexedAccess) {\n node.optional = optional;\n type = this.finishNode(node, \"OptionalIndexedAccessType\");\n } else {\n type = this.finishNode(node, \"IndexedAccessType\");\n }\n }\n }\n return type;\n }\n flowParsePrefixType() {\n const node = this.startNode();\n if (this.eat(17)) {\n node.typeAnnotation = this.flowParsePrefixType();\n return this.finishNode(node, \"NullableTypeAnnotation\");\n } else {\n return this.flowParsePostfixType();\n }\n }\n flowParseAnonFunctionWithoutParens() {\n const param = this.flowParsePrefixType();\n if (!this.state.noAnonFunctionType && this.eat(19)) {\n const node = this.startNodeAt(param.loc.start);\n node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];\n node.rest = null;\n node.this = null;\n node.returnType = this.flowParseType();\n node.typeParameters = null;\n return this.finishNode(node, \"FunctionTypeAnnotation\");\n }\n return param;\n }\n flowParseIntersectionType() {\n const node = this.startNode();\n this.eat(45);\n const type = this.flowParseAnonFunctionWithoutParens();\n node.types = [type];\n while (this.eat(45)) {\n node.types.push(this.flowParseAnonFunctionWithoutParens());\n }\n return node.types.length === 1 ? type : this.finishNode(node, \"IntersectionTypeAnnotation\");\n }\n flowParseUnionType() {\n const node = this.startNode();\n this.eat(43);\n const type = this.flowParseIntersectionType();\n node.types = [type];\n while (this.eat(43)) {\n node.types.push(this.flowParseIntersectionType());\n }\n return node.types.length === 1 ? type : this.finishNode(node, \"UnionTypeAnnotation\");\n }\n flowParseType() {\n const oldInType = this.state.inType;\n this.state.inType = true;\n const type = this.flowParseUnionType();\n this.state.inType = oldInType;\n return type;\n }\n flowParseTypeOrImplicitInstantiation() {\n if (this.state.type === 132 && this.state.value === \"_\") {\n const startLoc = this.state.startLoc;\n const node = this.parseIdentifier();\n return this.flowParseGenericType(startLoc, node);\n } else {\n return this.flowParseType();\n }\n }\n flowParseTypeAnnotation() {\n const node = this.startNode();\n node.typeAnnotation = this.flowParseTypeInitialiser();\n return this.finishNode(node, \"TypeAnnotation\");\n }\n flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {\n const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();\n if (this.match(14)) {\n ident.typeAnnotation = this.flowParseTypeAnnotation();\n this.resetEndLocation(ident);\n }\n return ident;\n }\n typeCastToParameter(node) {\n node.expression.typeAnnotation = node.typeAnnotation;\n this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n return node.expression;\n }\n flowParseVariance() {\n let variance = null;\n if (this.match(53)) {\n variance = this.startNode();\n if (this.state.value === \"+\") {\n variance.kind = \"plus\";\n } else {\n variance.kind = \"minus\";\n }\n this.next();\n return this.finishNode(variance, \"Variance\");\n }\n return variance;\n }\n parseFunctionBody(node, allowExpressionBody, isMethod = false) {\n if (allowExpressionBody) {\n this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));\n return;\n }\n super.parseFunctionBody(node, false, isMethod);\n }\n parseFunctionBodyAndFinish(node, type, isMethod = false) {\n if (this.match(14)) {\n const typeNode = this.startNode();\n [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, \"TypeAnnotation\") : null;\n }\n return super.parseFunctionBodyAndFinish(node, type, isMethod);\n }\n parseStatementLike(flags) {\n if (this.state.strict && this.isContextual(129)) {\n const lookahead = this.lookahead();\n if (tokenIsKeywordOrIdentifier(lookahead.type)) {\n const node = this.startNode();\n this.next();\n return this.flowParseInterface(node);\n }\n } else if (this.isContextual(126)) {\n const node = this.startNode();\n this.next();\n return this.flowParseEnumDeclaration(node);\n }\n const stmt = super.parseStatementLike(flags);\n if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {\n this.flowPragma = null;\n }\n return stmt;\n }\n parseExpressionStatement(node, expr, decorators) {\n if (expr.type === \"Identifier\") {\n if (expr.name === \"declare\") {\n if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {\n return this.flowParseDeclare(node);\n }\n } else if (tokenIsIdentifier(this.state.type)) {\n if (expr.name === \"interface\") {\n return this.flowParseInterface(node);\n } else if (expr.name === \"type\") {\n return this.flowParseTypeAlias(node);\n } else if (expr.name === \"opaque\") {\n return this.flowParseOpaqueType(node, false);\n }\n }\n }\n return super.parseExpressionStatement(node, expr, decorators);\n }\n shouldParseExportDeclaration() {\n const {\n type\n } = this.state;\n if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {\n return !this.state.containsEsc;\n }\n return super.shouldParseExportDeclaration();\n }\n isExportDefaultSpecifier() {\n const {\n type\n } = this.state;\n if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {\n return this.state.containsEsc;\n }\n return super.isExportDefaultSpecifier();\n }\n parseExportDefaultExpression() {\n if (this.isContextual(126)) {\n const node = this.startNode();\n this.next();\n return this.flowParseEnumDeclaration(node);\n }\n return super.parseExportDefaultExpression();\n }\n parseConditional(expr, startLoc, refExpressionErrors) {\n if (!this.match(17)) return expr;\n if (this.state.maybeInArrowParameters) {\n const nextCh = this.lookaheadCharCode();\n if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {\n this.setOptionalParametersError(refExpressionErrors);\n return expr;\n }\n }\n this.expect(17);\n const state = this.state.clone();\n const originalNoArrowAt = this.state.noArrowAt;\n const node = this.startNodeAt(startLoc);\n let {\n consequent,\n failed\n } = this.tryParseConditionalConsequent();\n let [valid, invalid] = this.getArrowLikeExpressions(consequent);\n if (failed || invalid.length > 0) {\n const noArrowAt = [...originalNoArrowAt];\n if (invalid.length > 0) {\n this.state = state;\n this.state.noArrowAt = noArrowAt;\n for (let i = 0; i < invalid.length; i++) {\n noArrowAt.push(invalid[i].start);\n }\n ({\n consequent,\n failed\n } = this.tryParseConditionalConsequent());\n [valid, invalid] = this.getArrowLikeExpressions(consequent);\n }\n if (failed && valid.length > 1) {\n this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);\n }\n if (failed && valid.length === 1) {\n this.state = state;\n noArrowAt.push(valid[0].start);\n this.state.noArrowAt = noArrowAt;\n ({\n consequent,\n failed\n } = this.tryParseConditionalConsequent());\n }\n }\n this.getArrowLikeExpressions(consequent, true);\n this.state.noArrowAt = originalNoArrowAt;\n this.expect(14);\n node.test = expr;\n node.consequent = consequent;\n node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined));\n return this.finishNode(node, \"ConditionalExpression\");\n }\n tryParseConditionalConsequent() {\n this.state.noArrowParamsConversionAt.push(this.state.start);\n const consequent = this.parseMaybeAssignAllowIn();\n const failed = !this.match(14);\n this.state.noArrowParamsConversionAt.pop();\n return {\n consequent,\n failed\n };\n }\n getArrowLikeExpressions(node, disallowInvalid) {\n const stack = [node];\n const arrows = [];\n while (stack.length !== 0) {\n const node = stack.pop();\n if (node.type === \"ArrowFunctionExpression\" && node.body.type !== \"BlockStatement\") {\n if (node.typeParameters || !node.returnType) {\n this.finishArrowValidation(node);\n } else {\n arrows.push(node);\n }\n stack.push(node.body);\n } else if (node.type === \"ConditionalExpression\") {\n stack.push(node.consequent);\n stack.push(node.alternate);\n }\n }\n if (disallowInvalid) {\n arrows.forEach(node => this.finishArrowValidation(node));\n return [arrows, []];\n }\n return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));\n }\n finishArrowValidation(node) {\n var _node$extra;\n this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);\n this.scope.enter(514 | 4);\n super.checkParams(node, false, true);\n this.scope.exit();\n }\n forwardNoArrowParamsConversionAt(node, parse) {\n let result;\n if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {\n this.state.noArrowParamsConversionAt.push(this.state.start);\n result = parse();\n this.state.noArrowParamsConversionAt.pop();\n } else {\n result = parse();\n }\n return result;\n }\n parseParenItem(node, startLoc) {\n const newNode = super.parseParenItem(node, startLoc);\n if (this.eat(17)) {\n newNode.optional = true;\n this.resetEndLocation(node);\n }\n if (this.match(14)) {\n const typeCastNode = this.startNodeAt(startLoc);\n typeCastNode.expression = newNode;\n typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();\n return this.finishNode(typeCastNode, \"TypeCastExpression\");\n }\n return newNode;\n }\n assertModuleNodeAllowed(node) {\n if (node.type === \"ImportDeclaration\" && (node.importKind === \"type\" || node.importKind === \"typeof\") || node.type === \"ExportNamedDeclaration\" && node.exportKind === \"type\" || node.type === \"ExportAllDeclaration\" && node.exportKind === \"type\") {\n return;\n }\n super.assertModuleNodeAllowed(node);\n }\n parseExportDeclaration(node) {\n if (this.isContextual(130)) {\n node.exportKind = \"type\";\n const declarationNode = this.startNode();\n this.next();\n if (this.match(5)) {\n node.specifiers = this.parseExportSpecifiers(true);\n super.parseExportFrom(node);\n return null;\n } else {\n return this.flowParseTypeAlias(declarationNode);\n }\n } else if (this.isContextual(131)) {\n node.exportKind = \"type\";\n const declarationNode = this.startNode();\n this.next();\n return this.flowParseOpaqueType(declarationNode, false);\n } else if (this.isContextual(129)) {\n node.exportKind = \"type\";\n const declarationNode = this.startNode();\n this.next();\n return this.flowParseInterface(declarationNode);\n } else if (this.isContextual(126)) {\n node.exportKind = \"value\";\n const declarationNode = this.startNode();\n this.next();\n return this.flowParseEnumDeclaration(declarationNode);\n } else {\n return super.parseExportDeclaration(node);\n }\n }\n eatExportStar(node) {\n if (super.eatExportStar(node)) return true;\n if (this.isContextual(130) && this.lookahead().type === 55) {\n node.exportKind = \"type\";\n this.next();\n this.next();\n return true;\n }\n return false;\n }\n maybeParseExportNamespaceSpecifier(node) {\n const {\n startLoc\n } = this.state;\n const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);\n if (hasNamespace && node.exportKind === \"type\") {\n this.unexpected(startLoc);\n }\n return hasNamespace;\n }\n parseClassId(node, isStatement, optionalId) {\n super.parseClassId(node, isStatement, optionalId);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n }\n }\n parseClassMember(classBody, member, state) {\n const {\n startLoc\n } = this.state;\n if (this.isContextual(125)) {\n if (super.parseClassMemberFromModifier(classBody, member)) {\n return;\n }\n member.declare = true;\n }\n super.parseClassMember(classBody, member, state);\n if (member.declare) {\n if (member.type !== \"ClassProperty\" && member.type !== \"ClassPrivateProperty\" && member.type !== \"PropertyDefinition\") {\n this.raise(FlowErrors.DeclareClassElement, startLoc);\n } else if (member.value) {\n this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);\n }\n }\n }\n isIterator(word) {\n return word === \"iterator\" || word === \"asyncIterator\";\n }\n readIterator() {\n const word = super.readWord1();\n const fullWord = \"@@\" + word;\n if (!this.isIterator(word) || !this.state.inType) {\n this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {\n identifierName: fullWord\n });\n }\n this.finishToken(132, fullWord);\n }\n getTokenFromCode(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (code === 123 && next === 124) {\n this.finishOp(6, 2);\n } else if (this.state.inType && (code === 62 || code === 60)) {\n this.finishOp(code === 62 ? 48 : 47, 1);\n } else if (this.state.inType && code === 63) {\n if (next === 46) {\n this.finishOp(18, 2);\n } else {\n this.finishOp(17, 1);\n }\n } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {\n this.state.pos += 2;\n this.readIterator();\n } else {\n super.getTokenFromCode(code);\n }\n }\n isAssignable(node, isBinding) {\n if (node.type === \"TypeCastExpression\") {\n return this.isAssignable(node.expression, isBinding);\n } else {\n return super.isAssignable(node, isBinding);\n }\n }\n toAssignable(node, isLHS = false) {\n if (!isLHS && node.type === \"AssignmentExpression\" && node.left.type === \"TypeCastExpression\") {\n node.left = this.typeCastToParameter(node.left);\n }\n super.toAssignable(node, isLHS);\n }\n toAssignableList(exprList, trailingCommaLoc, isLHS) {\n for (let i = 0; i < exprList.length; i++) {\n const expr = exprList[i];\n if ((expr == null ? void 0 : expr.type) === \"TypeCastExpression\") {\n exprList[i] = this.typeCastToParameter(expr);\n }\n }\n super.toAssignableList(exprList, trailingCommaLoc, isLHS);\n }\n toReferencedList(exprList, isParenthesizedExpr) {\n for (let i = 0; i < exprList.length; i++) {\n var _expr$extra;\n const expr = exprList[i];\n if (expr && expr.type === \"TypeCastExpression\" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {\n this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);\n }\n }\n return exprList;\n }\n parseArrayLike(close, isTuple, refExpressionErrors) {\n const node = super.parseArrayLike(close, isTuple, refExpressionErrors);\n if (refExpressionErrors != null && !this.state.maybeInArrowParameters) {\n this.toReferencedList(node.elements);\n }\n return node;\n }\n isValidLVal(type, disallowCallExpression, isParenthesized, binding) {\n return type === \"TypeCastExpression\" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding);\n }\n parseClassProperty(node) {\n if (this.match(14)) {\n node.typeAnnotation = this.flowParseTypeAnnotation();\n }\n return super.parseClassProperty(node);\n }\n parseClassPrivateProperty(node) {\n if (this.match(14)) {\n node.typeAnnotation = this.flowParseTypeAnnotation();\n }\n return super.parseClassPrivateProperty(node);\n }\n isClassMethod() {\n return this.match(47) || super.isClassMethod();\n }\n isClassProperty() {\n return this.match(14) || super.isClassProperty();\n }\n isNonstaticConstructor(method) {\n return !this.match(14) && super.isNonstaticConstructor(method);\n }\n pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n if (method.variance) {\n this.unexpected(method.variance.loc.start);\n }\n delete method.variance;\n if (this.match(47)) {\n method.typeParameters = this.flowParseTypeParameterDeclaration();\n }\n super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n if (method.params && isConstructor) {\n const params = method.params;\n if (params.length > 0 && this.isThisParam(params[0])) {\n this.raise(FlowErrors.ThisParamBannedInConstructor, method);\n }\n } else if (method.type === \"MethodDefinition\" && isConstructor && method.value.params) {\n const params = method.value.params;\n if (params.length > 0 && this.isThisParam(params[0])) {\n this.raise(FlowErrors.ThisParamBannedInConstructor, method);\n }\n }\n }\n pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n if (method.variance) {\n this.unexpected(method.variance.loc.start);\n }\n delete method.variance;\n if (this.match(47)) {\n method.typeParameters = this.flowParseTypeParameterDeclaration();\n }\n super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n }\n parseClassSuper(node) {\n super.parseClassSuper(node);\n if (node.superClass && (this.match(47) || this.match(51))) {\n node.superTypeParameters = this.flowParseTypeParameterInstantiationInExpression();\n }\n if (this.isContextual(113)) {\n this.next();\n const implemented = node.implements = [];\n do {\n const node = this.startNode();\n node.id = this.flowParseRestrictedIdentifier(true);\n if (this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterInstantiation();\n } else {\n node.typeParameters = null;\n }\n implemented.push(this.finishNode(node, \"ClassImplements\"));\n } while (this.eat(12));\n }\n }\n checkGetterSetterParams(method) {\n super.checkGetterSetterParams(method);\n const params = this.getObjectOrClassMethodParams(method);\n if (params.length > 0) {\n const param = params[0];\n if (this.isThisParam(param) && method.kind === \"get\") {\n this.raise(FlowErrors.GetterMayNotHaveThisParam, param);\n } else if (this.isThisParam(param)) {\n this.raise(FlowErrors.SetterMayNotHaveThisParam, param);\n }\n }\n }\n parsePropertyNamePrefixOperator(node) {\n node.variance = this.flowParseVariance();\n }\n parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n if (prop.variance) {\n this.unexpected(prop.variance.loc.start);\n }\n delete prop.variance;\n let typeParameters;\n if (this.match(47) && !isAccessor) {\n typeParameters = this.flowParseTypeParameterDeclaration();\n if (!this.match(10)) this.unexpected();\n }\n const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n if (typeParameters) {\n (result.value || result).typeParameters = typeParameters;\n }\n return result;\n }\n parseFunctionParamType(param) {\n if (this.eat(17)) {\n if (param.type !== \"Identifier\") {\n this.raise(FlowErrors.PatternIsOptional, param);\n }\n if (this.isThisParam(param)) {\n this.raise(FlowErrors.ThisParamMayNotBeOptional, param);\n }\n param.optional = true;\n }\n if (this.match(14)) {\n param.typeAnnotation = this.flowParseTypeAnnotation();\n } else if (this.isThisParam(param)) {\n this.raise(FlowErrors.ThisParamAnnotationRequired, param);\n }\n if (this.match(29) && this.isThisParam(param)) {\n this.raise(FlowErrors.ThisParamNoDefault, param);\n }\n this.resetEndLocation(param);\n return param;\n }\n parseMaybeDefault(startLoc, left) {\n const node = super.parseMaybeDefault(startLoc, left);\n if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);\n }\n return node;\n }\n checkImportReflection(node) {\n super.checkImportReflection(node);\n if (node.module && node.importKind !== \"value\") {\n this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);\n }\n }\n parseImportSpecifierLocal(node, specifier, type) {\n specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();\n node.specifiers.push(this.finishImportSpecifier(specifier, type));\n }\n isPotentialImportPhase(isExport) {\n if (super.isPotentialImportPhase(isExport)) return true;\n if (this.isContextual(130)) {\n if (!isExport) return true;\n const ch = this.lookaheadCharCode();\n return ch === 123 || ch === 42;\n }\n return !isExport && this.isContextual(87);\n }\n applyImportPhase(node, isExport, phase, loc) {\n super.applyImportPhase(node, isExport, phase, loc);\n if (isExport) {\n if (!phase && this.match(65)) {\n return;\n }\n node.exportKind = phase === \"type\" ? phase : \"value\";\n } else {\n if (phase === \"type\" && this.match(55)) this.unexpected();\n node.importKind = phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n }\n }\n parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n const firstIdent = specifier.imported;\n let specifierTypeKind = null;\n if (firstIdent.type === \"Identifier\") {\n if (firstIdent.name === \"type\") {\n specifierTypeKind = \"type\";\n } else if (firstIdent.name === \"typeof\") {\n specifierTypeKind = \"typeof\";\n }\n }\n let isBinding = false;\n if (this.isContextual(93) && !this.isLookaheadContextual(\"as\")) {\n const as_ident = this.parseIdentifier(true);\n if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {\n specifier.imported = as_ident;\n specifier.importKind = specifierTypeKind;\n specifier.local = this.cloneIdentifier(as_ident);\n } else {\n specifier.imported = firstIdent;\n specifier.importKind = null;\n specifier.local = this.parseIdentifier();\n }\n } else {\n if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {\n specifier.imported = this.parseIdentifier(true);\n specifier.importKind = specifierTypeKind;\n } else {\n if (importedIsString) {\n throw this.raise(Errors.ImportBindingIsString, specifier, {\n importName: firstIdent.value\n });\n }\n specifier.imported = firstIdent;\n specifier.importKind = null;\n }\n if (this.eatContextual(93)) {\n specifier.local = this.parseIdentifier();\n } else {\n isBinding = true;\n specifier.local = this.cloneIdentifier(specifier.imported);\n }\n }\n const specifierIsTypeImport = hasTypeImportKind(specifier);\n if (isInTypeOnlyImport && specifierIsTypeImport) {\n this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);\n }\n if (isInTypeOnlyImport || specifierIsTypeImport) {\n this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);\n }\n if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {\n this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);\n }\n return this.finishImportSpecifier(specifier, \"ImportSpecifier\");\n }\n parseBindingAtom() {\n switch (this.state.type) {\n case 78:\n return this.parseIdentifier(true);\n default:\n return super.parseBindingAtom();\n }\n }\n parseFunctionParams(node, isConstructor) {\n const kind = node.kind;\n if (kind !== \"get\" && kind !== \"set\" && this.match(47)) {\n node.typeParameters = this.flowParseTypeParameterDeclaration();\n }\n super.parseFunctionParams(node, isConstructor);\n }\n parseVarId(decl, kind) {\n super.parseVarId(decl, kind);\n if (this.match(14)) {\n decl.id.typeAnnotation = this.flowParseTypeAnnotation();\n this.resetEndLocation(decl.id);\n }\n }\n parseAsyncArrowFromCallExpression(node, call) {\n if (this.match(14)) {\n const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n this.state.noAnonFunctionType = true;\n node.returnType = this.flowParseTypeAnnotation();\n this.state.noAnonFunctionType = oldNoAnonFunctionType;\n }\n return super.parseAsyncArrowFromCallExpression(node, call);\n }\n shouldParseAsyncArrow() {\n return this.match(14) || super.shouldParseAsyncArrow();\n }\n parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n var _jsx;\n let state = null;\n let jsx;\n if (this.hasPlugin(\"jsx\") && (this.match(143) || this.match(47))) {\n state = this.state.clone();\n jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n if (!jsx.error) return jsx.node;\n const {\n context\n } = this.state;\n const currentContext = context[context.length - 1];\n if (currentContext === types.j_oTag || currentContext === types.j_expr) {\n context.pop();\n }\n }\n if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {\n var _jsx2, _jsx3;\n state = state || this.state.clone();\n let typeParameters;\n const arrow = this.tryParse(abort => {\n var _arrowExpression$extr;\n typeParameters = this.flowParseTypeParameterDeclaration();\n const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {\n const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n this.resetStartLocationFromNode(result, typeParameters);\n return result;\n });\n if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();\n const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);\n if (expr.type !== \"ArrowFunctionExpression\") abort();\n expr.typeParameters = typeParameters;\n this.resetStartLocationFromNode(expr, typeParameters);\n return arrowExpression;\n }, state);\n let arrowExpression = null;\n if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === \"ArrowFunctionExpression\") {\n if (!arrow.error && !arrow.aborted) {\n if (arrow.node.async) {\n this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);\n }\n return arrow.node;\n }\n arrowExpression = arrow.node;\n }\n if ((_jsx2 = jsx) != null && _jsx2.node) {\n this.state = jsx.failState;\n return jsx.node;\n }\n if (arrowExpression) {\n this.state = arrow.failState;\n return arrowExpression;\n }\n if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;\n if (arrow.thrown) throw arrow.error;\n throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);\n }\n return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n }\n parseArrow(node) {\n if (this.match(14)) {\n const result = this.tryParse(() => {\n const oldNoAnonFunctionType = this.state.noAnonFunctionType;\n this.state.noAnonFunctionType = true;\n const typeNode = this.startNode();\n [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();\n this.state.noAnonFunctionType = oldNoAnonFunctionType;\n if (this.canInsertSemicolon()) this.unexpected();\n if (!this.match(19)) this.unexpected();\n return typeNode;\n });\n if (result.thrown) return null;\n if (result.error) this.state = result.failState;\n node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, \"TypeAnnotation\") : null;\n }\n return super.parseArrow(node);\n }\n shouldParseArrow(params) {\n return this.match(14) || super.shouldParseArrow(params);\n }\n setArrowFunctionParameters(node, params) {\n if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {\n node.params = params;\n } else {\n super.setArrowFunctionParameters(node, params);\n }\n }\n checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {\n if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {\n return;\n }\n for (let i = 0; i < node.params.length; i++) {\n if (this.isThisParam(node.params[i]) && i > 0) {\n this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);\n }\n }\n super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);\n }\n parseParenAndDistinguishExpression(canBeArrow) {\n return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));\n }\n parseSubscripts(base, startLoc, noCalls) {\n if (base.type === \"Identifier\" && base.name === \"async\" && this.state.noArrowAt.includes(startLoc.index)) {\n this.next();\n const node = this.startNodeAt(startLoc);\n node.callee = base;\n node.arguments = super.parseCallExpressionArguments();\n base = this.finishNode(node, \"CallExpression\");\n } else if (base.type === \"Identifier\" && base.name === \"async\" && this.match(47)) {\n const state = this.state.clone();\n const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);\n if (!arrow.error && !arrow.aborted) return arrow.node;\n const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);\n if (result.node && !result.error) return result.node;\n if (arrow.node) {\n this.state = arrow.failState;\n return arrow.node;\n }\n if (result.node) {\n this.state = result.failState;\n return result.node;\n }\n throw arrow.error || result.error;\n }\n return super.parseSubscripts(base, startLoc, noCalls);\n }\n parseSubscript(base, startLoc, noCalls, subscriptState) {\n if (this.match(18) && this.isLookaheadToken_lt()) {\n subscriptState.optionalChainMember = true;\n if (noCalls) {\n subscriptState.stop = true;\n return base;\n }\n this.next();\n const node = this.startNodeAt(startLoc);\n node.callee = base;\n node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();\n this.expect(10);\n node.arguments = this.parseCallExpressionArguments();\n node.optional = true;\n return this.finishCallExpression(node, true);\n } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {\n const node = this.startNodeAt(startLoc);\n node.callee = base;\n const result = this.tryParse(() => {\n node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();\n this.expect(10);\n node.arguments = super.parseCallExpressionArguments();\n if (subscriptState.optionalChainMember) {\n node.optional = false;\n }\n return this.finishCallExpression(node, subscriptState.optionalChainMember);\n });\n if (result.node) {\n if (result.error) this.state = result.failState;\n return result.node;\n }\n }\n return super.parseSubscript(base, startLoc, noCalls, subscriptState);\n }\n parseNewCallee(node) {\n super.parseNewCallee(node);\n let targs = null;\n if (this.shouldParseTypes() && this.match(47)) {\n targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;\n }\n node.typeArguments = targs;\n }\n parseAsyncArrowWithTypeParameters(startLoc) {\n const node = this.startNodeAt(startLoc);\n this.parseFunctionParams(node, false);\n if (!this.parseArrow(node)) return;\n return super.parseArrowExpression(node, undefined, true);\n }\n readToken_mult_modulo(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (code === 42 && next === 47 && this.state.hasFlowComment) {\n this.state.hasFlowComment = false;\n this.state.pos += 2;\n this.nextToken();\n return;\n }\n super.readToken_mult_modulo(code);\n }\n readToken_pipe_amp(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (code === 124 && next === 125) {\n this.finishOp(9, 2);\n return;\n }\n super.readToken_pipe_amp(code);\n }\n parseTopLevel(file, program) {\n const fileNode = super.parseTopLevel(file, program);\n if (this.state.hasFlowComment) {\n this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());\n }\n return fileNode;\n }\n skipBlockComment() {\n if (this.hasPlugin(\"flowComments\") && this.skipFlowComment()) {\n if (this.state.hasFlowComment) {\n throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);\n }\n this.hasFlowCommentCompletion();\n const commentSkip = this.skipFlowComment();\n if (commentSkip) {\n this.state.pos += commentSkip;\n this.state.hasFlowComment = true;\n }\n return;\n }\n return super.skipBlockComment(this.state.hasFlowComment ? \"*-/\" : \"*/\");\n }\n skipFlowComment() {\n const {\n pos\n } = this.state;\n let shiftToFirstNonWhiteSpace = 2;\n while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {\n shiftToFirstNonWhiteSpace++;\n }\n const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);\n const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);\n if (ch2 === 58 && ch3 === 58) {\n return shiftToFirstNonWhiteSpace + 2;\n }\n if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === \"flow-include\") {\n return shiftToFirstNonWhiteSpace + 12;\n }\n if (ch2 === 58 && ch3 !== 58) {\n return shiftToFirstNonWhiteSpace;\n }\n return false;\n }\n hasFlowCommentCompletion() {\n const end = this.input.indexOf(\"*/\", this.state.pos);\n if (end === -1) {\n throw this.raise(Errors.UnterminatedComment, this.state.curPosition());\n }\n }\n flowEnumErrorBooleanMemberNotInitialized(loc, {\n enumName,\n memberName\n }) {\n this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {\n memberName,\n enumName\n });\n }\n flowEnumErrorInvalidMemberInitializer(loc, enumContext) {\n return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === \"symbol\" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);\n }\n flowEnumErrorNumberMemberNotInitialized(loc, details) {\n this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);\n }\n flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {\n this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);\n }\n flowEnumMemberInit() {\n const startLoc = this.state.startLoc;\n const endOfInit = () => this.match(12) || this.match(8);\n switch (this.state.type) {\n case 135:\n {\n const literal = this.parseNumericLiteral(this.state.value);\n if (endOfInit()) {\n return {\n type: \"number\",\n loc: literal.loc.start,\n value: literal\n };\n }\n return {\n type: \"invalid\",\n loc: startLoc\n };\n }\n case 134:\n {\n const literal = this.parseStringLiteral(this.state.value);\n if (endOfInit()) {\n return {\n type: \"string\",\n loc: literal.loc.start,\n value: literal\n };\n }\n return {\n type: \"invalid\",\n loc: startLoc\n };\n }\n case 85:\n case 86:\n {\n const literal = this.parseBooleanLiteral(this.match(85));\n if (endOfInit()) {\n return {\n type: \"boolean\",\n loc: literal.loc.start,\n value: literal\n };\n }\n return {\n type: \"invalid\",\n loc: startLoc\n };\n }\n default:\n return {\n type: \"invalid\",\n loc: startLoc\n };\n }\n }\n flowEnumMemberRaw() {\n const loc = this.state.startLoc;\n const id = this.parseIdentifier(true);\n const init = this.eat(29) ? this.flowEnumMemberInit() : {\n type: \"none\",\n loc\n };\n return {\n id,\n init\n };\n }\n flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {\n const {\n explicitType\n } = context;\n if (explicitType === null) {\n return;\n }\n if (explicitType !== expectedType) {\n this.flowEnumErrorInvalidMemberInitializer(loc, context);\n }\n }\n flowEnumMembers({\n enumName,\n explicitType\n }) {\n const seenNames = new Set();\n const members = {\n booleanMembers: [],\n numberMembers: [],\n stringMembers: [],\n defaultedMembers: []\n };\n let hasUnknownMembers = false;\n while (!this.match(8)) {\n if (this.eat(21)) {\n hasUnknownMembers = true;\n break;\n }\n const memberNode = this.startNode();\n const {\n id,\n init\n } = this.flowEnumMemberRaw();\n const memberName = id.name;\n if (memberName === \"\") {\n continue;\n }\n if (/^[a-z]/.test(memberName)) {\n this.raise(FlowErrors.EnumInvalidMemberName, id, {\n memberName,\n suggestion: memberName[0].toUpperCase() + memberName.slice(1),\n enumName\n });\n }\n if (seenNames.has(memberName)) {\n this.raise(FlowErrors.EnumDuplicateMemberName, id, {\n memberName,\n enumName\n });\n }\n seenNames.add(memberName);\n const context = {\n enumName,\n explicitType,\n memberName\n };\n memberNode.id = id;\n switch (init.type) {\n case \"boolean\":\n {\n this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"boolean\");\n memberNode.init = init.value;\n members.booleanMembers.push(this.finishNode(memberNode, \"EnumBooleanMember\"));\n break;\n }\n case \"number\":\n {\n this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"number\");\n memberNode.init = init.value;\n members.numberMembers.push(this.finishNode(memberNode, \"EnumNumberMember\"));\n break;\n }\n case \"string\":\n {\n this.flowEnumCheckExplicitTypeMismatch(init.loc, context, \"string\");\n memberNode.init = init.value;\n members.stringMembers.push(this.finishNode(memberNode, \"EnumStringMember\"));\n break;\n }\n case \"invalid\":\n {\n throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);\n }\n case \"none\":\n {\n switch (explicitType) {\n case \"boolean\":\n this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);\n break;\n case \"number\":\n this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);\n break;\n default:\n members.defaultedMembers.push(this.finishNode(memberNode, \"EnumDefaultedMember\"));\n }\n }\n }\n if (!this.match(8)) {\n this.expect(12);\n }\n }\n return {\n members,\n hasUnknownMembers\n };\n }\n flowEnumStringMembers(initializedMembers, defaultedMembers, {\n enumName\n }) {\n if (initializedMembers.length === 0) {\n return defaultedMembers;\n } else if (defaultedMembers.length === 0) {\n return initializedMembers;\n } else if (defaultedMembers.length > initializedMembers.length) {\n for (const member of initializedMembers) {\n this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {\n enumName\n });\n }\n return defaultedMembers;\n } else {\n for (const member of defaultedMembers) {\n this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {\n enumName\n });\n }\n return initializedMembers;\n }\n }\n flowEnumParseExplicitType({\n enumName\n }) {\n if (!this.eatContextual(102)) return null;\n if (!tokenIsIdentifier(this.state.type)) {\n throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {\n enumName\n });\n }\n const {\n value\n } = this.state;\n this.next();\n if (value !== \"boolean\" && value !== \"number\" && value !== \"string\" && value !== \"symbol\") {\n this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {\n enumName,\n invalidEnumType: value\n });\n }\n return value;\n }\n flowEnumBody(node, id) {\n const enumName = id.name;\n const nameLoc = id.loc.start;\n const explicitType = this.flowEnumParseExplicitType({\n enumName\n });\n this.expect(5);\n const {\n members,\n hasUnknownMembers\n } = this.flowEnumMembers({\n enumName,\n explicitType\n });\n node.hasUnknownMembers = hasUnknownMembers;\n switch (explicitType) {\n case \"boolean\":\n node.explicitType = true;\n node.members = members.booleanMembers;\n this.expect(8);\n return this.finishNode(node, \"EnumBooleanBody\");\n case \"number\":\n node.explicitType = true;\n node.members = members.numberMembers;\n this.expect(8);\n return this.finishNode(node, \"EnumNumberBody\");\n case \"string\":\n node.explicitType = true;\n node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {\n enumName\n });\n this.expect(8);\n return this.finishNode(node, \"EnumStringBody\");\n case \"symbol\":\n node.members = members.defaultedMembers;\n this.expect(8);\n return this.finishNode(node, \"EnumSymbolBody\");\n default:\n {\n const empty = () => {\n node.members = [];\n this.expect(8);\n return this.finishNode(node, \"EnumStringBody\");\n };\n node.explicitType = false;\n const boolsLen = members.booleanMembers.length;\n const numsLen = members.numberMembers.length;\n const strsLen = members.stringMembers.length;\n const defaultedLen = members.defaultedMembers.length;\n if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {\n return empty();\n } else if (!boolsLen && !numsLen) {\n node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {\n enumName\n });\n this.expect(8);\n return this.finishNode(node, \"EnumStringBody\");\n } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {\n for (const member of members.defaultedMembers) {\n this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {\n enumName,\n memberName: member.id.name\n });\n }\n node.members = members.booleanMembers;\n this.expect(8);\n return this.finishNode(node, \"EnumBooleanBody\");\n } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {\n for (const member of members.defaultedMembers) {\n this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {\n enumName,\n memberName: member.id.name\n });\n }\n node.members = members.numberMembers;\n this.expect(8);\n return this.finishNode(node, \"EnumNumberBody\");\n } else {\n this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {\n enumName\n });\n return empty();\n }\n }\n }\n }\n flowParseEnumDeclaration(node) {\n const id = this.parseIdentifier();\n node.id = id;\n node.body = this.flowEnumBody(this.startNode(), id);\n return this.finishNode(node, \"EnumDeclaration\");\n }\n jsxParseOpeningElementAfterName(node) {\n if (this.shouldParseTypes()) {\n if (this.match(47) || this.match(51)) {\n node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();\n }\n }\n return super.jsxParseOpeningElementAfterName(node);\n }\n isLookaheadToken_lt() {\n const next = this.nextTokenStart();\n if (this.input.charCodeAt(next) === 60) {\n const afterNext = this.input.charCodeAt(next + 1);\n return afterNext !== 60 && afterNext !== 61;\n }\n return false;\n }\n reScan_lt_gt() {\n const {\n type\n } = this.state;\n if (type === 47) {\n this.state.pos -= 1;\n this.readToken_lt();\n } else if (type === 48) {\n this.state.pos -= 1;\n this.readToken_gt();\n }\n }\n reScan_lt() {\n const {\n type\n } = this.state;\n if (type === 51) {\n this.state.pos -= 2;\n this.finishOp(47, 1);\n return 47;\n }\n return type;\n }\n maybeUnwrapTypeCastExpression(node) {\n return node.type === \"TypeCastExpression\" ? node.expression : node;\n }\n};\nconst entities = {\n __proto__: null,\n quot: \"\\u0022\",\n amp: \"&\",\n apos: \"\\u0027\",\n lt: \"<\",\n gt: \">\",\n nbsp: \"\\u00A0\",\n iexcl: \"\\u00A1\",\n cent: \"\\u00A2\",\n pound: \"\\u00A3\",\n curren: \"\\u00A4\",\n yen: \"\\u00A5\",\n brvbar: \"\\u00A6\",\n sect: \"\\u00A7\",\n uml: \"\\u00A8\",\n copy: \"\\u00A9\",\n ordf: \"\\u00AA\",\n laquo: \"\\u00AB\",\n not: \"\\u00AC\",\n shy: \"\\u00AD\",\n reg: \"\\u00AE\",\n macr: \"\\u00AF\",\n deg: \"\\u00B0\",\n plusmn: \"\\u00B1\",\n sup2: \"\\u00B2\",\n sup3: \"\\u00B3\",\n acute: \"\\u00B4\",\n micro: \"\\u00B5\",\n para: \"\\u00B6\",\n middot: \"\\u00B7\",\n cedil: \"\\u00B8\",\n sup1: \"\\u00B9\",\n ordm: \"\\u00BA\",\n raquo: \"\\u00BB\",\n frac14: \"\\u00BC\",\n frac12: \"\\u00BD\",\n frac34: \"\\u00BE\",\n iquest: \"\\u00BF\",\n Agrave: \"\\u00C0\",\n Aacute: \"\\u00C1\",\n Acirc: \"\\u00C2\",\n Atilde: \"\\u00C3\",\n Auml: \"\\u00C4\",\n Aring: \"\\u00C5\",\n AElig: \"\\u00C6\",\n Ccedil: \"\\u00C7\",\n Egrave: \"\\u00C8\",\n Eacute: \"\\u00C9\",\n Ecirc: \"\\u00CA\",\n Euml: \"\\u00CB\",\n Igrave: \"\\u00CC\",\n Iacute: \"\\u00CD\",\n Icirc: \"\\u00CE\",\n Iuml: \"\\u00CF\",\n ETH: \"\\u00D0\",\n Ntilde: \"\\u00D1\",\n Ograve: \"\\u00D2\",\n Oacute: \"\\u00D3\",\n Ocirc: \"\\u00D4\",\n Otilde: \"\\u00D5\",\n Ouml: \"\\u00D6\",\n times: \"\\u00D7\",\n Oslash: \"\\u00D8\",\n Ugrave: \"\\u00D9\",\n Uacute: \"\\u00DA\",\n Ucirc: \"\\u00DB\",\n Uuml: \"\\u00DC\",\n Yacute: \"\\u00DD\",\n THORN: \"\\u00DE\",\n szlig: \"\\u00DF\",\n agrave: \"\\u00E0\",\n aacute: \"\\u00E1\",\n acirc: \"\\u00E2\",\n atilde: \"\\u00E3\",\n auml: \"\\u00E4\",\n aring: \"\\u00E5\",\n aelig: \"\\u00E6\",\n ccedil: \"\\u00E7\",\n egrave: \"\\u00E8\",\n eacute: \"\\u00E9\",\n ecirc: \"\\u00EA\",\n euml: \"\\u00EB\",\n igrave: \"\\u00EC\",\n iacute: \"\\u00ED\",\n icirc: \"\\u00EE\",\n iuml: \"\\u00EF\",\n eth: \"\\u00F0\",\n ntilde: \"\\u00F1\",\n ograve: \"\\u00F2\",\n oacute: \"\\u00F3\",\n ocirc: \"\\u00F4\",\n otilde: \"\\u00F5\",\n ouml: \"\\u00F6\",\n divide: \"\\u00F7\",\n oslash: \"\\u00F8\",\n ugrave: \"\\u00F9\",\n uacute: \"\\u00FA\",\n ucirc: \"\\u00FB\",\n uuml: \"\\u00FC\",\n yacute: \"\\u00FD\",\n thorn: \"\\u00FE\",\n yuml: \"\\u00FF\",\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 lang: \"\\u2329\",\n rang: \"\\u232A\",\n loz: \"\\u25CA\",\n spades: \"\\u2660\",\n clubs: \"\\u2663\",\n hearts: \"\\u2665\",\n diams: \"\\u2666\"\n};\nconst lineBreak = /\\r\\n|[\\r\\n\\u2028\\u2029]/;\nconst lineBreakG = new RegExp(lineBreak.source, \"g\");\nfunction isNewLine(code) {\n switch (code) {\n case 10:\n case 13:\n case 8232:\n case 8233:\n return true;\n default:\n return false;\n }\n}\nfunction hasNewLine(input, start, end) {\n for (let i = start; i < end; i++) {\n if (isNewLine(input.charCodeAt(i))) {\n return true;\n }\n }\n return false;\n}\nconst skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\nconst skipWhiteSpaceInLine = /(?:[^\\S\\n\\r\\u2028\\u2029]|\\/\\/.*|\\/\\*.*?\\*\\/)*/g;\nfunction isWhitespace(code) {\n switch (code) {\n case 0x0009:\n case 0x000b:\n case 0x000c:\n case 32:\n case 160:\n case 5760:\n case 0x2000:\n case 0x2001:\n case 0x2002:\n case 0x2003:\n case 0x2004:\n case 0x2005:\n case 0x2006:\n case 0x2007:\n case 0x2008:\n case 0x2009:\n case 0x200a:\n case 0x202f:\n case 0x205f:\n case 0x3000:\n case 0xfeff:\n return true;\n default:\n return false;\n }\n}\nconst JsxErrors = ParseErrorEnum`jsx`({\n AttributeIsEmpty: \"JSX attributes must only be assigned a non-empty expression.\",\n MissingClosingTagElement: ({\n openingTagName\n }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,\n MissingClosingTagFragment: \"Expected corresponding JSX closing tag for <>.\",\n UnexpectedSequenceExpression: \"Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?\",\n UnexpectedToken: ({\n unexpected,\n HTMLEntity\n }) => `Unexpected token \\`${unexpected}\\`. Did you mean \\`${HTMLEntity}\\` or \\`{'${unexpected}'}\\`?`,\n UnsupportedJsxValue: \"JSX value should be either an expression or a quoted JSX text.\",\n UnterminatedJsxContent: \"Unterminated JSX contents.\",\n UnwrappedAdjacentJSXElements: \"Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...?\"\n});\nfunction isFragment(object) {\n return object ? object.type === \"JSXOpeningFragment\" || object.type === \"JSXClosingFragment\" : false;\n}\nfunction getQualifiedJSXName(object) {\n if (object.type === \"JSXIdentifier\") {\n return object.name;\n }\n if (object.type === \"JSXNamespacedName\") {\n return object.namespace.name + \":\" + object.name.name;\n }\n if (object.type === \"JSXMemberExpression\") {\n return getQualifiedJSXName(object.object) + \".\" + getQualifiedJSXName(object.property);\n }\n throw new Error(\"Node had unexpected type: \" + object.type);\n}\nvar jsx = superClass => class JSXParserMixin extends superClass {\n jsxReadToken() {\n let out = \"\";\n let chunkStart = this.state.pos;\n for (;;) {\n if (this.state.pos >= this.length) {\n throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);\n }\n const ch = this.input.charCodeAt(this.state.pos);\n switch (ch) {\n case 60:\n case 123:\n if (this.state.pos === this.state.start) {\n if (ch === 60 && this.state.canStartJSXElement) {\n ++this.state.pos;\n this.finishToken(143);\n } else {\n super.getTokenFromCode(ch);\n }\n return;\n }\n out += this.input.slice(chunkStart, this.state.pos);\n this.finishToken(142, out);\n return;\n case 38:\n out += this.input.slice(chunkStart, this.state.pos);\n out += this.jsxReadEntity();\n chunkStart = this.state.pos;\n break;\n case 62:\n case 125:\n default:\n if (isNewLine(ch)) {\n out += this.input.slice(chunkStart, this.state.pos);\n out += this.jsxReadNewLine(true);\n chunkStart = this.state.pos;\n } else {\n ++this.state.pos;\n }\n }\n }\n }\n jsxReadNewLine(normalizeCRLF) {\n const ch = this.input.charCodeAt(this.state.pos);\n let out;\n ++this.state.pos;\n if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {\n ++this.state.pos;\n out = normalizeCRLF ? \"\\n\" : \"\\r\\n\";\n } else {\n out = String.fromCharCode(ch);\n }\n ++this.state.curLine;\n this.state.lineStart = this.state.pos;\n return out;\n }\n jsxReadString(quote) {\n let out = \"\";\n let chunkStart = ++this.state.pos;\n for (;;) {\n if (this.state.pos >= this.length) {\n throw this.raise(Errors.UnterminatedString, this.state.startLoc);\n }\n const ch = this.input.charCodeAt(this.state.pos);\n if (ch === quote) break;\n if (ch === 38) {\n out += this.input.slice(chunkStart, this.state.pos);\n out += this.jsxReadEntity();\n chunkStart = this.state.pos;\n } else if (isNewLine(ch)) {\n out += this.input.slice(chunkStart, this.state.pos);\n out += this.jsxReadNewLine(false);\n chunkStart = this.state.pos;\n } else {\n ++this.state.pos;\n }\n }\n out += this.input.slice(chunkStart, this.state.pos++);\n this.finishToken(134, out);\n }\n jsxReadEntity() {\n const startPos = ++this.state.pos;\n if (this.codePointAtPos(this.state.pos) === 35) {\n ++this.state.pos;\n let radix = 10;\n if (this.codePointAtPos(this.state.pos) === 120) {\n radix = 16;\n ++this.state.pos;\n }\n const codePoint = this.readInt(radix, undefined, false, \"bail\");\n if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {\n ++this.state.pos;\n return String.fromCodePoint(codePoint);\n }\n } else {\n let count = 0;\n let semi = false;\n while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) {\n ++this.state.pos;\n }\n if (semi) {\n const desc = this.input.slice(startPos, this.state.pos);\n const entity = entities[desc];\n ++this.state.pos;\n if (entity) {\n return entity;\n }\n }\n }\n this.state.pos = startPos;\n return \"&\";\n }\n jsxReadWord() {\n let ch;\n const start = this.state.pos;\n do {\n ch = this.input.charCodeAt(++this.state.pos);\n } while (isIdentifierChar(ch) || ch === 45);\n this.finishToken(141, this.input.slice(start, this.state.pos));\n }\n jsxParseIdentifier() {\n const node = this.startNode();\n if (this.match(141)) {\n node.name = this.state.value;\n } else if (tokenIsKeyword(this.state.type)) {\n node.name = tokenLabelName(this.state.type);\n } else {\n this.unexpected();\n }\n this.next();\n return this.finishNode(node, \"JSXIdentifier\");\n }\n jsxParseNamespacedName() {\n const startLoc = this.state.startLoc;\n const name = this.jsxParseIdentifier();\n if (!this.eat(14)) return name;\n const node = this.startNodeAt(startLoc);\n node.namespace = name;\n node.name = this.jsxParseIdentifier();\n return this.finishNode(node, \"JSXNamespacedName\");\n }\n jsxParseElementName() {\n const startLoc = this.state.startLoc;\n let node = this.jsxParseNamespacedName();\n if (node.type === \"JSXNamespacedName\") {\n return node;\n }\n while (this.eat(16)) {\n const newNode = this.startNodeAt(startLoc);\n newNode.object = node;\n newNode.property = this.jsxParseIdentifier();\n node = this.finishNode(newNode, \"JSXMemberExpression\");\n }\n return node;\n }\n jsxParseAttributeValue() {\n let node;\n switch (this.state.type) {\n case 5:\n node = this.startNode();\n this.setContext(types.brace);\n this.next();\n node = this.jsxParseExpressionContainer(node, types.j_oTag);\n if (node.expression.type === \"JSXEmptyExpression\") {\n this.raise(JsxErrors.AttributeIsEmpty, node);\n }\n return node;\n case 143:\n case 134:\n return this.parseExprAtom();\n default:\n throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);\n }\n }\n jsxParseEmptyExpression() {\n const node = this.startNodeAt(this.state.lastTokEndLoc);\n return this.finishNodeAt(node, \"JSXEmptyExpression\", this.state.startLoc);\n }\n jsxParseSpreadChild(node) {\n this.next();\n node.expression = this.parseExpression();\n this.setContext(types.j_expr);\n this.state.canStartJSXElement = true;\n this.expect(8);\n return this.finishNode(node, \"JSXSpreadChild\");\n }\n jsxParseExpressionContainer(node, previousContext) {\n if (this.match(8)) {\n node.expression = this.jsxParseEmptyExpression();\n } else {\n const expression = this.parseExpression();\n node.expression = expression;\n }\n this.setContext(previousContext);\n this.state.canStartJSXElement = true;\n this.expect(8);\n return this.finishNode(node, \"JSXExpressionContainer\");\n }\n jsxParseAttribute() {\n const node = this.startNode();\n if (this.match(5)) {\n this.setContext(types.brace);\n this.next();\n this.expect(21);\n node.argument = this.parseMaybeAssignAllowIn();\n this.setContext(types.j_oTag);\n this.state.canStartJSXElement = true;\n this.expect(8);\n return this.finishNode(node, \"JSXSpreadAttribute\");\n }\n node.name = this.jsxParseNamespacedName();\n node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;\n return this.finishNode(node, \"JSXAttribute\");\n }\n jsxParseOpeningElementAt(startLoc) {\n const node = this.startNodeAt(startLoc);\n if (this.eat(144)) {\n return this.finishNode(node, \"JSXOpeningFragment\");\n }\n node.name = this.jsxParseElementName();\n return this.jsxParseOpeningElementAfterName(node);\n }\n jsxParseOpeningElementAfterName(node) {\n const attributes = [];\n while (!this.match(56) && !this.match(144)) {\n attributes.push(this.jsxParseAttribute());\n }\n node.attributes = attributes;\n node.selfClosing = this.eat(56);\n this.expect(144);\n return this.finishNode(node, \"JSXOpeningElement\");\n }\n jsxParseClosingElementAt(startLoc) {\n const node = this.startNodeAt(startLoc);\n if (this.eat(144)) {\n return this.finishNode(node, \"JSXClosingFragment\");\n }\n node.name = this.jsxParseElementName();\n this.expect(144);\n return this.finishNode(node, \"JSXClosingElement\");\n }\n jsxParseElementAt(startLoc) {\n const node = this.startNodeAt(startLoc);\n const children = [];\n const openingElement = this.jsxParseOpeningElementAt(startLoc);\n let closingElement = null;\n if (!openingElement.selfClosing) {\n contents: for (;;) {\n switch (this.state.type) {\n case 143:\n startLoc = this.state.startLoc;\n this.next();\n if (this.eat(56)) {\n closingElement = this.jsxParseClosingElementAt(startLoc);\n break contents;\n }\n children.push(this.jsxParseElementAt(startLoc));\n break;\n case 142:\n children.push(this.parseLiteral(this.state.value, \"JSXText\"));\n break;\n case 5:\n {\n const node = this.startNode();\n this.setContext(types.brace);\n this.next();\n if (this.match(21)) {\n children.push(this.jsxParseSpreadChild(node));\n } else {\n children.push(this.jsxParseExpressionContainer(node, types.j_expr));\n }\n break;\n }\n default:\n this.unexpected();\n }\n }\n if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {\n this.raise(JsxErrors.MissingClosingTagFragment, closingElement);\n } else if (!isFragment(openingElement) && isFragment(closingElement)) {\n this.raise(JsxErrors.MissingClosingTagElement, closingElement, {\n openingTagName: getQualifiedJSXName(openingElement.name)\n });\n } else if (!isFragment(openingElement) && !isFragment(closingElement)) {\n if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {\n this.raise(JsxErrors.MissingClosingTagElement, closingElement, {\n openingTagName: getQualifiedJSXName(openingElement.name)\n });\n }\n }\n }\n if (isFragment(openingElement)) {\n node.openingFragment = openingElement;\n node.closingFragment = closingElement;\n } else {\n node.openingElement = openingElement;\n node.closingElement = closingElement;\n }\n node.children = children;\n if (this.match(47)) {\n throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);\n }\n return isFragment(openingElement) ? this.finishNode(node, \"JSXFragment\") : this.finishNode(node, \"JSXElement\");\n }\n jsxParseElement() {\n const startLoc = this.state.startLoc;\n this.next();\n return this.jsxParseElementAt(startLoc);\n }\n setContext(newContext) {\n const {\n context\n } = this.state;\n context[context.length - 1] = newContext;\n }\n parseExprAtom(refExpressionErrors) {\n if (this.match(143)) {\n return this.jsxParseElement();\n } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {\n this.replaceToken(143);\n return this.jsxParseElement();\n } else {\n return super.parseExprAtom(refExpressionErrors);\n }\n }\n skipSpace() {\n const curContext = this.curContext();\n if (!curContext.preserveSpace) super.skipSpace();\n }\n getTokenFromCode(code) {\n const context = this.curContext();\n if (context === types.j_expr) {\n this.jsxReadToken();\n return;\n }\n if (context === types.j_oTag || context === types.j_cTag) {\n if (isIdentifierStart(code)) {\n this.jsxReadWord();\n return;\n }\n if (code === 62) {\n ++this.state.pos;\n this.finishToken(144);\n return;\n }\n if ((code === 34 || code === 39) && context === types.j_oTag) {\n this.jsxReadString(code);\n return;\n }\n }\n if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {\n ++this.state.pos;\n this.finishToken(143);\n return;\n }\n super.getTokenFromCode(code);\n }\n updateContext(prevType) {\n const {\n context,\n type\n } = this.state;\n if (type === 56 && prevType === 143) {\n context.splice(-2, 2, types.j_cTag);\n this.state.canStartJSXElement = false;\n } else if (type === 143) {\n context.push(types.j_oTag);\n } else if (type === 144) {\n const out = context[context.length - 1];\n if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {\n context.pop();\n this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;\n } else {\n this.setContext(types.j_expr);\n this.state.canStartJSXElement = true;\n }\n } else {\n this.state.canStartJSXElement = tokenComesBeforeExpression(type);\n }\n }\n};\nclass TypeScriptScope extends Scope {\n constructor(...args) {\n super(...args);\n this.tsNames = new Map();\n }\n}\nclass TypeScriptScopeHandler extends ScopeHandler {\n constructor(...args) {\n super(...args);\n this.importsStack = [];\n }\n createScope(flags) {\n this.importsStack.push(new Set());\n return new TypeScriptScope(flags);\n }\n enter(flags) {\n if (flags === 1024) {\n this.importsStack.push(new Set());\n }\n super.enter(flags);\n }\n exit() {\n const flags = super.exit();\n if (flags === 1024) {\n this.importsStack.pop();\n }\n return flags;\n }\n hasImport(name, allowShadow) {\n const len = this.importsStack.length;\n if (this.importsStack[len - 1].has(name)) {\n return true;\n }\n if (!allowShadow && len > 1) {\n for (let i = 0; i < len - 1; i++) {\n if (this.importsStack[i].has(name)) return true;\n }\n }\n return false;\n }\n declareName(name, bindingType, loc) {\n if (bindingType & 4096) {\n if (this.hasImport(name, true)) {\n this.parser.raise(Errors.VarRedeclaration, loc, {\n identifierName: name\n });\n }\n this.importsStack[this.importsStack.length - 1].add(name);\n return;\n }\n const scope = this.currentScope();\n let type = scope.tsNames.get(name) || 0;\n if (bindingType & 1024) {\n this.maybeExportDefined(scope, name);\n scope.tsNames.set(name, type | 16);\n return;\n }\n super.declareName(name, bindingType, loc);\n if (bindingType & 2) {\n if (!(bindingType & 1)) {\n this.checkRedeclarationInScope(scope, name, bindingType, loc);\n this.maybeExportDefined(scope, name);\n }\n type = type | 1;\n }\n if (bindingType & 256) {\n type = type | 2;\n }\n if (bindingType & 512) {\n type = type | 4;\n }\n if (bindingType & 128) {\n type = type | 8;\n }\n if (type) scope.tsNames.set(name, type);\n }\n isRedeclaredInScope(scope, name, bindingType) {\n const type = scope.tsNames.get(name);\n if ((type & 2) > 0) {\n if (bindingType & 256) {\n const isConst = !!(bindingType & 512);\n const wasConst = (type & 4) > 0;\n return isConst !== wasConst;\n }\n return true;\n }\n if (bindingType & 128 && (type & 8) > 0) {\n if (scope.names.get(name) & 2) {\n return !!(bindingType & 1);\n } else {\n return false;\n }\n }\n if (bindingType & 2 && (type & 1) > 0) {\n return true;\n }\n return super.isRedeclaredInScope(scope, name, bindingType);\n }\n checkLocalExport(id) {\n const {\n name\n } = id;\n if (this.hasImport(name)) return;\n const len = this.scopeStack.length;\n for (let i = len - 1; i >= 0; i--) {\n const scope = this.scopeStack[i];\n const type = scope.tsNames.get(name);\n if ((type & 1) > 0 || (type & 16) > 0) {\n return;\n }\n }\n super.checkLocalExport(id);\n }\n}\nclass ProductionParameterHandler {\n constructor() {\n this.stacks = [];\n }\n enter(flags) {\n this.stacks.push(flags);\n }\n exit() {\n this.stacks.pop();\n }\n currentFlags() {\n return this.stacks[this.stacks.length - 1];\n }\n get hasAwait() {\n return (this.currentFlags() & 2) > 0;\n }\n get hasYield() {\n return (this.currentFlags() & 1) > 0;\n }\n get hasReturn() {\n return (this.currentFlags() & 4) > 0;\n }\n get hasIn() {\n return (this.currentFlags() & 8) > 0;\n }\n}\nfunction functionFlags(isAsync, isGenerator) {\n return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0);\n}\nclass BaseParser {\n constructor() {\n this.sawUnambiguousESM = false;\n this.ambiguousScriptDifferentAst = false;\n }\n sourceToOffsetPos(sourcePos) {\n return sourcePos + this.startIndex;\n }\n offsetToSourcePos(offsetPos) {\n return offsetPos - this.startIndex;\n }\n hasPlugin(pluginConfig) {\n if (typeof pluginConfig === \"string\") {\n return this.plugins.has(pluginConfig);\n } else {\n const [pluginName, pluginOptions] = pluginConfig;\n if (!this.hasPlugin(pluginName)) {\n return false;\n }\n const actualOptions = this.plugins.get(pluginName);\n for (const key of Object.keys(pluginOptions)) {\n if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) {\n return false;\n }\n }\n return true;\n }\n }\n getPluginOption(plugin, name) {\n var _this$plugins$get;\n return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];\n }\n}\nfunction setTrailingComments(node, comments) {\n if (node.trailingComments === undefined) {\n node.trailingComments = comments;\n } else {\n node.trailingComments.unshift(...comments);\n }\n}\nfunction setLeadingComments(node, comments) {\n if (node.leadingComments === undefined) {\n node.leadingComments = comments;\n } else {\n node.leadingComments.unshift(...comments);\n }\n}\nfunction setInnerComments(node, comments) {\n if (node.innerComments === undefined) {\n node.innerComments = comments;\n } else {\n node.innerComments.unshift(...comments);\n }\n}\nfunction adjustInnerComments(node, elements, commentWS) {\n let lastElement = null;\n let i = elements.length;\n while (lastElement === null && i > 0) {\n lastElement = elements[--i];\n }\n if (lastElement === null || lastElement.start > commentWS.start) {\n setInnerComments(node, commentWS.comments);\n } else {\n setTrailingComments(lastElement, commentWS.comments);\n }\n}\nclass CommentsParser extends BaseParser {\n addComment(comment) {\n if (this.filename) comment.loc.filename = this.filename;\n const {\n commentsLen\n } = this.state;\n if (this.comments.length !== commentsLen) {\n this.comments.length = commentsLen;\n }\n this.comments.push(comment);\n this.state.commentsLen++;\n }\n processComment(node) {\n const {\n commentStack\n } = this.state;\n const commentStackLength = commentStack.length;\n if (commentStackLength === 0) return;\n let i = commentStackLength - 1;\n const lastCommentWS = commentStack[i];\n if (lastCommentWS.start === node.end) {\n lastCommentWS.leadingNode = node;\n i--;\n }\n const {\n start: nodeStart\n } = node;\n for (; i >= 0; i--) {\n const commentWS = commentStack[i];\n const commentEnd = commentWS.end;\n if (commentEnd > nodeStart) {\n commentWS.containingNode = node;\n this.finalizeComment(commentWS);\n commentStack.splice(i, 1);\n } else {\n if (commentEnd === nodeStart) {\n commentWS.trailingNode = node;\n }\n break;\n }\n }\n }\n finalizeComment(commentWS) {\n var _node$options;\n const {\n comments\n } = commentWS;\n if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {\n if (commentWS.leadingNode !== null) {\n setTrailingComments(commentWS.leadingNode, comments);\n }\n if (commentWS.trailingNode !== null) {\n setLeadingComments(commentWS.trailingNode, comments);\n }\n } else {\n const node = commentWS.containingNode;\n const commentStart = commentWS.start;\n if (this.input.charCodeAt(this.offsetToSourcePos(commentStart) - 1) === 44) {\n switch (node.type) {\n case \"ObjectExpression\":\n case \"ObjectPattern\":\n adjustInnerComments(node, node.properties, commentWS);\n break;\n case \"CallExpression\":\n case \"OptionalCallExpression\":\n adjustInnerComments(node, node.arguments, commentWS);\n break;\n case \"ImportExpression\":\n adjustInnerComments(node, [node.source, (_node$options = node.options) != null ? _node$options : null], commentWS);\n break;\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ArrowFunctionExpression\":\n case \"ObjectMethod\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n adjustInnerComments(node, node.params, commentWS);\n break;\n case \"ArrayExpression\":\n case \"ArrayPattern\":\n adjustInnerComments(node, node.elements, commentWS);\n break;\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n adjustInnerComments(node, node.specifiers, commentWS);\n break;\n case \"TSEnumDeclaration\":\n adjustInnerComments(node, node.members, commentWS);\n break;\n case \"TSEnumBody\":\n adjustInnerComments(node, node.members, commentWS);\n break;\n default:\n {\n if (node.type === \"RecordExpression\") {\n adjustInnerComments(node, node.properties, commentWS);\n break;\n }\n if (node.type === \"TupleExpression\") {\n adjustInnerComments(node, node.elements, commentWS);\n break;\n }\n setInnerComments(node, comments);\n }\n }\n } else {\n setInnerComments(node, comments);\n }\n }\n }\n finalizeRemainingComments() {\n const {\n commentStack\n } = this.state;\n for (let i = commentStack.length - 1; i >= 0; i--) {\n this.finalizeComment(commentStack[i]);\n }\n this.state.commentStack = [];\n }\n resetPreviousNodeTrailingComments(node) {\n const {\n commentStack\n } = this.state;\n const {\n length\n } = commentStack;\n if (length === 0) return;\n const commentWS = commentStack[length - 1];\n if (commentWS.leadingNode === node) {\n commentWS.leadingNode = null;\n }\n }\n takeSurroundingComments(node, start, end) {\n const {\n commentStack\n } = this.state;\n const commentStackLength = commentStack.length;\n if (commentStackLength === 0) return;\n let i = commentStackLength - 1;\n for (; i >= 0; i--) {\n const commentWS = commentStack[i];\n const commentEnd = commentWS.end;\n const commentStart = commentWS.start;\n if (commentStart === end) {\n commentWS.leadingNode = node;\n } else if (commentEnd === start) {\n commentWS.trailingNode = node;\n } else if (commentEnd < start) {\n break;\n }\n }\n }\n}\nclass State {\n constructor() {\n this.flags = 1024;\n this.startIndex = void 0;\n this.curLine = void 0;\n this.lineStart = void 0;\n this.startLoc = void 0;\n this.endLoc = void 0;\n this.errors = [];\n this.potentialArrowAt = -1;\n this.noArrowAt = [];\n this.noArrowParamsConversionAt = [];\n this.topicContext = {\n maxNumOfResolvableTopics: 0,\n maxTopicIndex: null\n };\n this.labels = [];\n this.commentsLen = 0;\n this.commentStack = [];\n this.pos = 0;\n this.type = 140;\n this.value = null;\n this.start = 0;\n this.end = 0;\n this.lastTokEndLoc = null;\n this.lastTokStartLoc = null;\n this.context = [types.brace];\n this.firstInvalidTemplateEscapePos = null;\n this.strictErrors = new Map();\n this.tokensLength = 0;\n }\n get strict() {\n return (this.flags & 1) > 0;\n }\n set strict(v) {\n if (v) this.flags |= 1;else this.flags &= -2;\n }\n init({\n strictMode,\n sourceType,\n startIndex,\n startLine,\n startColumn\n }) {\n this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === \"module\";\n this.startIndex = startIndex;\n this.curLine = startLine;\n this.lineStart = -startColumn;\n this.startLoc = this.endLoc = new Position(startLine, startColumn, startIndex);\n }\n get maybeInArrowParameters() {\n return (this.flags & 2) > 0;\n }\n set maybeInArrowParameters(v) {\n if (v) this.flags |= 2;else this.flags &= -3;\n }\n get inType() {\n return (this.flags & 4) > 0;\n }\n set inType(v) {\n if (v) this.flags |= 4;else this.flags &= -5;\n }\n get noAnonFunctionType() {\n return (this.flags & 8) > 0;\n }\n set noAnonFunctionType(v) {\n if (v) this.flags |= 8;else this.flags &= -9;\n }\n get hasFlowComment() {\n return (this.flags & 16) > 0;\n }\n set hasFlowComment(v) {\n if (v) this.flags |= 16;else this.flags &= -17;\n }\n get isAmbientContext() {\n return (this.flags & 32) > 0;\n }\n set isAmbientContext(v) {\n if (v) this.flags |= 32;else this.flags &= -33;\n }\n get inAbstractClass() {\n return (this.flags & 64) > 0;\n }\n set inAbstractClass(v) {\n if (v) this.flags |= 64;else this.flags &= -65;\n }\n get inDisallowConditionalTypesContext() {\n return (this.flags & 128) > 0;\n }\n set inDisallowConditionalTypesContext(v) {\n if (v) this.flags |= 128;else this.flags &= -129;\n }\n get soloAwait() {\n return (this.flags & 256) > 0;\n }\n set soloAwait(v) {\n if (v) this.flags |= 256;else this.flags &= -257;\n }\n get inFSharpPipelineDirectBody() {\n return (this.flags & 512) > 0;\n }\n set inFSharpPipelineDirectBody(v) {\n if (v) this.flags |= 512;else this.flags &= -513;\n }\n get canStartJSXElement() {\n return (this.flags & 1024) > 0;\n }\n set canStartJSXElement(v) {\n if (v) this.flags |= 1024;else this.flags &= -1025;\n }\n get containsEsc() {\n return (this.flags & 2048) > 0;\n }\n set containsEsc(v) {\n if (v) this.flags |= 2048;else this.flags &= -2049;\n }\n get hasTopLevelAwait() {\n return (this.flags & 4096) > 0;\n }\n set hasTopLevelAwait(v) {\n if (v) this.flags |= 4096;else this.flags &= -4097;\n }\n curPosition() {\n return new Position(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex);\n }\n clone() {\n const state = new State();\n state.flags = this.flags;\n state.startIndex = this.startIndex;\n state.curLine = this.curLine;\n state.lineStart = this.lineStart;\n state.startLoc = this.startLoc;\n state.endLoc = this.endLoc;\n state.errors = this.errors.slice();\n state.potentialArrowAt = this.potentialArrowAt;\n state.noArrowAt = this.noArrowAt.slice();\n state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice();\n state.topicContext = this.topicContext;\n state.labels = this.labels.slice();\n state.commentsLen = this.commentsLen;\n state.commentStack = this.commentStack.slice();\n state.pos = this.pos;\n state.type = this.type;\n state.value = this.value;\n state.start = this.start;\n state.end = this.end;\n state.lastTokEndLoc = this.lastTokEndLoc;\n state.lastTokStartLoc = this.lastTokStartLoc;\n state.context = this.context.slice();\n state.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos;\n state.strictErrors = this.strictErrors;\n state.tokensLength = this.tokensLength;\n return state;\n }\n}\nvar _isDigit = function isDigit(code) {\n return code >= 48 && code <= 57;\n};\nconst forbiddenNumericSeparatorSiblings = {\n decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),\n hex: new Set([46, 88, 95, 120])\n};\nconst isAllowedNumericSeparatorSibling = {\n bin: ch => ch === 48 || ch === 49,\n oct: ch => ch >= 48 && ch <= 55,\n dec: ch => ch >= 48 && ch <= 57,\n hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102\n};\nfunction readStringContents(type, input, pos, lineStart, curLine, errors) {\n const initialPos = pos;\n const initialLineStart = lineStart;\n const initialCurLine = curLine;\n let out = \"\";\n let firstInvalidLoc = null;\n let chunkStart = pos;\n const {\n length\n } = input;\n for (;;) {\n if (pos >= length) {\n errors.unterminated(initialPos, initialLineStart, initialCurLine);\n out += input.slice(chunkStart, pos);\n break;\n }\n const ch = input.charCodeAt(pos);\n if (isStringEnd(type, ch, input, pos)) {\n out += input.slice(chunkStart, pos);\n break;\n }\n if (ch === 92) {\n out += input.slice(chunkStart, pos);\n const res = readEscapedChar(input, pos, lineStart, curLine, type === \"template\", errors);\n if (res.ch === null && !firstInvalidLoc) {\n firstInvalidLoc = {\n pos,\n lineStart,\n curLine\n };\n } else {\n out += res.ch;\n }\n ({\n pos,\n lineStart,\n curLine\n } = res);\n chunkStart = pos;\n } else if (ch === 8232 || ch === 8233) {\n ++pos;\n ++curLine;\n lineStart = pos;\n } else if (ch === 10 || ch === 13) {\n if (type === \"template\") {\n out += input.slice(chunkStart, pos) + \"\\n\";\n ++pos;\n if (ch === 13 && input.charCodeAt(pos) === 10) {\n ++pos;\n }\n ++curLine;\n chunkStart = lineStart = pos;\n } else {\n errors.unterminated(initialPos, initialLineStart, initialCurLine);\n }\n } else {\n ++pos;\n }\n }\n return {\n pos,\n str: out,\n firstInvalidLoc,\n lineStart,\n curLine,\n containsInvalid: !!firstInvalidLoc\n };\n}\nfunction isStringEnd(type, ch, input, pos) {\n if (type === \"template\") {\n return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;\n }\n return ch === (type === \"double\" ? 34 : 39);\n}\nfunction readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {\n const throwOnInvalid = !inTemplate;\n pos++;\n const res = ch => ({\n pos,\n ch,\n lineStart,\n curLine\n });\n const ch = input.charCodeAt(pos++);\n switch (ch) {\n case 110:\n return res(\"\\n\");\n case 114:\n return res(\"\\r\");\n case 120:\n {\n let code;\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));\n return res(code === null ? null : String.fromCharCode(code));\n }\n case 117:\n {\n let code;\n ({\n code,\n pos\n } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));\n return res(code === null ? null : String.fromCodePoint(code));\n }\n case 116:\n return res(\"\\t\");\n case 98:\n return res(\"\\b\");\n case 118:\n return res(\"\\u000b\");\n case 102:\n return res(\"\\f\");\n case 13:\n if (input.charCodeAt(pos) === 10) {\n ++pos;\n }\n case 10:\n lineStart = pos;\n ++curLine;\n case 8232:\n case 8233:\n return res(\"\");\n case 56:\n case 57:\n if (inTemplate) {\n return res(null);\n } else {\n errors.strictNumericEscape(pos - 1, lineStart, curLine);\n }\n default:\n if (ch >= 48 && ch <= 55) {\n const startPos = pos - 1;\n const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));\n let octalStr = match[0];\n let octal = parseInt(octalStr, 8);\n if (octal > 255) {\n octalStr = octalStr.slice(0, -1);\n octal = parseInt(octalStr, 8);\n }\n pos += octalStr.length - 1;\n const next = input.charCodeAt(pos);\n if (octalStr !== \"0\" || next === 56 || next === 57) {\n if (inTemplate) {\n return res(null);\n } else {\n errors.strictNumericEscape(startPos, lineStart, curLine);\n }\n }\n return res(String.fromCharCode(octal));\n }\n return res(String.fromCharCode(ch));\n }\n}\nfunction readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {\n const initialPos = pos;\n let n;\n ({\n n,\n pos\n } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));\n if (n === null) {\n if (throwOnInvalid) {\n errors.invalidEscapeSequence(initialPos, lineStart, curLine);\n } else {\n pos = initialPos - 1;\n }\n }\n return {\n code: n,\n pos\n };\n}\nfunction readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {\n const start = pos;\n const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;\n const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;\n let invalid = false;\n let total = 0;\n for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n const code = input.charCodeAt(pos);\n let val;\n if (code === 95 && allowNumSeparator !== \"bail\") {\n const prev = input.charCodeAt(pos - 1);\n const next = input.charCodeAt(pos + 1);\n if (!allowNumSeparator) {\n if (bailOnError) return {\n n: null,\n pos\n };\n errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);\n } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {\n if (bailOnError) return {\n n: null,\n pos\n };\n errors.unexpectedNumericSeparator(pos, lineStart, curLine);\n }\n ++pos;\n continue;\n }\n if (code >= 97) {\n val = code - 97 + 10;\n } else if (code >= 65) {\n val = code - 65 + 10;\n } else if (_isDigit(code)) {\n val = code - 48;\n } else {\n val = Infinity;\n }\n if (val >= radix) {\n if (val <= 9 && bailOnError) {\n return {\n n: null,\n pos\n };\n } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {\n val = 0;\n } else if (forceLen) {\n val = 0;\n invalid = true;\n } else {\n break;\n }\n }\n ++pos;\n total = total * radix + val;\n }\n if (pos === start || len != null && pos - start !== len || invalid) {\n return {\n n: null,\n pos\n };\n }\n return {\n n: total,\n pos\n };\n}\nfunction readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {\n const ch = input.charCodeAt(pos);\n let code;\n if (ch === 123) {\n ++pos;\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, input.indexOf(\"}\", pos) - pos, true, throwOnInvalid, errors));\n ++pos;\n if (code !== null && code > 0x10ffff) {\n if (throwOnInvalid) {\n errors.invalidCodePoint(pos, lineStart, curLine);\n } else {\n return {\n code: null,\n pos\n };\n }\n }\n } else {\n ({\n code,\n pos\n } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));\n }\n return {\n code,\n pos\n };\n}\nfunction buildPosition(pos, lineStart, curLine) {\n return new Position(curLine, pos - lineStart, pos);\n}\nconst VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);\nclass Token {\n constructor(state) {\n const startIndex = state.startIndex || 0;\n this.type = state.type;\n this.value = state.value;\n this.start = startIndex + state.start;\n this.end = startIndex + state.end;\n this.loc = new SourceLocation(state.startLoc, state.endLoc);\n }\n}\nclass Tokenizer extends CommentsParser {\n constructor(options, input) {\n super();\n this.isLookahead = void 0;\n this.tokens = [];\n this.errorHandlers_readInt = {\n invalidDigit: (pos, lineStart, curLine, radix) => {\n if (!(this.optionFlags & 2048)) return false;\n this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {\n radix\n });\n return true;\n },\n numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),\n unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)\n };\n this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {\n invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),\n invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)\n });\n this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {\n strictNumericEscape: (pos, lineStart, curLine) => {\n this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));\n },\n unterminated: (pos, lineStart, curLine) => {\n throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));\n }\n });\n this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {\n strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),\n unterminated: (pos, lineStart, curLine) => {\n throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));\n }\n });\n this.state = new State();\n this.state.init(options);\n this.input = input;\n this.length = input.length;\n this.comments = [];\n this.isLookahead = false;\n }\n pushToken(token) {\n this.tokens.length = this.state.tokensLength;\n this.tokens.push(token);\n ++this.state.tokensLength;\n }\n next() {\n this.checkKeywordEscapes();\n if (this.optionFlags & 256) {\n this.pushToken(new Token(this.state));\n }\n this.state.lastTokEndLoc = this.state.endLoc;\n this.state.lastTokStartLoc = this.state.startLoc;\n this.nextToken();\n }\n eat(type) {\n if (this.match(type)) {\n this.next();\n return true;\n } else {\n return false;\n }\n }\n match(type) {\n return this.state.type === type;\n }\n createLookaheadState(state) {\n return {\n pos: state.pos,\n value: null,\n type: state.type,\n start: state.start,\n end: state.end,\n context: [this.curContext()],\n inType: state.inType,\n startLoc: state.startLoc,\n lastTokEndLoc: state.lastTokEndLoc,\n curLine: state.curLine,\n lineStart: state.lineStart,\n curPosition: state.curPosition\n };\n }\n lookahead() {\n const old = this.state;\n this.state = this.createLookaheadState(old);\n this.isLookahead = true;\n this.nextToken();\n this.isLookahead = false;\n const curr = this.state;\n this.state = old;\n return curr;\n }\n nextTokenStart() {\n return this.nextTokenStartSince(this.state.pos);\n }\n nextTokenStartSince(pos) {\n skipWhiteSpace.lastIndex = pos;\n return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;\n }\n lookaheadCharCode() {\n return this.lookaheadCharCodeSince(this.state.pos);\n }\n lookaheadCharCodeSince(pos) {\n return this.input.charCodeAt(this.nextTokenStartSince(pos));\n }\n nextTokenInLineStart() {\n return this.nextTokenInLineStartSince(this.state.pos);\n }\n nextTokenInLineStartSince(pos) {\n skipWhiteSpaceInLine.lastIndex = pos;\n return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos;\n }\n lookaheadInLineCharCode() {\n return this.input.charCodeAt(this.nextTokenInLineStart());\n }\n codePointAtPos(pos) {\n let cp = this.input.charCodeAt(pos);\n if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {\n const trail = this.input.charCodeAt(pos);\n if ((trail & 0xfc00) === 0xdc00) {\n cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);\n }\n }\n return cp;\n }\n setStrict(strict) {\n this.state.strict = strict;\n if (strict) {\n this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, at));\n this.state.strictErrors.clear();\n }\n }\n curContext() {\n return this.state.context[this.state.context.length - 1];\n }\n nextToken() {\n this.skipSpace();\n this.state.start = this.state.pos;\n if (!this.isLookahead) this.state.startLoc = this.state.curPosition();\n if (this.state.pos >= this.length) {\n this.finishToken(140);\n return;\n }\n this.getTokenFromCode(this.codePointAtPos(this.state.pos));\n }\n skipBlockComment(commentEnd) {\n let startLoc;\n if (!this.isLookahead) startLoc = this.state.curPosition();\n const start = this.state.pos;\n const end = this.input.indexOf(commentEnd, start + 2);\n if (end === -1) {\n throw this.raise(Errors.UnterminatedComment, this.state.curPosition());\n }\n this.state.pos = end + commentEnd.length;\n lineBreakG.lastIndex = start + 2;\n while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {\n ++this.state.curLine;\n this.state.lineStart = lineBreakG.lastIndex;\n }\n if (this.isLookahead) return;\n const comment = {\n type: \"CommentBlock\",\n value: this.input.slice(start + 2, end),\n start: this.sourceToOffsetPos(start),\n end: this.sourceToOffsetPos(end + commentEnd.length),\n loc: new SourceLocation(startLoc, this.state.curPosition())\n };\n if (this.optionFlags & 256) this.pushToken(comment);\n return comment;\n }\n skipLineComment(startSkip) {\n const start = this.state.pos;\n let startLoc;\n if (!this.isLookahead) startLoc = this.state.curPosition();\n let ch = this.input.charCodeAt(this.state.pos += startSkip);\n if (this.state.pos < this.length) {\n while (!isNewLine(ch) && ++this.state.pos < this.length) {\n ch = this.input.charCodeAt(this.state.pos);\n }\n }\n if (this.isLookahead) return;\n const end = this.state.pos;\n const value = this.input.slice(start + startSkip, end);\n const comment = {\n type: \"CommentLine\",\n value,\n start: this.sourceToOffsetPos(start),\n end: this.sourceToOffsetPos(end),\n loc: new SourceLocation(startLoc, this.state.curPosition())\n };\n if (this.optionFlags & 256) this.pushToken(comment);\n return comment;\n }\n skipSpace() {\n const spaceStart = this.state.pos;\n const comments = this.optionFlags & 4096 ? [] : null;\n loop: while (this.state.pos < this.length) {\n const ch = this.input.charCodeAt(this.state.pos);\n switch (ch) {\n case 32:\n case 160:\n case 9:\n ++this.state.pos;\n break;\n case 13:\n if (this.input.charCodeAt(this.state.pos + 1) === 10) {\n ++this.state.pos;\n }\n case 10:\n case 8232:\n case 8233:\n ++this.state.pos;\n ++this.state.curLine;\n this.state.lineStart = this.state.pos;\n break;\n case 47:\n switch (this.input.charCodeAt(this.state.pos + 1)) {\n case 42:\n {\n const comment = this.skipBlockComment(\"*/\");\n if (comment !== undefined) {\n this.addComment(comment);\n comments == null || comments.push(comment);\n }\n break;\n }\n case 47:\n {\n const comment = this.skipLineComment(2);\n if (comment !== undefined) {\n this.addComment(comment);\n comments == null || comments.push(comment);\n }\n break;\n }\n default:\n break loop;\n }\n break;\n default:\n if (isWhitespace(ch)) {\n ++this.state.pos;\n } else if (ch === 45 && !this.inModule && this.optionFlags & 8192) {\n const pos = this.state.pos;\n if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {\n const comment = this.skipLineComment(3);\n if (comment !== undefined) {\n this.addComment(comment);\n comments == null || comments.push(comment);\n }\n } else {\n break loop;\n }\n } else if (ch === 60 && !this.inModule && this.optionFlags & 8192) {\n const pos = this.state.pos;\n if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {\n const comment = this.skipLineComment(4);\n if (comment !== undefined) {\n this.addComment(comment);\n comments == null || comments.push(comment);\n }\n } else {\n break loop;\n }\n } else {\n break loop;\n }\n }\n }\n if ((comments == null ? void 0 : comments.length) > 0) {\n const end = this.state.pos;\n const commentWhitespace = {\n start: this.sourceToOffsetPos(spaceStart),\n end: this.sourceToOffsetPos(end),\n comments: comments,\n leadingNode: null,\n trailingNode: null,\n containingNode: null\n };\n this.state.commentStack.push(commentWhitespace);\n }\n }\n finishToken(type, val) {\n this.state.end = this.state.pos;\n this.state.endLoc = this.state.curPosition();\n const prevType = this.state.type;\n this.state.type = type;\n this.state.value = val;\n if (!this.isLookahead) {\n this.updateContext(prevType);\n }\n }\n replaceToken(type) {\n this.state.type = type;\n this.updateContext();\n }\n readToken_numberSign() {\n if (this.state.pos === 0 && this.readToken_interpreter()) {\n return;\n }\n const nextPos = this.state.pos + 1;\n const next = this.codePointAtPos(nextPos);\n if (next >= 48 && next <= 57) {\n throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition());\n }\n if (next === 123 || next === 91 && this.hasPlugin(\"recordAndTuple\")) {\n this.expectPlugin(\"recordAndTuple\");\n if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") === \"bar\") {\n throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, this.state.curPosition());\n }\n this.state.pos += 2;\n if (next === 123) {\n this.finishToken(7);\n } else {\n this.finishToken(1);\n }\n } else if (isIdentifierStart(next)) {\n ++this.state.pos;\n this.finishToken(139, this.readWord1(next));\n } else if (next === 92) {\n ++this.state.pos;\n this.finishToken(139, this.readWord1());\n } else {\n this.finishOp(27, 1);\n }\n }\n readToken_dot() {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next >= 48 && next <= 57) {\n this.readNumber(true);\n return;\n }\n if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {\n this.state.pos += 3;\n this.finishToken(21);\n } else {\n ++this.state.pos;\n this.finishToken(16);\n }\n }\n readToken_slash() {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === 61) {\n this.finishOp(31, 2);\n } else {\n this.finishOp(56, 1);\n }\n }\n readToken_interpreter() {\n if (this.state.pos !== 0 || this.length < 2) return false;\n let ch = this.input.charCodeAt(this.state.pos + 1);\n if (ch !== 33) return false;\n const start = this.state.pos;\n this.state.pos += 1;\n while (!isNewLine(ch) && ++this.state.pos < this.length) {\n ch = this.input.charCodeAt(this.state.pos);\n }\n const value = this.input.slice(start + 2, this.state.pos);\n this.finishToken(28, value);\n return true;\n }\n readToken_mult_modulo(code) {\n let type = code === 42 ? 55 : 54;\n let width = 1;\n let next = this.input.charCodeAt(this.state.pos + 1);\n if (code === 42 && next === 42) {\n width++;\n next = this.input.charCodeAt(this.state.pos + 2);\n type = 57;\n }\n if (next === 61 && !this.state.inType) {\n width++;\n type = code === 37 ? 33 : 30;\n }\n this.finishOp(type, width);\n }\n readToken_pipe_amp(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === code) {\n if (this.input.charCodeAt(this.state.pos + 2) === 61) {\n this.finishOp(30, 3);\n } else {\n this.finishOp(code === 124 ? 41 : 42, 2);\n }\n return;\n }\n if (code === 124) {\n if (next === 62) {\n this.finishOp(39, 2);\n return;\n }\n if (this.hasPlugin(\"recordAndTuple\") && next === 125) {\n if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, this.state.curPosition());\n }\n this.state.pos += 2;\n this.finishToken(9);\n return;\n }\n if (this.hasPlugin(\"recordAndTuple\") && next === 93) {\n if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, this.state.curPosition());\n }\n this.state.pos += 2;\n this.finishToken(4);\n return;\n }\n }\n if (next === 61) {\n this.finishOp(30, 2);\n return;\n }\n this.finishOp(code === 124 ? 43 : 45, 1);\n }\n readToken_caret() {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === 61 && !this.state.inType) {\n this.finishOp(32, 2);\n } else if (next === 94 && this.hasPlugin([\"pipelineOperator\", {\n proposal: \"hack\",\n topicToken: \"^^\"\n }])) {\n this.finishOp(37, 2);\n const lookaheadCh = this.input.codePointAt(this.state.pos);\n if (lookaheadCh === 94) {\n this.unexpected();\n }\n } else {\n this.finishOp(44, 1);\n }\n }\n readToken_atSign() {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === 64 && this.hasPlugin([\"pipelineOperator\", {\n proposal: \"hack\",\n topicToken: \"@@\"\n }])) {\n this.finishOp(38, 2);\n } else {\n this.finishOp(26, 1);\n }\n }\n readToken_plus_min(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === code) {\n this.finishOp(34, 2);\n return;\n }\n if (next === 61) {\n this.finishOp(30, 2);\n } else {\n this.finishOp(53, 1);\n }\n }\n readToken_lt() {\n const {\n pos\n } = this.state;\n const next = this.input.charCodeAt(pos + 1);\n if (next === 60) {\n if (this.input.charCodeAt(pos + 2) === 61) {\n this.finishOp(30, 3);\n return;\n }\n this.finishOp(51, 2);\n return;\n }\n if (next === 61) {\n this.finishOp(49, 2);\n return;\n }\n this.finishOp(47, 1);\n }\n readToken_gt() {\n const {\n pos\n } = this.state;\n const next = this.input.charCodeAt(pos + 1);\n if (next === 62) {\n const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;\n if (this.input.charCodeAt(pos + size) === 61) {\n this.finishOp(30, size + 1);\n return;\n }\n this.finishOp(52, size);\n return;\n }\n if (next === 61) {\n this.finishOp(49, 2);\n return;\n }\n this.finishOp(48, 1);\n }\n readToken_eq_excl(code) {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === 61) {\n this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);\n return;\n }\n if (code === 61 && next === 62) {\n this.state.pos += 2;\n this.finishToken(19);\n return;\n }\n this.finishOp(code === 61 ? 29 : 35, 1);\n }\n readToken_question() {\n const next = this.input.charCodeAt(this.state.pos + 1);\n const next2 = this.input.charCodeAt(this.state.pos + 2);\n if (next === 63) {\n if (next2 === 61) {\n this.finishOp(30, 3);\n } else {\n this.finishOp(40, 2);\n }\n } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {\n this.state.pos += 2;\n this.finishToken(18);\n } else {\n ++this.state.pos;\n this.finishToken(17);\n }\n }\n getTokenFromCode(code) {\n switch (code) {\n case 46:\n this.readToken_dot();\n return;\n case 40:\n ++this.state.pos;\n this.finishToken(10);\n return;\n case 41:\n ++this.state.pos;\n this.finishToken(11);\n return;\n case 59:\n ++this.state.pos;\n this.finishToken(13);\n return;\n case 44:\n ++this.state.pos;\n this.finishToken(12);\n return;\n case 91:\n if (this.hasPlugin(\"recordAndTuple\") && this.input.charCodeAt(this.state.pos + 1) === 124) {\n if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, this.state.curPosition());\n }\n this.state.pos += 2;\n this.finishToken(2);\n } else {\n ++this.state.pos;\n this.finishToken(0);\n }\n return;\n case 93:\n ++this.state.pos;\n this.finishToken(3);\n return;\n case 123:\n if (this.hasPlugin(\"recordAndTuple\") && this.input.charCodeAt(this.state.pos + 1) === 124) {\n if (this.getPluginOption(\"recordAndTuple\", \"syntaxType\") !== \"bar\") {\n throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, this.state.curPosition());\n }\n this.state.pos += 2;\n this.finishToken(6);\n } else {\n ++this.state.pos;\n this.finishToken(5);\n }\n return;\n case 125:\n ++this.state.pos;\n this.finishToken(8);\n return;\n case 58:\n if (this.hasPlugin(\"functionBind\") && this.input.charCodeAt(this.state.pos + 1) === 58) {\n this.finishOp(15, 2);\n } else {\n ++this.state.pos;\n this.finishToken(14);\n }\n return;\n case 63:\n this.readToken_question();\n return;\n case 96:\n this.readTemplateToken();\n return;\n case 48:\n {\n const next = this.input.charCodeAt(this.state.pos + 1);\n if (next === 120 || next === 88) {\n this.readRadixNumber(16);\n return;\n }\n if (next === 111 || next === 79) {\n this.readRadixNumber(8);\n return;\n }\n if (next === 98 || next === 66) {\n this.readRadixNumber(2);\n return;\n }\n }\n case 49:\n case 50:\n case 51:\n case 52:\n case 53:\n case 54:\n case 55:\n case 56:\n case 57:\n this.readNumber(false);\n return;\n case 34:\n case 39:\n this.readString(code);\n return;\n case 47:\n this.readToken_slash();\n return;\n case 37:\n case 42:\n this.readToken_mult_modulo(code);\n return;\n case 124:\n case 38:\n this.readToken_pipe_amp(code);\n return;\n case 94:\n this.readToken_caret();\n return;\n case 43:\n case 45:\n this.readToken_plus_min(code);\n return;\n case 60:\n this.readToken_lt();\n return;\n case 62:\n this.readToken_gt();\n return;\n case 61:\n case 33:\n this.readToken_eq_excl(code);\n return;\n case 126:\n this.finishOp(36, 1);\n return;\n case 64:\n this.readToken_atSign();\n return;\n case 35:\n this.readToken_numberSign();\n return;\n case 92:\n this.readWord();\n return;\n default:\n if (isIdentifierStart(code)) {\n this.readWord(code);\n return;\n }\n }\n throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), {\n unexpected: String.fromCodePoint(code)\n });\n }\n finishOp(type, size) {\n const str = this.input.slice(this.state.pos, this.state.pos + size);\n this.state.pos += size;\n this.finishToken(type, str);\n }\n readRegexp() {\n const startLoc = this.state.startLoc;\n const start = this.state.start + 1;\n let escaped, inClass;\n let {\n pos\n } = this.state;\n for (;; ++pos) {\n if (pos >= this.length) {\n throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));\n }\n const ch = this.input.charCodeAt(pos);\n if (isNewLine(ch)) {\n throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));\n }\n if (escaped) {\n escaped = false;\n } else {\n if (ch === 91) {\n inClass = true;\n } else if (ch === 93 && inClass) {\n inClass = false;\n } else if (ch === 47 && !inClass) {\n break;\n }\n escaped = ch === 92;\n }\n }\n const content = this.input.slice(start, pos);\n ++pos;\n let mods = \"\";\n const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);\n while (pos < this.length) {\n const cp = this.codePointAtPos(pos);\n const char = String.fromCharCode(cp);\n if (VALID_REGEX_FLAGS.has(cp)) {\n if (cp === 118) {\n if (mods.includes(\"u\")) {\n this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());\n }\n } else if (cp === 117) {\n if (mods.includes(\"v\")) {\n this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());\n }\n }\n if (mods.includes(char)) {\n this.raise(Errors.DuplicateRegExpFlags, nextPos());\n }\n } else if (isIdentifierChar(cp) || cp === 92) {\n this.raise(Errors.MalformedRegExpFlags, nextPos());\n } else {\n break;\n }\n ++pos;\n mods += char;\n }\n this.state.pos = pos;\n this.finishToken(138, {\n pattern: content,\n flags: mods\n });\n }\n readInt(radix, len, forceLen = false, allowNumSeparator = true) {\n const {\n n,\n pos\n } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);\n this.state.pos = pos;\n return n;\n }\n readRadixNumber(radix) {\n const start = this.state.pos;\n const startLoc = this.state.curPosition();\n let isBigInt = false;\n this.state.pos += 2;\n const val = this.readInt(radix);\n if (val == null) {\n this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), {\n radix\n });\n }\n const next = this.input.charCodeAt(this.state.pos);\n if (next === 110) {\n ++this.state.pos;\n isBigInt = true;\n } else if (next === 109) {\n throw this.raise(Errors.InvalidDecimal, startLoc);\n }\n if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n }\n if (isBigInt) {\n const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, \"\");\n this.finishToken(136, str);\n return;\n }\n this.finishToken(135, val);\n }\n readNumber(startsWithDot) {\n const start = this.state.pos;\n const startLoc = this.state.curPosition();\n let isFloat = false;\n let isBigInt = false;\n let hasExponent = false;\n let isOctal = false;\n if (!startsWithDot && this.readInt(10) === null) {\n this.raise(Errors.InvalidNumber, this.state.curPosition());\n }\n const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;\n if (hasLeadingZero) {\n const integer = this.input.slice(start, this.state.pos);\n this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc);\n if (!this.state.strict) {\n const underscorePos = integer.indexOf(\"_\");\n if (underscorePos > 0) {\n this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));\n }\n }\n isOctal = hasLeadingZero && !/[89]/.test(integer);\n }\n let next = this.input.charCodeAt(this.state.pos);\n if (next === 46 && !isOctal) {\n ++this.state.pos;\n this.readInt(10);\n isFloat = true;\n next = this.input.charCodeAt(this.state.pos);\n }\n if ((next === 69 || next === 101) && !isOctal) {\n next = this.input.charCodeAt(++this.state.pos);\n if (next === 43 || next === 45) {\n ++this.state.pos;\n }\n if (this.readInt(10) === null) {\n this.raise(Errors.InvalidOrMissingExponent, startLoc);\n }\n isFloat = true;\n hasExponent = true;\n next = this.input.charCodeAt(this.state.pos);\n }\n if (next === 110) {\n if (isFloat || hasLeadingZero) {\n this.raise(Errors.InvalidBigIntLiteral, startLoc);\n }\n ++this.state.pos;\n isBigInt = true;\n }\n if (next === 109) {\n this.expectPlugin(\"decimal\", this.state.curPosition());\n if (hasExponent || hasLeadingZero) {\n this.raise(Errors.InvalidDecimal, startLoc);\n }\n ++this.state.pos;\n var isDecimal = true;\n }\n if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {\n throw this.raise(Errors.NumberIdentifier, this.state.curPosition());\n }\n const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, \"\");\n if (isBigInt) {\n this.finishToken(136, str);\n return;\n }\n if (isDecimal) {\n this.finishToken(137, str);\n return;\n }\n const val = isOctal ? parseInt(str, 8) : parseFloat(str);\n this.finishToken(135, val);\n }\n readCodePoint(throwOnInvalid) {\n const {\n code,\n pos\n } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);\n this.state.pos = pos;\n return code;\n }\n readString(quote) {\n const {\n str,\n pos,\n curLine,\n lineStart\n } = readStringContents(quote === 34 ? \"double\" : \"single\", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);\n this.state.pos = pos + 1;\n this.state.lineStart = lineStart;\n this.state.curLine = curLine;\n this.finishToken(134, str);\n }\n readTemplateContinuation() {\n if (!this.match(8)) {\n this.unexpected(null, 8);\n }\n this.state.pos--;\n this.readTemplateToken();\n }\n readTemplateToken() {\n const opening = this.input[this.state.pos];\n const {\n str,\n firstInvalidLoc,\n pos,\n curLine,\n lineStart\n } = readStringContents(\"template\", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);\n this.state.pos = pos + 1;\n this.state.lineStart = lineStart;\n this.state.curLine = curLine;\n if (firstInvalidLoc) {\n this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos));\n }\n if (this.input.codePointAt(pos) === 96) {\n this.finishToken(24, firstInvalidLoc ? null : opening + str + \"`\");\n } else {\n this.state.pos++;\n this.finishToken(25, firstInvalidLoc ? null : opening + str + \"${\");\n }\n }\n recordStrictModeErrors(toParseError, at) {\n const index = at.index;\n if (this.state.strict && !this.state.strictErrors.has(index)) {\n this.raise(toParseError, at);\n } else {\n this.state.strictErrors.set(index, [toParseError, at]);\n }\n }\n readWord1(firstCode) {\n this.state.containsEsc = false;\n let word = \"\";\n const start = this.state.pos;\n let chunkStart = this.state.pos;\n if (firstCode !== undefined) {\n this.state.pos += firstCode <= 0xffff ? 1 : 2;\n }\n while (this.state.pos < this.length) {\n const ch = this.codePointAtPos(this.state.pos);\n if (isIdentifierChar(ch)) {\n this.state.pos += ch <= 0xffff ? 1 : 2;\n } else if (ch === 92) {\n this.state.containsEsc = true;\n word += this.input.slice(chunkStart, this.state.pos);\n const escStart = this.state.curPosition();\n const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;\n if (this.input.charCodeAt(++this.state.pos) !== 117) {\n this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());\n chunkStart = this.state.pos - 1;\n continue;\n }\n ++this.state.pos;\n const esc = this.readCodePoint(true);\n if (esc !== null) {\n if (!identifierCheck(esc)) {\n this.raise(Errors.EscapedCharNotAnIdentifier, escStart);\n }\n word += String.fromCodePoint(esc);\n }\n chunkStart = this.state.pos;\n } else {\n break;\n }\n }\n return word + this.input.slice(chunkStart, this.state.pos);\n }\n readWord(firstCode) {\n const word = this.readWord1(firstCode);\n const type = keywords$1.get(word);\n if (type !== undefined) {\n this.finishToken(type, tokenLabelName(type));\n } else {\n this.finishToken(132, word);\n }\n }\n checkKeywordEscapes() {\n const {\n type\n } = this.state;\n if (tokenIsKeyword(type) && this.state.containsEsc) {\n this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, {\n reservedWord: tokenLabelName(type)\n });\n }\n }\n raise(toParseError, at, details = {}) {\n const loc = at instanceof Position ? at : at.loc.start;\n const error = toParseError(loc, details);\n if (!(this.optionFlags & 2048)) throw error;\n if (!this.isLookahead) this.state.errors.push(error);\n return error;\n }\n raiseOverwrite(toParseError, at, details = {}) {\n const loc = at instanceof Position ? at : at.loc.start;\n const pos = loc.index;\n const errors = this.state.errors;\n for (let i = errors.length - 1; i >= 0; i--) {\n const error = errors[i];\n if (error.loc.index === pos) {\n return errors[i] = toParseError(loc, details);\n }\n if (error.loc.index < pos) break;\n }\n return this.raise(toParseError, at, details);\n }\n updateContext(prevType) {}\n unexpected(loc, type) {\n throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, {\n expected: type ? tokenLabelName(type) : null\n });\n }\n expectPlugin(pluginName, loc) {\n if (this.hasPlugin(pluginName)) {\n return true;\n }\n throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, {\n missingPlugin: [pluginName]\n });\n }\n expectOnePlugin(pluginNames) {\n if (!pluginNames.some(name => this.hasPlugin(name))) {\n throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, {\n missingPlugin: pluginNames\n });\n }\n }\n errorBuilder(error) {\n return (pos, lineStart, curLine) => {\n this.raise(error, buildPosition(pos, lineStart, curLine));\n };\n }\n}\nclass ClassScope {\n constructor() {\n this.privateNames = new Set();\n this.loneAccessors = new Map();\n this.undefinedPrivateNames = new Map();\n }\n}\nclass ClassScopeHandler {\n constructor(parser) {\n this.parser = void 0;\n this.stack = [];\n this.undefinedPrivateNames = new Map();\n this.parser = parser;\n }\n current() {\n return this.stack[this.stack.length - 1];\n }\n enter() {\n this.stack.push(new ClassScope());\n }\n exit() {\n const oldClassScope = this.stack.pop();\n const current = this.current();\n for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {\n if (current) {\n if (!current.undefinedPrivateNames.has(name)) {\n current.undefinedPrivateNames.set(name, loc);\n }\n } else {\n this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {\n identifierName: name\n });\n }\n }\n }\n declarePrivateName(name, elementType, loc) {\n const {\n privateNames,\n loneAccessors,\n undefinedPrivateNames\n } = this.current();\n let redefined = privateNames.has(name);\n if (elementType & 3) {\n const accessor = redefined && loneAccessors.get(name);\n if (accessor) {\n const oldStatic = accessor & 4;\n const newStatic = elementType & 4;\n const oldKind = accessor & 3;\n const newKind = elementType & 3;\n redefined = oldKind === newKind || oldStatic !== newStatic;\n if (!redefined) loneAccessors.delete(name);\n } else if (!redefined) {\n loneAccessors.set(name, elementType);\n }\n }\n if (redefined) {\n this.parser.raise(Errors.PrivateNameRedeclaration, loc, {\n identifierName: name\n });\n }\n privateNames.add(name);\n undefinedPrivateNames.delete(name);\n }\n usePrivateName(name, loc) {\n let classScope;\n for (classScope of this.stack) {\n if (classScope.privateNames.has(name)) return;\n }\n if (classScope) {\n classScope.undefinedPrivateNames.set(name, loc);\n } else {\n this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, {\n identifierName: name\n });\n }\n }\n}\nclass ExpressionScope {\n constructor(type = 0) {\n this.type = type;\n }\n canBeArrowParameterDeclaration() {\n return this.type === 2 || this.type === 1;\n }\n isCertainlyParameterDeclaration() {\n return this.type === 3;\n }\n}\nclass ArrowHeadParsingScope extends ExpressionScope {\n constructor(type) {\n super(type);\n this.declarationErrors = new Map();\n }\n recordDeclarationError(ParsingErrorClass, at) {\n const index = at.index;\n this.declarationErrors.set(index, [ParsingErrorClass, at]);\n }\n clearDeclarationError(index) {\n this.declarationErrors.delete(index);\n }\n iterateErrors(iterator) {\n this.declarationErrors.forEach(iterator);\n }\n}\nclass ExpressionScopeHandler {\n constructor(parser) {\n this.parser = void 0;\n this.stack = [new ExpressionScope()];\n this.parser = parser;\n }\n enter(scope) {\n this.stack.push(scope);\n }\n exit() {\n this.stack.pop();\n }\n recordParameterInitializerError(toParseError, node) {\n const origin = node.loc.start;\n const {\n stack\n } = this;\n let i = stack.length - 1;\n let scope = stack[i];\n while (!scope.isCertainlyParameterDeclaration()) {\n if (scope.canBeArrowParameterDeclaration()) {\n scope.recordDeclarationError(toParseError, origin);\n } else {\n return;\n }\n scope = stack[--i];\n }\n this.parser.raise(toParseError, origin);\n }\n recordArrowParameterBindingError(error, node) {\n const {\n stack\n } = this;\n const scope = stack[stack.length - 1];\n const origin = node.loc.start;\n if (scope.isCertainlyParameterDeclaration()) {\n this.parser.raise(error, origin);\n } else if (scope.canBeArrowParameterDeclaration()) {\n scope.recordDeclarationError(error, origin);\n } else {\n return;\n }\n }\n recordAsyncArrowParametersError(at) {\n const {\n stack\n } = this;\n let i = stack.length - 1;\n let scope = stack[i];\n while (scope.canBeArrowParameterDeclaration()) {\n if (scope.type === 2) {\n scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);\n }\n scope = stack[--i];\n }\n }\n validateAsPattern() {\n const {\n stack\n } = this;\n const currentScope = stack[stack.length - 1];\n if (!currentScope.canBeArrowParameterDeclaration()) return;\n currentScope.iterateErrors(([toParseError, loc]) => {\n this.parser.raise(toParseError, loc);\n let i = stack.length - 2;\n let scope = stack[i];\n while (scope.canBeArrowParameterDeclaration()) {\n scope.clearDeclarationError(loc.index);\n scope = stack[--i];\n }\n });\n }\n}\nfunction newParameterDeclarationScope() {\n return new ExpressionScope(3);\n}\nfunction newArrowHeadScope() {\n return new ArrowHeadParsingScope(1);\n}\nfunction newAsyncArrowScope() {\n return new ArrowHeadParsingScope(2);\n}\nfunction newExpressionScope() {\n return new ExpressionScope();\n}\nclass UtilParser extends Tokenizer {\n addExtra(node, key, value, enumerable = true) {\n if (!node) return;\n let {\n extra\n } = node;\n if (extra == null) {\n extra = {};\n node.extra = extra;\n }\n if (enumerable) {\n extra[key] = value;\n } else {\n Object.defineProperty(extra, key, {\n enumerable,\n value\n });\n }\n }\n isContextual(token) {\n return this.state.type === token && !this.state.containsEsc;\n }\n isUnparsedContextual(nameStart, name) {\n if (this.input.startsWith(name, nameStart)) {\n const nextCh = this.input.charCodeAt(nameStart + name.length);\n return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);\n }\n return false;\n }\n isLookaheadContextual(name) {\n const next = this.nextTokenStart();\n return this.isUnparsedContextual(next, name);\n }\n eatContextual(token) {\n if (this.isContextual(token)) {\n this.next();\n return true;\n }\n return false;\n }\n expectContextual(token, toParseError) {\n if (!this.eatContextual(token)) {\n if (toParseError != null) {\n throw this.raise(toParseError, this.state.startLoc);\n }\n this.unexpected(null, token);\n }\n }\n canInsertSemicolon() {\n return this.match(140) || this.match(8) || this.hasPrecedingLineBreak();\n }\n hasPrecedingLineBreak() {\n return hasNewLine(this.input, this.offsetToSourcePos(this.state.lastTokEndLoc.index), this.state.start);\n }\n hasFollowingLineBreak() {\n return hasNewLine(this.input, this.state.end, this.nextTokenStart());\n }\n isLineTerminator() {\n return this.eat(13) || this.canInsertSemicolon();\n }\n semicolon(allowAsi = true) {\n if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;\n this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);\n }\n expect(type, loc) {\n if (!this.eat(type)) {\n this.unexpected(loc, type);\n }\n }\n tryParse(fn, oldState = this.state.clone()) {\n const abortSignal = {\n node: null\n };\n try {\n const node = fn((node = null) => {\n abortSignal.node = node;\n throw abortSignal;\n });\n if (this.state.errors.length > oldState.errors.length) {\n const failState = this.state;\n this.state = oldState;\n this.state.tokensLength = failState.tokensLength;\n return {\n node,\n error: failState.errors[oldState.errors.length],\n thrown: false,\n aborted: false,\n failState\n };\n }\n return {\n node: node,\n error: null,\n thrown: false,\n aborted: false,\n failState: null\n };\n } catch (error) {\n const failState = this.state;\n this.state = oldState;\n if (error instanceof SyntaxError) {\n return {\n node: null,\n error,\n thrown: true,\n aborted: false,\n failState\n };\n }\n if (error === abortSignal) {\n return {\n node: abortSignal.node,\n error: null,\n thrown: false,\n aborted: true,\n failState\n };\n }\n throw error;\n }\n }\n checkExpressionErrors(refExpressionErrors, andThrow) {\n if (!refExpressionErrors) return false;\n const {\n shorthandAssignLoc,\n doubleProtoLoc,\n privateKeyLoc,\n optionalParametersLoc,\n voidPatternLoc\n } = refExpressionErrors;\n const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc || !!voidPatternLoc;\n if (!andThrow) {\n return hasErrors;\n }\n if (shorthandAssignLoc != null) {\n this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);\n }\n if (doubleProtoLoc != null) {\n this.raise(Errors.DuplicateProto, doubleProtoLoc);\n }\n if (privateKeyLoc != null) {\n this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);\n }\n if (optionalParametersLoc != null) {\n this.unexpected(optionalParametersLoc);\n }\n if (voidPatternLoc != null) {\n this.raise(Errors.InvalidCoverDiscardElement, voidPatternLoc);\n }\n }\n isLiteralPropertyName() {\n return tokenIsLiteralPropertyName(this.state.type);\n }\n isPrivateName(node) {\n return node.type === \"PrivateName\";\n }\n getPrivateNameSV(node) {\n return node.id.name;\n }\n hasPropertyAsPrivateName(node) {\n return (node.type === \"MemberExpression\" || node.type === \"OptionalMemberExpression\") && this.isPrivateName(node.property);\n }\n isObjectProperty(node) {\n return node.type === \"ObjectProperty\";\n }\n isObjectMethod(node) {\n return node.type === \"ObjectMethod\";\n }\n initializeScopes(inModule = this.options.sourceType === \"module\") {\n const oldLabels = this.state.labels;\n this.state.labels = [];\n const oldExportedIdentifiers = this.exportedIdentifiers;\n this.exportedIdentifiers = new Set();\n const oldInModule = this.inModule;\n this.inModule = inModule;\n const oldScope = this.scope;\n const ScopeHandler = this.getScopeHandler();\n this.scope = new ScopeHandler(this, inModule);\n const oldProdParam = this.prodParam;\n this.prodParam = new ProductionParameterHandler();\n const oldClassScope = this.classScope;\n this.classScope = new ClassScopeHandler(this);\n const oldExpressionScope = this.expressionScope;\n this.expressionScope = new ExpressionScopeHandler(this);\n return () => {\n this.state.labels = oldLabels;\n this.exportedIdentifiers = oldExportedIdentifiers;\n this.inModule = oldInModule;\n this.scope = oldScope;\n this.prodParam = oldProdParam;\n this.classScope = oldClassScope;\n this.expressionScope = oldExpressionScope;\n };\n }\n enterInitialScopes() {\n let paramFlags = 0;\n if (this.inModule || this.optionFlags & 1) {\n paramFlags |= 2;\n }\n if (this.optionFlags & 32) {\n paramFlags |= 1;\n }\n const isCommonJS = !this.inModule && this.options.sourceType === \"commonjs\";\n if (isCommonJS || this.optionFlags & 2) {\n paramFlags |= 4;\n }\n this.prodParam.enter(paramFlags);\n let scopeFlags = isCommonJS ? 514 : 1;\n if (this.optionFlags & 4) {\n scopeFlags |= 512;\n }\n this.scope.enter(scopeFlags);\n }\n checkDestructuringPrivate(refExpressionErrors) {\n const {\n privateKeyLoc\n } = refExpressionErrors;\n if (privateKeyLoc !== null) {\n this.expectPlugin(\"destructuringPrivate\", privateKeyLoc);\n }\n }\n}\nclass ExpressionErrors {\n constructor() {\n this.shorthandAssignLoc = null;\n this.doubleProtoLoc = null;\n this.privateKeyLoc = null;\n this.optionalParametersLoc = null;\n this.voidPatternLoc = null;\n }\n}\nclass Node {\n constructor(parser, pos, loc) {\n this.type = \"\";\n this.start = pos;\n this.end = 0;\n this.loc = new SourceLocation(loc);\n if ((parser == null ? void 0 : parser.optionFlags) & 128) this.range = [pos, 0];\n if (parser != null && parser.filename) this.loc.filename = parser.filename;\n }\n}\nconst NodePrototype = Node.prototype;\nNodePrototype.__clone = function () {\n const newNode = new Node(undefined, this.start, this.loc.start);\n const keys = Object.keys(this);\n for (let i = 0, length = keys.length; i < length; i++) {\n const key = keys[i];\n if (key !== \"leadingComments\" && key !== \"trailingComments\" && key !== \"innerComments\") {\n newNode[key] = this[key];\n }\n }\n return newNode;\n};\nclass NodeUtils extends UtilParser {\n startNode() {\n const loc = this.state.startLoc;\n return new Node(this, loc.index, loc);\n }\n startNodeAt(loc) {\n return new Node(this, loc.index, loc);\n }\n startNodeAtNode(type) {\n return this.startNodeAt(type.loc.start);\n }\n finishNode(node, type) {\n return this.finishNodeAt(node, type, this.state.lastTokEndLoc);\n }\n finishNodeAt(node, type, endLoc) {\n node.type = type;\n node.end = endLoc.index;\n node.loc.end = endLoc;\n if (this.optionFlags & 128) node.range[1] = endLoc.index;\n if (this.optionFlags & 4096) {\n this.processComment(node);\n }\n return node;\n }\n resetStartLocation(node, startLoc) {\n node.start = startLoc.index;\n node.loc.start = startLoc;\n if (this.optionFlags & 128) node.range[0] = startLoc.index;\n }\n resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {\n node.end = endLoc.index;\n node.loc.end = endLoc;\n if (this.optionFlags & 128) node.range[1] = endLoc.index;\n }\n resetStartLocationFromNode(node, locationNode) {\n this.resetStartLocation(node, locationNode.loc.start);\n }\n castNodeTo(node, type) {\n node.type = type;\n return node;\n }\n cloneIdentifier(node) {\n const {\n type,\n start,\n end,\n loc,\n range,\n name\n } = node;\n const cloned = Object.create(NodePrototype);\n cloned.type = type;\n cloned.start = start;\n cloned.end = end;\n cloned.loc = loc;\n cloned.range = range;\n cloned.name = name;\n if (node.extra) cloned.extra = node.extra;\n return cloned;\n }\n cloneStringLiteral(node) {\n const {\n type,\n start,\n end,\n loc,\n range,\n extra\n } = node;\n const cloned = Object.create(NodePrototype);\n cloned.type = type;\n cloned.start = start;\n cloned.end = end;\n cloned.loc = loc;\n cloned.range = range;\n cloned.extra = extra;\n cloned.value = node.value;\n return cloned;\n }\n}\nconst unwrapParenthesizedExpression = node => {\n return node.type === \"ParenthesizedExpression\" ? unwrapParenthesizedExpression(node.expression) : node;\n};\nclass LValParser extends NodeUtils {\n toAssignable(node, isLHS = false) {\n var _node$extra, _node$extra3;\n let parenthesized = undefined;\n if (node.type === \"ParenthesizedExpression\" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {\n parenthesized = unwrapParenthesizedExpression(node);\n if (isLHS) {\n if (parenthesized.type === \"Identifier\") {\n this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);\n } else if (parenthesized.type !== \"CallExpression\" && parenthesized.type !== \"MemberExpression\" && !this.isOptionalMemberExpression(parenthesized)) {\n this.raise(Errors.InvalidParenthesizedAssignment, node);\n }\n } else {\n this.raise(Errors.InvalidParenthesizedAssignment, node);\n }\n }\n switch (node.type) {\n case \"Identifier\":\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n case \"AssignmentPattern\":\n case \"RestElement\":\n case \"VoidPattern\":\n break;\n case \"ObjectExpression\":\n this.castNodeTo(node, \"ObjectPattern\");\n for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {\n var _node$extra2;\n const prop = node.properties[i];\n const isLast = i === last;\n this.toAssignableObjectExpressionProp(prop, isLast, isLHS);\n if (isLast && prop.type === \"RestElement\" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {\n this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);\n }\n }\n break;\n case \"ObjectProperty\":\n {\n const {\n key,\n value\n } = node;\n if (this.isPrivateName(key)) {\n this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);\n }\n this.toAssignable(value, isLHS);\n break;\n }\n case \"SpreadElement\":\n {\n throw new Error(\"Internal @babel/parser error (this is a bug, please report it).\" + \" SpreadElement should be converted by .toAssignable's caller.\");\n }\n case \"ArrayExpression\":\n this.castNodeTo(node, \"ArrayPattern\");\n this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);\n break;\n case \"AssignmentExpression\":\n if (node.operator !== \"=\") {\n this.raise(Errors.MissingEqInAssignment, node.left.loc.end);\n }\n this.castNodeTo(node, \"AssignmentPattern\");\n delete node.operator;\n if (node.left.type === \"VoidPattern\") {\n this.raise(Errors.VoidPatternInitializer, node.left);\n }\n this.toAssignable(node.left, isLHS);\n break;\n case \"ParenthesizedExpression\":\n this.toAssignable(parenthesized, isLHS);\n break;\n }\n }\n toAssignableObjectExpressionProp(prop, isLast, isLHS) {\n if (prop.type === \"ObjectMethod\") {\n this.raise(prop.kind === \"get\" || prop.kind === \"set\" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key);\n } else if (prop.type === \"SpreadElement\") {\n this.castNodeTo(prop, \"RestElement\");\n const arg = prop.argument;\n this.checkToRestConversion(arg, false);\n this.toAssignable(arg, isLHS);\n if (!isLast) {\n this.raise(Errors.RestTrailingComma, prop);\n }\n } else {\n this.toAssignable(prop, isLHS);\n }\n }\n toAssignableList(exprList, trailingCommaLoc, isLHS) {\n const end = exprList.length - 1;\n for (let i = 0; i <= end; i++) {\n const elt = exprList[i];\n if (!elt) continue;\n this.toAssignableListItem(exprList, i, isLHS);\n if (elt.type === \"RestElement\") {\n if (i < end) {\n this.raise(Errors.RestTrailingComma, elt);\n } else if (trailingCommaLoc) {\n this.raise(Errors.RestTrailingComma, trailingCommaLoc);\n }\n }\n }\n }\n toAssignableListItem(exprList, index, isLHS) {\n const node = exprList[index];\n if (node.type === \"SpreadElement\") {\n this.castNodeTo(node, \"RestElement\");\n const arg = node.argument;\n this.checkToRestConversion(arg, true);\n this.toAssignable(arg, isLHS);\n } else {\n this.toAssignable(node, isLHS);\n }\n }\n isAssignable(node, isBinding) {\n switch (node.type) {\n case \"Identifier\":\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n case \"AssignmentPattern\":\n case \"RestElement\":\n case \"VoidPattern\":\n return true;\n case \"ObjectExpression\":\n {\n const last = node.properties.length - 1;\n return node.properties.every((prop, i) => {\n return prop.type !== \"ObjectMethod\" && (i === last || prop.type !== \"SpreadElement\") && this.isAssignable(prop);\n });\n }\n case \"ObjectProperty\":\n return this.isAssignable(node.value);\n case \"SpreadElement\":\n return this.isAssignable(node.argument);\n case \"ArrayExpression\":\n return node.elements.every(element => element === null || this.isAssignable(element));\n case \"AssignmentExpression\":\n return node.operator === \"=\";\n case \"ParenthesizedExpression\":\n return this.isAssignable(node.expression);\n case \"MemberExpression\":\n case \"OptionalMemberExpression\":\n return !isBinding;\n default:\n return false;\n }\n }\n toReferencedList(exprList, isParenthesizedExpr) {\n return exprList;\n }\n toReferencedListDeep(exprList, isParenthesizedExpr) {\n this.toReferencedList(exprList, isParenthesizedExpr);\n for (const expr of exprList) {\n if ((expr == null ? void 0 : expr.type) === \"ArrayExpression\") {\n this.toReferencedListDeep(expr.elements);\n }\n }\n }\n parseSpread(refExpressionErrors) {\n const node = this.startNode();\n this.next();\n node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);\n return this.finishNode(node, \"SpreadElement\");\n }\n parseRestBinding() {\n const node = this.startNode();\n this.next();\n const argument = this.parseBindingAtom();\n if (argument.type === \"VoidPattern\") {\n this.raise(Errors.UnexpectedVoidPattern, argument);\n }\n node.argument = argument;\n return this.finishNode(node, \"RestElement\");\n }\n parseBindingAtom() {\n switch (this.state.type) {\n case 0:\n {\n const node = this.startNode();\n this.next();\n node.elements = this.parseBindingList(3, 93, 1);\n return this.finishNode(node, \"ArrayPattern\");\n }\n case 5:\n return this.parseObjectLike(8, true);\n case 88:\n return this.parseVoidPattern(null);\n }\n return this.parseIdentifier();\n }\n parseBindingList(close, closeCharCode, flags) {\n const allowEmpty = flags & 1;\n const elts = [];\n let first = true;\n while (!this.eat(close)) {\n if (first) {\n first = false;\n } else {\n this.expect(12);\n }\n if (allowEmpty && this.match(12)) {\n elts.push(null);\n } else if (this.eat(close)) {\n break;\n } else if (this.match(21)) {\n let rest = this.parseRestBinding();\n if (this.hasPlugin(\"flow\") || flags & 2) {\n rest = this.parseFunctionParamType(rest);\n }\n elts.push(rest);\n if (!this.checkCommaAfterRest(closeCharCode)) {\n this.expect(close);\n break;\n }\n } else {\n const decorators = [];\n if (flags & 2) {\n if (this.match(26) && this.hasPlugin(\"decorators\")) {\n this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);\n }\n while (this.match(26)) {\n decorators.push(this.parseDecorator());\n }\n }\n elts.push(this.parseBindingElement(flags, decorators));\n }\n }\n return elts;\n }\n parseBindingRestProperty(prop) {\n this.next();\n if (this.hasPlugin(\"discardBinding\") && this.match(88)) {\n prop.argument = this.parseVoidPattern(null);\n this.raise(Errors.UnexpectedVoidPattern, prop.argument);\n } else {\n prop.argument = this.parseIdentifier();\n }\n this.checkCommaAfterRest(125);\n return this.finishNode(prop, \"RestElement\");\n }\n parseBindingProperty() {\n const {\n type,\n startLoc\n } = this.state;\n if (type === 21) {\n return this.parseBindingRestProperty(this.startNode());\n }\n const prop = this.startNode();\n if (type === 139) {\n this.expectPlugin(\"destructuringPrivate\", startLoc);\n this.classScope.usePrivateName(this.state.value, startLoc);\n prop.key = this.parsePrivateName();\n } else {\n this.parsePropertyName(prop);\n }\n prop.method = false;\n return this.parseObjPropValue(prop, startLoc, false, false, true, false);\n }\n parseBindingElement(flags, decorators) {\n const left = this.parseMaybeDefault();\n if (this.hasPlugin(\"flow\") || flags & 2) {\n this.parseFunctionParamType(left);\n }\n if (decorators.length) {\n left.decorators = decorators;\n this.resetStartLocationFromNode(left, decorators[0]);\n }\n const elt = this.parseMaybeDefault(left.loc.start, left);\n return elt;\n }\n parseFunctionParamType(param) {\n return param;\n }\n parseMaybeDefault(startLoc, left) {\n startLoc != null ? startLoc : startLoc = this.state.startLoc;\n left = left != null ? left : this.parseBindingAtom();\n if (!this.eat(29)) return left;\n const node = this.startNodeAt(startLoc);\n if (left.type === \"VoidPattern\") {\n this.raise(Errors.VoidPatternInitializer, left);\n }\n node.left = left;\n node.right = this.parseMaybeAssignAllowIn();\n return this.finishNode(node, \"AssignmentPattern\");\n }\n isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {\n switch (type) {\n case \"AssignmentPattern\":\n return \"left\";\n case \"RestElement\":\n return \"argument\";\n case \"ObjectProperty\":\n return \"value\";\n case \"ParenthesizedExpression\":\n return \"expression\";\n case \"ArrayPattern\":\n return \"elements\";\n case \"ObjectPattern\":\n return \"properties\";\n case \"VoidPattern\":\n return true;\n case \"CallExpression\":\n if (!disallowCallExpression && !this.state.strict && this.optionFlags & 8192) {\n return true;\n }\n }\n return false;\n }\n isOptionalMemberExpression(expression) {\n return expression.type === \"OptionalMemberExpression\";\n }\n checkLVal(expression, ancestor, binding = 64, checkClashes = false, strictModeChanged = false, hasParenthesizedAncestor = false, disallowCallExpression = false) {\n var _expression$extra;\n const type = expression.type;\n if (this.isObjectMethod(expression)) return;\n const isOptionalMemberExpression = this.isOptionalMemberExpression(expression);\n if (isOptionalMemberExpression || type === \"MemberExpression\") {\n if (isOptionalMemberExpression) {\n this.expectPlugin(\"optionalChainingAssign\", expression.loc.start);\n if (ancestor.type !== \"AssignmentExpression\") {\n this.raise(Errors.InvalidLhsOptionalChaining, expression, {\n ancestor\n });\n }\n }\n if (binding !== 64) {\n this.raise(Errors.InvalidPropertyBindingPattern, expression);\n }\n return;\n }\n if (type === \"Identifier\") {\n this.checkIdentifier(expression, binding, strictModeChanged);\n const {\n name\n } = expression;\n if (checkClashes) {\n if (checkClashes.has(name)) {\n this.raise(Errors.ParamDupe, expression);\n } else {\n checkClashes.add(name);\n }\n }\n return;\n } else if (type === \"VoidPattern\" && ancestor.type === \"CatchClause\") {\n this.raise(Errors.VoidPatternCatchClauseParam, expression);\n }\n const unwrappedExpression = unwrapParenthesizedExpression(expression);\n disallowCallExpression || (disallowCallExpression = unwrappedExpression.type === \"CallExpression\" && (unwrappedExpression.callee.type === \"Import\" || unwrappedExpression.callee.type === \"Super\"));\n const validity = this.isValidLVal(type, disallowCallExpression, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === \"AssignmentExpression\", binding);\n if (validity === true) return;\n if (validity === false) {\n const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;\n this.raise(ParseErrorClass, expression, {\n ancestor\n });\n return;\n }\n let key, isParenthesizedExpression;\n if (typeof validity === \"string\") {\n key = validity;\n isParenthesizedExpression = type === \"ParenthesizedExpression\";\n } else {\n [key, isParenthesizedExpression] = validity;\n }\n const nextAncestor = type === \"ArrayPattern\" || type === \"ObjectPattern\" ? {\n type\n } : ancestor;\n const val = expression[key];\n if (Array.isArray(val)) {\n for (const child of val) {\n if (child) {\n this.checkLVal(child, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, true);\n }\n }\n } else if (val) {\n this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, disallowCallExpression);\n }\n }\n checkIdentifier(at, bindingType, strictModeChanged = false) {\n if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {\n if (bindingType === 64) {\n this.raise(Errors.StrictEvalArguments, at, {\n referenceName: at.name\n });\n } else {\n this.raise(Errors.StrictEvalArgumentsBinding, at, {\n bindingName: at.name\n });\n }\n }\n if (bindingType & 8192 && at.name === \"let\") {\n this.raise(Errors.LetInLexicalBinding, at);\n }\n if (!(bindingType & 64)) {\n this.declareNameFromIdentifier(at, bindingType);\n }\n }\n declareNameFromIdentifier(identifier, binding) {\n this.scope.declareName(identifier.name, binding, identifier.loc.start);\n }\n checkToRestConversion(node, allowPattern) {\n switch (node.type) {\n case \"ParenthesizedExpression\":\n this.checkToRestConversion(node.expression, allowPattern);\n break;\n case \"Identifier\":\n case \"MemberExpression\":\n break;\n case \"ArrayExpression\":\n case \"ObjectExpression\":\n if (allowPattern) break;\n default:\n this.raise(Errors.InvalidRestAssignmentPattern, node);\n }\n }\n checkCommaAfterRest(close) {\n if (!this.match(12)) {\n return false;\n }\n this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc);\n return true;\n }\n}\nconst keywordAndTSRelationalOperator = /in(?:stanceof)?|as|satisfies/y;\nfunction nonNull(x) {\n if (x == null) {\n throw new Error(`Unexpected ${x} value.`);\n }\n return x;\n}\nfunction assert(x) {\n if (!x) {\n throw new Error(\"Assert fail\");\n }\n}\nconst TSErrors = ParseErrorEnum`typescript`({\n AbstractMethodHasImplementation: ({\n methodName\n }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,\n AbstractPropertyHasInitializer: ({\n propertyName\n }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,\n AccessorCannotBeOptional: \"An 'accessor' property cannot be declared optional.\",\n AccessorCannotDeclareThisParameter: \"'get' and 'set' accessors cannot declare 'this' parameters.\",\n AccessorCannotHaveTypeParameters: \"An accessor cannot have type parameters.\",\n ClassMethodHasDeclare: \"Class methods cannot have the 'declare' modifier.\",\n ClassMethodHasReadonly: \"Class methods cannot have the 'readonly' modifier.\",\n ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: \"A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.\",\n ConstructorHasTypeParameters: \"Type parameters cannot appear on a constructor declaration.\",\n DeclareAccessor: ({\n kind\n }) => `'declare' is not allowed in ${kind}ters.`,\n DeclareClassFieldHasInitializer: \"Initializers are not allowed in ambient contexts.\",\n DeclareFunctionHasImplementation: \"An implementation cannot be declared in ambient contexts.\",\n DuplicateAccessibilityModifier: ({\n modifier\n }) => `Accessibility modifier already seen: '${modifier}'.`,\n DuplicateModifier: ({\n modifier\n }) => `Duplicate modifier: '${modifier}'.`,\n EmptyHeritageClauseType: ({\n token\n }) => `'${token}' list cannot be empty.`,\n EmptyTypeArguments: \"Type argument list cannot be empty.\",\n EmptyTypeParameters: \"Type parameter list cannot be empty.\",\n ExpectedAmbientAfterExportDeclare: \"'export declare' must be followed by an ambient declaration.\",\n ImportAliasHasImportType: \"An import alias can not use 'import type'.\",\n ImportReflectionHasImportType: \"An `import module` declaration can not use `type` modifier\",\n IncompatibleModifiers: ({\n modifiers\n }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,\n IndexSignatureHasAbstract: \"Index signatures cannot have the 'abstract' modifier.\",\n IndexSignatureHasAccessibility: ({\n modifier\n }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,\n IndexSignatureHasDeclare: \"Index signatures cannot have the 'declare' modifier.\",\n IndexSignatureHasOverride: \"'override' modifier cannot appear on an index signature.\",\n IndexSignatureHasStatic: \"Index signatures cannot have the 'static' modifier.\",\n InitializerNotAllowedInAmbientContext: \"Initializers are not allowed in ambient contexts.\",\n InvalidHeritageClauseType: ({\n token\n }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,\n InvalidModifierOnAwaitUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on an await using declaration.`,\n InvalidModifierOnTypeMember: ({\n modifier\n }) => `'${modifier}' modifier cannot appear on a type member.`,\n InvalidModifierOnTypeParameter: ({\n modifier\n }) => `'${modifier}' modifier cannot appear on a type parameter.`,\n InvalidModifierOnTypeParameterPositions: ({\n modifier\n }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,\n InvalidModifierOnUsingDeclaration: modifier => `'${modifier}' modifier cannot appear on a using declaration.`,\n InvalidModifiersOrder: ({\n orderedModifiers\n }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,\n InvalidPropertyAccessAfterInstantiationExpression: \"Invalid property access after an instantiation expression. \" + \"You can either wrap the instantiation expression in parentheses, or delete the type arguments.\",\n InvalidTupleMemberLabel: \"Tuple members must be labeled with a simple identifier.\",\n MissingInterfaceName: \"'interface' declarations must be followed by an identifier.\",\n NonAbstractClassHasAbstractMethod: \"Abstract methods can only appear within an abstract class.\",\n NonClassMethodPropertyHasAbstractModifier: \"'abstract' modifier can only appear on a class, method, or property declaration.\",\n OptionalTypeBeforeRequired: \"A required element cannot follow an optional element.\",\n OverrideNotInSubClass: \"This member cannot have an 'override' modifier because its containing class does not extend another class.\",\n PatternIsOptional: \"A binding pattern parameter cannot be optional in an implementation signature.\",\n PrivateElementHasAbstract: \"Private elements cannot have the 'abstract' modifier.\",\n PrivateElementHasAccessibility: ({\n modifier\n }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,\n ReadonlyForMethodSignature: \"'readonly' modifier can only appear on a property declaration or index signature.\",\n ReservedArrowTypeParam: \"This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `() => ...`.\",\n ReservedTypeAssertion: \"This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.\",\n SetAccessorCannotHaveOptionalParameter: \"A 'set' accessor cannot have an optional parameter.\",\n SetAccessorCannotHaveRestParameter: \"A 'set' accessor cannot have rest parameter.\",\n SetAccessorCannotHaveReturnType: \"A 'set' accessor cannot have a return type annotation.\",\n SingleTypeParameterWithoutTrailingComma: ({\n typeParameterName\n }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,\n StaticBlockCannotHaveModifier: \"Static class blocks cannot have any modifier.\",\n TupleOptionalAfterType: \"A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).\",\n TypeAnnotationAfterAssign: \"Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.\",\n TypeImportCannotSpecifyDefaultAndNamed: \"A type-only import can specify a default import or named bindings, but not both.\",\n TypeModifierIsUsedInTypeExports: \"The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.\",\n TypeModifierIsUsedInTypeImports: \"The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.\",\n UnexpectedParameterModifier: \"A parameter property is only allowed in a constructor implementation.\",\n UnexpectedReadonly: \"'readonly' type modifier is only permitted on array and tuple literal types.\",\n UnexpectedTypeAnnotation: \"Did not expect a type annotation here.\",\n UnexpectedTypeCastInParameter: \"Unexpected type cast in parameter position.\",\n UnsupportedImportTypeArgument: \"Argument in a type import must be a string literal.\",\n UnsupportedParameterPropertyKind: \"A parameter property may not be declared using a binding pattern.\",\n UnsupportedSignatureParameterKind: ({\n type\n }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,\n UsingDeclarationInAmbientContext: kind => `'${kind}' declarations are not allowed in ambient contexts.`\n});\nfunction keywordTypeFromName(value) {\n switch (value) {\n case \"any\":\n return \"TSAnyKeyword\";\n case \"boolean\":\n return \"TSBooleanKeyword\";\n case \"bigint\":\n return \"TSBigIntKeyword\";\n case \"never\":\n return \"TSNeverKeyword\";\n case \"number\":\n return \"TSNumberKeyword\";\n case \"object\":\n return \"TSObjectKeyword\";\n case \"string\":\n return \"TSStringKeyword\";\n case \"symbol\":\n return \"TSSymbolKeyword\";\n case \"undefined\":\n return \"TSUndefinedKeyword\";\n case \"unknown\":\n return \"TSUnknownKeyword\";\n default:\n return undefined;\n }\n}\nfunction tsIsAccessModifier(modifier) {\n return modifier === \"private\" || modifier === \"public\" || modifier === \"protected\";\n}\nfunction tsIsVarianceAnnotations(modifier) {\n return modifier === \"in\" || modifier === \"out\";\n}\nvar typescript = superClass => class TypeScriptParserMixin extends superClass {\n constructor(...args) {\n super(...args);\n this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {\n allowedModifiers: [\"in\", \"out\"],\n disallowedModifiers: [\"const\", \"public\", \"private\", \"protected\", \"readonly\", \"declare\", \"abstract\", \"override\"],\n errorTemplate: TSErrors.InvalidModifierOnTypeParameter\n });\n this.tsParseConstModifier = this.tsParseModifiers.bind(this, {\n allowedModifiers: [\"const\"],\n disallowedModifiers: [\"in\", \"out\"],\n errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions\n });\n this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {\n allowedModifiers: [\"in\", \"out\", \"const\"],\n disallowedModifiers: [\"public\", \"private\", \"protected\", \"readonly\", \"declare\", \"abstract\", \"override\"],\n errorTemplate: TSErrors.InvalidModifierOnTypeParameter\n });\n }\n getScopeHandler() {\n return TypeScriptScopeHandler;\n }\n tsIsIdentifier() {\n return tokenIsIdentifier(this.state.type);\n }\n tsTokenCanFollowModifier() {\n return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(139) || this.isLiteralPropertyName();\n }\n tsNextTokenOnSameLineAndCanFollowModifier() {\n this.next();\n if (this.hasPrecedingLineBreak()) {\n return false;\n }\n return this.tsTokenCanFollowModifier();\n }\n tsNextTokenCanFollowModifier() {\n if (this.match(106)) {\n this.next();\n return this.tsTokenCanFollowModifier();\n }\n return this.tsNextTokenOnSameLineAndCanFollowModifier();\n }\n tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {\n if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {\n return undefined;\n }\n const modifier = this.state.value;\n if (allowedModifiers.includes(modifier)) {\n if (hasSeenStaticModifier && this.match(106)) {\n return undefined;\n }\n if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {\n return undefined;\n }\n if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {\n return modifier;\n }\n }\n return undefined;\n }\n tsParseModifiers({\n allowedModifiers,\n disallowedModifiers,\n stopOnStartOfClassStaticBlock,\n errorTemplate = TSErrors.InvalidModifierOnTypeMember\n }, modified) {\n const enforceOrder = (loc, modifier, before, after) => {\n if (modifier === before && modified[after]) {\n this.raise(TSErrors.InvalidModifiersOrder, loc, {\n orderedModifiers: [before, after]\n });\n }\n };\n const incompatible = (loc, modifier, mod1, mod2) => {\n if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {\n this.raise(TSErrors.IncompatibleModifiers, loc, {\n modifiers: [mod1, mod2]\n });\n }\n };\n for (;;) {\n const {\n startLoc\n } = this.state;\n const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock, modified.static);\n if (!modifier) break;\n if (tsIsAccessModifier(modifier)) {\n if (modified.accessibility) {\n this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {\n modifier\n });\n } else {\n enforceOrder(startLoc, modifier, modifier, \"override\");\n enforceOrder(startLoc, modifier, modifier, \"static\");\n enforceOrder(startLoc, modifier, modifier, \"readonly\");\n modified.accessibility = modifier;\n }\n } else if (tsIsVarianceAnnotations(modifier)) {\n if (modified[modifier]) {\n this.raise(TSErrors.DuplicateModifier, startLoc, {\n modifier\n });\n }\n modified[modifier] = true;\n enforceOrder(startLoc, modifier, \"in\", \"out\");\n } else {\n if (hasOwnProperty.call(modified, modifier)) {\n this.raise(TSErrors.DuplicateModifier, startLoc, {\n modifier\n });\n } else {\n enforceOrder(startLoc, modifier, \"static\", \"readonly\");\n enforceOrder(startLoc, modifier, \"static\", \"override\");\n enforceOrder(startLoc, modifier, \"override\", \"readonly\");\n enforceOrder(startLoc, modifier, \"abstract\", \"override\");\n incompatible(startLoc, modifier, \"declare\", \"override\");\n incompatible(startLoc, modifier, \"static\", \"abstract\");\n }\n modified[modifier] = true;\n }\n if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {\n this.raise(errorTemplate, startLoc, {\n modifier\n });\n }\n }\n }\n tsIsListTerminator(kind) {\n switch (kind) {\n case \"EnumMembers\":\n case \"TypeMembers\":\n return this.match(8);\n case \"HeritageClauseElement\":\n return this.match(5);\n case \"TupleElementTypes\":\n return this.match(3);\n case \"TypeParametersOrArguments\":\n return this.match(48);\n }\n }\n tsParseList(kind, parseElement) {\n const result = [];\n while (!this.tsIsListTerminator(kind)) {\n result.push(parseElement());\n }\n return result;\n }\n tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {\n return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));\n }\n tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {\n const result = [];\n let trailingCommaPos = -1;\n for (;;) {\n if (this.tsIsListTerminator(kind)) {\n break;\n }\n trailingCommaPos = -1;\n const element = parseElement();\n if (element == null) {\n return undefined;\n }\n result.push(element);\n if (this.eat(12)) {\n trailingCommaPos = this.state.lastTokStartLoc.index;\n continue;\n }\n if (this.tsIsListTerminator(kind)) {\n break;\n }\n if (expectSuccess) {\n this.expect(12);\n }\n return undefined;\n }\n if (refTrailingCommaPos) {\n refTrailingCommaPos.value = trailingCommaPos;\n }\n return result;\n }\n tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {\n if (!skipFirstToken) {\n if (bracket) {\n this.expect(0);\n } else {\n this.expect(47);\n }\n }\n const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);\n if (bracket) {\n this.expect(3);\n } else {\n this.expect(48);\n }\n return result;\n }\n tsParseImportType() {\n const node = this.startNode();\n this.expect(83);\n this.expect(10);\n if (!this.match(134)) {\n this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);\n node.argument = super.parseExprAtom();\n } else {\n node.argument = this.parseStringLiteral(this.state.value);\n }\n if (this.eat(12)) {\n node.options = this.tsParseImportTypeOptions();\n } else {\n node.options = null;\n }\n this.expect(11);\n if (this.eat(16)) {\n node.qualifier = this.tsParseEntityName(1 | 2);\n }\n if (this.match(47)) {\n node.typeParameters = this.tsParseTypeArguments();\n }\n return this.finishNode(node, \"TSImportType\");\n }\n tsParseImportTypeOptions() {\n const node = this.startNode();\n this.expect(5);\n const withProperty = this.startNode();\n if (this.isContextual(76)) {\n withProperty.method = false;\n withProperty.key = this.parseIdentifier(true);\n withProperty.computed = false;\n withProperty.shorthand = false;\n } else {\n this.unexpected(null, 76);\n }\n this.expect(14);\n withProperty.value = this.tsParseImportTypeWithPropertyValue();\n node.properties = [this.finishObjectProperty(withProperty)];\n this.eat(12);\n this.expect(8);\n return this.finishNode(node, \"ObjectExpression\");\n }\n tsParseImportTypeWithPropertyValue() {\n const node = this.startNode();\n const properties = [];\n this.expect(5);\n while (!this.match(8)) {\n const type = this.state.type;\n if (tokenIsIdentifier(type) || type === 134) {\n properties.push(super.parsePropertyDefinition(null));\n } else {\n this.unexpected();\n }\n this.eat(12);\n }\n node.properties = properties;\n this.next();\n return this.finishNode(node, \"ObjectExpression\");\n }\n tsParseEntityName(flags) {\n let entity;\n if (flags & 1 && this.match(78)) {\n if (flags & 2) {\n entity = this.parseIdentifier(true);\n } else {\n const node = this.startNode();\n this.next();\n entity = this.finishNode(node, \"ThisExpression\");\n }\n } else {\n entity = this.parseIdentifier(!!(flags & 1));\n }\n while (this.eat(16)) {\n const node = this.startNodeAtNode(entity);\n node.left = entity;\n node.right = this.parseIdentifier(!!(flags & 1));\n entity = this.finishNode(node, \"TSQualifiedName\");\n }\n return entity;\n }\n tsParseTypeReference() {\n const node = this.startNode();\n node.typeName = this.tsParseEntityName(1);\n if (!this.hasPrecedingLineBreak() && this.match(47)) {\n node.typeParameters = this.tsParseTypeArguments();\n }\n return this.finishNode(node, \"TSTypeReference\");\n }\n tsParseThisTypePredicate(lhs) {\n this.next();\n const node = this.startNodeAtNode(lhs);\n node.parameterName = lhs;\n node.typeAnnotation = this.tsParseTypeAnnotation(false);\n node.asserts = false;\n return this.finishNode(node, \"TSTypePredicate\");\n }\n tsParseThisTypeNode() {\n const node = this.startNode();\n this.next();\n return this.finishNode(node, \"TSThisType\");\n }\n tsParseTypeQuery() {\n const node = this.startNode();\n this.expect(87);\n if (this.match(83)) {\n node.exprName = this.tsParseImportType();\n } else {\n node.exprName = this.tsParseEntityName(1 | 2);\n }\n if (!this.hasPrecedingLineBreak() && this.match(47)) {\n node.typeParameters = this.tsParseTypeArguments();\n }\n return this.finishNode(node, \"TSTypeQuery\");\n }\n tsParseTypeParameter(parseModifiers) {\n const node = this.startNode();\n parseModifiers(node);\n node.name = this.tsParseTypeParameterName();\n node.constraint = this.tsEatThenParseType(81);\n node.default = this.tsEatThenParseType(29);\n return this.finishNode(node, \"TSTypeParameter\");\n }\n tsTryParseTypeParameters(parseModifiers) {\n if (this.match(47)) {\n return this.tsParseTypeParameters(parseModifiers);\n }\n }\n tsParseTypeParameters(parseModifiers) {\n const node = this.startNode();\n if (this.match(47) || this.match(143)) {\n this.next();\n } else {\n this.unexpected();\n }\n const refTrailingCommaPos = {\n value: -1\n };\n node.params = this.tsParseBracketedList(\"TypeParametersOrArguments\", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);\n if (node.params.length === 0) {\n this.raise(TSErrors.EmptyTypeParameters, node);\n }\n if (refTrailingCommaPos.value !== -1) {\n this.addExtra(node, \"trailingComma\", refTrailingCommaPos.value);\n }\n return this.finishNode(node, \"TSTypeParameterDeclaration\");\n }\n tsFillSignature(returnToken, signature) {\n const returnTokenRequired = returnToken === 19;\n const paramsKey = \"parameters\";\n const returnTypeKey = \"typeAnnotation\";\n signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n this.expect(10);\n signature[paramsKey] = this.tsParseBindingListForSignature();\n if (returnTokenRequired) {\n signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n } else if (this.match(returnToken)) {\n signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);\n }\n }\n tsParseBindingListForSignature() {\n const list = super.parseBindingList(11, 41, 2);\n for (const pattern of list) {\n const {\n type\n } = pattern;\n if (type === \"AssignmentPattern\" || type === \"TSParameterProperty\") {\n this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {\n type\n });\n }\n }\n return list;\n }\n tsParseTypeMemberSemicolon() {\n if (!this.eat(12) && !this.isLineTerminator()) {\n this.expect(13);\n }\n }\n tsParseSignatureMember(kind, node) {\n this.tsFillSignature(14, node);\n this.tsParseTypeMemberSemicolon();\n return this.finishNode(node, kind);\n }\n tsIsUnambiguouslyIndexSignature() {\n this.next();\n if (tokenIsIdentifier(this.state.type)) {\n this.next();\n return this.match(14);\n }\n return false;\n }\n tsTryParseIndexSignature(node) {\n if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {\n return;\n }\n this.expect(0);\n const id = this.parseIdentifier();\n id.typeAnnotation = this.tsParseTypeAnnotation();\n this.resetEndLocation(id);\n this.expect(3);\n node.parameters = [id];\n const type = this.tsTryParseTypeAnnotation();\n if (type) node.typeAnnotation = type;\n this.tsParseTypeMemberSemicolon();\n return this.finishNode(node, \"TSIndexSignature\");\n }\n tsParsePropertyOrMethodSignature(node, readonly) {\n if (this.eat(17)) node.optional = true;\n if (this.match(10) || this.match(47)) {\n if (readonly) {\n this.raise(TSErrors.ReadonlyForMethodSignature, node);\n }\n const method = node;\n if (method.kind && this.match(47)) {\n this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());\n }\n this.tsFillSignature(14, method);\n this.tsParseTypeMemberSemicolon();\n const paramsKey = \"parameters\";\n const returnTypeKey = \"typeAnnotation\";\n if (method.kind === \"get\") {\n if (method[paramsKey].length > 0) {\n this.raise(Errors.BadGetterArity, this.state.curPosition());\n if (this.isThisParam(method[paramsKey][0])) {\n this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());\n }\n }\n } else if (method.kind === \"set\") {\n if (method[paramsKey].length !== 1) {\n this.raise(Errors.BadSetterArity, this.state.curPosition());\n } else {\n const firstParameter = method[paramsKey][0];\n if (this.isThisParam(firstParameter)) {\n this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());\n }\n if (firstParameter.type === \"Identifier\" && firstParameter.optional) {\n this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());\n }\n if (firstParameter.type === \"RestElement\") {\n this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition());\n }\n }\n if (method[returnTypeKey]) {\n this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]);\n }\n } else {\n method.kind = \"method\";\n }\n return this.finishNode(method, \"TSMethodSignature\");\n } else {\n const property = node;\n if (readonly) property.readonly = true;\n const type = this.tsTryParseTypeAnnotation();\n if (type) property.typeAnnotation = type;\n this.tsParseTypeMemberSemicolon();\n return this.finishNode(property, \"TSPropertySignature\");\n }\n }\n tsParseTypeMember() {\n const node = this.startNode();\n if (this.match(10) || this.match(47)) {\n return this.tsParseSignatureMember(\"TSCallSignatureDeclaration\", node);\n }\n if (this.match(77)) {\n const id = this.startNode();\n this.next();\n if (this.match(10) || this.match(47)) {\n return this.tsParseSignatureMember(\"TSConstructSignatureDeclaration\", node);\n } else {\n node.key = this.createIdentifier(id, \"new\");\n return this.tsParsePropertyOrMethodSignature(node, false);\n }\n }\n this.tsParseModifiers({\n allowedModifiers: [\"readonly\"],\n disallowedModifiers: [\"declare\", \"abstract\", \"private\", \"protected\", \"public\", \"static\", \"override\"]\n }, node);\n const idx = this.tsTryParseIndexSignature(node);\n if (idx) {\n return idx;\n }\n super.parsePropertyName(node);\n if (!node.computed && node.key.type === \"Identifier\" && (node.key.name === \"get\" || node.key.name === \"set\") && this.tsTokenCanFollowModifier()) {\n node.kind = node.key.name;\n super.parsePropertyName(node);\n if (!this.match(10) && !this.match(47)) {\n this.unexpected(null, 10);\n }\n }\n return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);\n }\n tsParseTypeLiteral() {\n const node = this.startNode();\n node.members = this.tsParseObjectTypeMembers();\n return this.finishNode(node, \"TSTypeLiteral\");\n }\n tsParseObjectTypeMembers() {\n this.expect(5);\n const members = this.tsParseList(\"TypeMembers\", this.tsParseTypeMember.bind(this));\n this.expect(8);\n return members;\n }\n tsIsStartOfMappedType() {\n this.next();\n if (this.eat(53)) {\n return this.isContextual(122);\n }\n if (this.isContextual(122)) {\n this.next();\n }\n if (!this.match(0)) {\n return false;\n }\n this.next();\n if (!this.tsIsIdentifier()) {\n return false;\n }\n this.next();\n return this.match(58);\n }\n tsParseMappedType() {\n const node = this.startNode();\n this.expect(5);\n if (this.match(53)) {\n node.readonly = this.state.value;\n this.next();\n this.expectContextual(122);\n } else if (this.eatContextual(122)) {\n node.readonly = true;\n }\n this.expect(0);\n const typeParameter = this.startNode();\n typeParameter.name = this.tsParseTypeParameterName();\n typeParameter.constraint = this.tsExpectThenParseType(58);\n node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n node.nameType = this.eatContextual(93) ? this.tsParseType() : null;\n this.expect(3);\n if (this.match(53)) {\n node.optional = this.state.value;\n this.next();\n this.expect(17);\n } else if (this.eat(17)) {\n node.optional = true;\n }\n node.typeAnnotation = this.tsTryParseType();\n this.semicolon();\n this.expect(8);\n return this.finishNode(node, \"TSMappedType\");\n }\n tsParseTupleType() {\n const node = this.startNode();\n node.elementTypes = this.tsParseBracketedList(\"TupleElementTypes\", this.tsParseTupleElementType.bind(this), true, false);\n let seenOptionalElement = false;\n node.elementTypes.forEach(elementNode => {\n const {\n type\n } = elementNode;\n if (seenOptionalElement && type !== \"TSRestType\" && type !== \"TSOptionalType\" && !(type === \"TSNamedTupleMember\" && elementNode.optional)) {\n this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);\n }\n seenOptionalElement || (seenOptionalElement = type === \"TSNamedTupleMember\" && elementNode.optional || type === \"TSOptionalType\");\n });\n return this.finishNode(node, \"TSTupleType\");\n }\n tsParseTupleElementType() {\n const restStartLoc = this.state.startLoc;\n const rest = this.eat(21);\n const {\n startLoc\n } = this.state;\n let labeled;\n let label;\n let optional;\n let type;\n const isWord = tokenIsKeywordOrIdentifier(this.state.type);\n const chAfterWord = isWord ? this.lookaheadCharCode() : null;\n if (chAfterWord === 58) {\n labeled = true;\n optional = false;\n label = this.parseIdentifier(true);\n this.expect(14);\n type = this.tsParseType();\n } else if (chAfterWord === 63) {\n optional = true;\n const wordName = this.state.value;\n const typeOrLabel = this.tsParseNonArrayType();\n if (this.lookaheadCharCode() === 58) {\n labeled = true;\n label = this.createIdentifier(this.startNodeAt(startLoc), wordName);\n this.expect(17);\n this.expect(14);\n type = this.tsParseType();\n } else {\n labeled = false;\n type = typeOrLabel;\n this.expect(17);\n }\n } else {\n type = this.tsParseType();\n optional = this.eat(17);\n labeled = this.eat(14);\n }\n if (labeled) {\n let labeledNode;\n if (label) {\n labeledNode = this.startNodeAt(startLoc);\n labeledNode.optional = optional;\n labeledNode.label = label;\n labeledNode.elementType = type;\n if (this.eat(17)) {\n labeledNode.optional = true;\n this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);\n }\n } else {\n labeledNode = this.startNodeAt(startLoc);\n labeledNode.optional = optional;\n this.raise(TSErrors.InvalidTupleMemberLabel, type);\n labeledNode.label = type;\n labeledNode.elementType = this.tsParseType();\n }\n type = this.finishNode(labeledNode, \"TSNamedTupleMember\");\n } else if (optional) {\n const optionalTypeNode = this.startNodeAt(startLoc);\n optionalTypeNode.typeAnnotation = type;\n type = this.finishNode(optionalTypeNode, \"TSOptionalType\");\n }\n if (rest) {\n const restNode = this.startNodeAt(restStartLoc);\n restNode.typeAnnotation = type;\n type = this.finishNode(restNode, \"TSRestType\");\n }\n return type;\n }\n tsParseParenthesizedType() {\n const node = this.startNode();\n this.expect(10);\n node.typeAnnotation = this.tsParseType();\n this.expect(11);\n return this.finishNode(node, \"TSParenthesizedType\");\n }\n tsParseFunctionOrConstructorType(type, abstract) {\n const node = this.startNode();\n if (type === \"TSConstructorType\") {\n node.abstract = !!abstract;\n if (abstract) this.next();\n this.next();\n }\n this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));\n return this.finishNode(node, type);\n }\n tsParseLiteralTypeNode() {\n const node = this.startNode();\n switch (this.state.type) {\n case 135:\n case 136:\n case 134:\n case 85:\n case 86:\n node.literal = super.parseExprAtom();\n break;\n default:\n this.unexpected();\n }\n return this.finishNode(node, \"TSLiteralType\");\n }\n tsParseTemplateLiteralType() {\n const node = this.startNode();\n node.literal = super.parseTemplate(false);\n return this.finishNode(node, \"TSLiteralType\");\n }\n parseTemplateSubstitution() {\n if (this.state.inType) return this.tsParseType();\n return super.parseTemplateSubstitution();\n }\n tsParseThisTypeOrThisTypePredicate() {\n const thisKeyword = this.tsParseThisTypeNode();\n if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {\n return this.tsParseThisTypePredicate(thisKeyword);\n } else {\n return thisKeyword;\n }\n }\n tsParseNonArrayType() {\n switch (this.state.type) {\n case 134:\n case 135:\n case 136:\n case 85:\n case 86:\n return this.tsParseLiteralTypeNode();\n case 53:\n if (this.state.value === \"-\") {\n const node = this.startNode();\n const nextToken = this.lookahead();\n if (nextToken.type !== 135 && nextToken.type !== 136) {\n this.unexpected();\n }\n node.literal = this.parseMaybeUnary();\n return this.finishNode(node, \"TSLiteralType\");\n }\n break;\n case 78:\n return this.tsParseThisTypeOrThisTypePredicate();\n case 87:\n return this.tsParseTypeQuery();\n case 83:\n return this.tsParseImportType();\n case 5:\n return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();\n case 0:\n return this.tsParseTupleType();\n case 10:\n return this.tsParseParenthesizedType();\n case 25:\n case 24:\n return this.tsParseTemplateLiteralType();\n default:\n {\n const {\n type\n } = this.state;\n if (tokenIsIdentifier(type) || type === 88 || type === 84) {\n const nodeType = type === 88 ? \"TSVoidKeyword\" : type === 84 ? \"TSNullKeyword\" : keywordTypeFromName(this.state.value);\n if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {\n const node = this.startNode();\n this.next();\n return this.finishNode(node, nodeType);\n }\n return this.tsParseTypeReference();\n }\n }\n }\n throw this.unexpected();\n }\n tsParseArrayTypeOrHigher() {\n const {\n startLoc\n } = this.state;\n let type = this.tsParseNonArrayType();\n while (!this.hasPrecedingLineBreak() && this.eat(0)) {\n if (this.match(3)) {\n const node = this.startNodeAt(startLoc);\n node.elementType = type;\n this.expect(3);\n type = this.finishNode(node, \"TSArrayType\");\n } else {\n const node = this.startNodeAt(startLoc);\n node.objectType = type;\n node.indexType = this.tsParseType();\n this.expect(3);\n type = this.finishNode(node, \"TSIndexedAccessType\");\n }\n }\n return type;\n }\n tsParseTypeOperator() {\n const node = this.startNode();\n const operator = this.state.value;\n this.next();\n node.operator = operator;\n node.typeAnnotation = this.tsParseTypeOperatorOrHigher();\n if (operator === \"readonly\") {\n this.tsCheckTypeAnnotationForReadOnly(node);\n }\n return this.finishNode(node, \"TSTypeOperator\");\n }\n tsCheckTypeAnnotationForReadOnly(node) {\n switch (node.typeAnnotation.type) {\n case \"TSTupleType\":\n case \"TSArrayType\":\n return;\n default:\n this.raise(TSErrors.UnexpectedReadonly, node);\n }\n }\n tsParseInferType() {\n const node = this.startNode();\n this.expectContextual(115);\n const typeParameter = this.startNode();\n typeParameter.name = this.tsParseTypeParameterName();\n typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());\n node.typeParameter = this.finishNode(typeParameter, \"TSTypeParameter\");\n return this.finishNode(node, \"TSInferType\");\n }\n tsParseConstraintForInferType() {\n if (this.eat(81)) {\n const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());\n if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {\n return constraint;\n }\n }\n }\n tsParseTypeOperatorOrHigher() {\n const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;\n return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());\n }\n tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {\n const node = this.startNode();\n const hasLeadingOperator = this.eat(operator);\n const types = [];\n do {\n types.push(parseConstituentType());\n } while (this.eat(operator));\n if (types.length === 1 && !hasLeadingOperator) {\n return types[0];\n }\n node.types = types;\n return this.finishNode(node, kind);\n }\n tsParseIntersectionTypeOrHigher() {\n return this.tsParseUnionOrIntersectionType(\"TSIntersectionType\", this.tsParseTypeOperatorOrHigher.bind(this), 45);\n }\n tsParseUnionTypeOrHigher() {\n return this.tsParseUnionOrIntersectionType(\"TSUnionType\", this.tsParseIntersectionTypeOrHigher.bind(this), 43);\n }\n tsIsStartOfFunctionType() {\n if (this.match(47)) {\n return true;\n }\n return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));\n }\n tsSkipParameterStart() {\n if (tokenIsIdentifier(this.state.type) || this.match(78)) {\n this.next();\n return true;\n }\n if (this.match(5)) {\n const {\n errors\n } = this.state;\n const previousErrorCount = errors.length;\n try {\n this.parseObjectLike(8, true);\n return errors.length === previousErrorCount;\n } catch (_unused) {\n return false;\n }\n }\n if (this.match(0)) {\n this.next();\n const {\n errors\n } = this.state;\n const previousErrorCount = errors.length;\n try {\n super.parseBindingList(3, 93, 1);\n return errors.length === previousErrorCount;\n } catch (_unused2) {\n return false;\n }\n }\n return false;\n }\n tsIsUnambiguouslyStartOfFunctionType() {\n this.next();\n if (this.match(11) || this.match(21)) {\n return true;\n }\n if (this.tsSkipParameterStart()) {\n if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {\n return true;\n }\n if (this.match(11)) {\n this.next();\n if (this.match(19)) {\n return true;\n }\n }\n }\n return false;\n }\n tsParseTypeOrTypePredicateAnnotation(returnToken) {\n return this.tsInType(() => {\n const t = this.startNode();\n this.expect(returnToken);\n const node = this.startNode();\n const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));\n if (asserts && this.match(78)) {\n let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();\n if (thisTypePredicate.type === \"TSThisType\") {\n node.parameterName = thisTypePredicate;\n node.asserts = true;\n node.typeAnnotation = null;\n thisTypePredicate = this.finishNode(node, \"TSTypePredicate\");\n } else {\n this.resetStartLocationFromNode(thisTypePredicate, node);\n thisTypePredicate.asserts = true;\n }\n t.typeAnnotation = thisTypePredicate;\n return this.finishNode(t, \"TSTypeAnnotation\");\n }\n const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));\n if (!typePredicateVariable) {\n if (!asserts) {\n return this.tsParseTypeAnnotation(false, t);\n }\n node.parameterName = this.parseIdentifier();\n node.asserts = asserts;\n node.typeAnnotation = null;\n t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n return this.finishNode(t, \"TSTypeAnnotation\");\n }\n const type = this.tsParseTypeAnnotation(false);\n node.parameterName = typePredicateVariable;\n node.typeAnnotation = type;\n node.asserts = asserts;\n t.typeAnnotation = this.finishNode(node, \"TSTypePredicate\");\n return this.finishNode(t, \"TSTypeAnnotation\");\n });\n }\n tsTryParseTypeOrTypePredicateAnnotation() {\n if (this.match(14)) {\n return this.tsParseTypeOrTypePredicateAnnotation(14);\n }\n }\n tsTryParseTypeAnnotation() {\n if (this.match(14)) {\n return this.tsParseTypeAnnotation();\n }\n }\n tsTryParseType() {\n return this.tsEatThenParseType(14);\n }\n tsParseTypePredicatePrefix() {\n const id = this.parseIdentifier();\n if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {\n this.next();\n return id;\n }\n }\n tsParseTypePredicateAsserts() {\n if (this.state.type !== 109) {\n return false;\n }\n const containsEsc = this.state.containsEsc;\n this.next();\n if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {\n return false;\n }\n if (containsEsc) {\n this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {\n reservedWord: \"asserts\"\n });\n }\n return true;\n }\n tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {\n this.tsInType(() => {\n if (eatColon) this.expect(14);\n t.typeAnnotation = this.tsParseType();\n });\n return this.finishNode(t, \"TSTypeAnnotation\");\n }\n tsParseType() {\n assert(this.state.inType);\n const type = this.tsParseNonConditionalType();\n if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {\n return type;\n }\n const node = this.startNodeAtNode(type);\n node.checkType = type;\n node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());\n this.expect(17);\n node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());\n this.expect(14);\n node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());\n return this.finishNode(node, \"TSConditionalType\");\n }\n isAbstractConstructorSignature() {\n return this.isContextual(124) && this.isLookaheadContextual(\"new\");\n }\n tsParseNonConditionalType() {\n if (this.tsIsStartOfFunctionType()) {\n return this.tsParseFunctionOrConstructorType(\"TSFunctionType\");\n }\n if (this.match(77)) {\n return this.tsParseFunctionOrConstructorType(\"TSConstructorType\");\n } else if (this.isAbstractConstructorSignature()) {\n return this.tsParseFunctionOrConstructorType(\"TSConstructorType\", true);\n }\n return this.tsParseUnionTypeOrHigher();\n }\n tsParseTypeAssertion() {\n if (this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);\n }\n const node = this.startNode();\n node.typeAnnotation = this.tsInType(() => {\n this.next();\n return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();\n });\n this.expect(48);\n node.expression = this.parseMaybeUnary();\n return this.finishNode(node, \"TSTypeAssertion\");\n }\n tsParseHeritageClause(token) {\n const originalStartLoc = this.state.startLoc;\n const delimitedList = this.tsParseDelimitedList(\"HeritageClauseElement\", () => {\n const node = this.startNode();\n node.expression = this.tsParseEntityName(1 | 2);\n if (this.match(47)) {\n node.typeParameters = this.tsParseTypeArguments();\n }\n return this.finishNode(node, \"TSExpressionWithTypeArguments\");\n });\n if (!delimitedList.length) {\n this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {\n token\n });\n }\n return delimitedList;\n }\n tsParseInterfaceDeclaration(node, properties = {}) {\n if (this.hasFollowingLineBreak()) return null;\n this.expectContextual(129);\n if (properties.declare) node.declare = true;\n if (tokenIsIdentifier(this.state.type)) {\n node.id = this.parseIdentifier();\n this.checkIdentifier(node.id, 130);\n } else {\n node.id = null;\n this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);\n }\n node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);\n if (this.eat(81)) {\n node.extends = this.tsParseHeritageClause(\"extends\");\n }\n const body = this.startNode();\n body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));\n node.body = this.finishNode(body, \"TSInterfaceBody\");\n return this.finishNode(node, \"TSInterfaceDeclaration\");\n }\n tsParseTypeAliasDeclaration(node) {\n node.id = this.parseIdentifier();\n this.checkIdentifier(node.id, 2);\n node.typeAnnotation = this.tsInType(() => {\n node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);\n this.expect(29);\n if (this.isContextual(114) && this.lookaheadCharCode() !== 46) {\n const node = this.startNode();\n this.next();\n return this.finishNode(node, \"TSIntrinsicKeyword\");\n }\n return this.tsParseType();\n });\n this.semicolon();\n return this.finishNode(node, \"TSTypeAliasDeclaration\");\n }\n tsInTopLevelContext(cb) {\n if (this.curContext() !== types.brace) {\n const oldContext = this.state.context;\n this.state.context = [oldContext[0]];\n try {\n return cb();\n } finally {\n this.state.context = oldContext;\n }\n } else {\n return cb();\n }\n }\n tsInType(cb) {\n const oldInType = this.state.inType;\n this.state.inType = true;\n try {\n return cb();\n } finally {\n this.state.inType = oldInType;\n }\n }\n tsInDisallowConditionalTypesContext(cb) {\n const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;\n this.state.inDisallowConditionalTypesContext = true;\n try {\n return cb();\n } finally {\n this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;\n }\n }\n tsInAllowConditionalTypesContext(cb) {\n const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;\n this.state.inDisallowConditionalTypesContext = false;\n try {\n return cb();\n } finally {\n this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;\n }\n }\n tsEatThenParseType(token) {\n if (this.match(token)) {\n return this.tsNextThenParseType();\n }\n }\n tsExpectThenParseType(token) {\n return this.tsInType(() => {\n this.expect(token);\n return this.tsParseType();\n });\n }\n tsNextThenParseType() {\n return this.tsInType(() => {\n this.next();\n return this.tsParseType();\n });\n }\n tsParseEnumMember() {\n const node = this.startNode();\n node.id = this.match(134) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);\n if (this.eat(29)) {\n node.initializer = super.parseMaybeAssignAllowIn();\n }\n return this.finishNode(node, \"TSEnumMember\");\n }\n tsParseEnumDeclaration(node, properties = {}) {\n if (properties.const) node.const = true;\n if (properties.declare) node.declare = true;\n this.expectContextual(126);\n node.id = this.parseIdentifier();\n this.checkIdentifier(node.id, node.const ? 8971 : 8459);\n this.expect(5);\n node.members = this.tsParseDelimitedList(\"EnumMembers\", this.tsParseEnumMember.bind(this));\n this.expect(8);\n return this.finishNode(node, \"TSEnumDeclaration\");\n }\n tsParseEnumBody() {\n const node = this.startNode();\n this.expect(5);\n node.members = this.tsParseDelimitedList(\"EnumMembers\", this.tsParseEnumMember.bind(this));\n this.expect(8);\n return this.finishNode(node, \"TSEnumBody\");\n }\n tsParseModuleBlock() {\n const node = this.startNode();\n this.scope.enter(0);\n this.expect(5);\n super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);\n this.scope.exit();\n return this.finishNode(node, \"TSModuleBlock\");\n }\n tsParseModuleOrNamespaceDeclaration(node, nested = false) {\n node.id = this.parseIdentifier();\n if (!nested) {\n this.checkIdentifier(node.id, 1024);\n }\n if (this.eat(16)) {\n const inner = this.startNode();\n this.tsParseModuleOrNamespaceDeclaration(inner, true);\n node.body = inner;\n } else {\n this.scope.enter(1024);\n this.prodParam.enter(0);\n node.body = this.tsParseModuleBlock();\n this.prodParam.exit();\n this.scope.exit();\n }\n return this.finishNode(node, \"TSModuleDeclaration\");\n }\n tsParseAmbientExternalModuleDeclaration(node) {\n if (this.isContextual(112)) {\n node.kind = \"global\";\n node.global = true;\n node.id = this.parseIdentifier();\n } else if (this.match(134)) {\n node.kind = \"module\";\n node.id = super.parseStringLiteral(this.state.value);\n } else {\n this.unexpected();\n }\n if (this.match(5)) {\n this.scope.enter(1024);\n this.prodParam.enter(0);\n node.body = this.tsParseModuleBlock();\n this.prodParam.exit();\n this.scope.exit();\n } else {\n this.semicolon();\n }\n return this.finishNode(node, \"TSModuleDeclaration\");\n }\n tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {\n node.isExport = isExport || false;\n node.id = maybeDefaultIdentifier || this.parseIdentifier();\n this.checkIdentifier(node.id, 4096);\n this.expect(29);\n const moduleReference = this.tsParseModuleReference();\n if (node.importKind === \"type\" && moduleReference.type !== \"TSExternalModuleReference\") {\n this.raise(TSErrors.ImportAliasHasImportType, moduleReference);\n }\n node.moduleReference = moduleReference;\n this.semicolon();\n return this.finishNode(node, \"TSImportEqualsDeclaration\");\n }\n tsIsExternalModuleReference() {\n return this.isContextual(119) && this.lookaheadCharCode() === 40;\n }\n tsParseModuleReference() {\n return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);\n }\n tsParseExternalModuleReference() {\n const node = this.startNode();\n this.expectContextual(119);\n this.expect(10);\n if (!this.match(134)) {\n this.unexpected();\n }\n node.expression = super.parseExprAtom();\n this.expect(11);\n this.sawUnambiguousESM = true;\n return this.finishNode(node, \"TSExternalModuleReference\");\n }\n tsLookAhead(f) {\n const state = this.state.clone();\n const res = f();\n this.state = state;\n return res;\n }\n tsTryParseAndCatch(f) {\n const result = this.tryParse(abort => f() || abort());\n if (result.aborted || !result.node) return;\n if (result.error) this.state = result.failState;\n return result.node;\n }\n tsTryParse(f) {\n const state = this.state.clone();\n const result = f();\n if (result !== undefined && result !== false) {\n return result;\n }\n this.state = state;\n }\n tsTryParseDeclare(node) {\n if (this.isLineTerminator()) {\n return;\n }\n const startType = this.state.type;\n return this.tsInAmbientContext(() => {\n switch (startType) {\n case 68:\n node.declare = true;\n return super.parseFunctionStatement(node, false, false);\n case 80:\n node.declare = true;\n return this.parseClass(node, true, false);\n case 126:\n return this.tsParseEnumDeclaration(node, {\n declare: true\n });\n case 112:\n return this.tsParseAmbientExternalModuleDeclaration(node);\n case 100:\n if (this.state.containsEsc) {\n return;\n }\n case 75:\n case 74:\n if (!this.match(75) || !this.isLookaheadContextual(\"enum\")) {\n node.declare = true;\n return this.parseVarStatement(node, this.state.value, true);\n }\n this.expect(75);\n return this.tsParseEnumDeclaration(node, {\n const: true,\n declare: true\n });\n case 107:\n if (this.isUsing()) {\n this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, \"declare\");\n node.declare = true;\n return this.parseVarStatement(node, \"using\", true);\n }\n break;\n case 96:\n if (this.isAwaitUsing()) {\n this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, \"declare\");\n node.declare = true;\n this.next();\n return this.parseVarStatement(node, \"await using\", true);\n }\n break;\n case 129:\n {\n const result = this.tsParseInterfaceDeclaration(node, {\n declare: true\n });\n if (result) return result;\n }\n default:\n if (tokenIsIdentifier(startType)) {\n return this.tsParseDeclaration(node, this.state.type, true, null);\n }\n }\n });\n }\n tsTryParseExportDeclaration() {\n return this.tsParseDeclaration(this.startNode(), this.state.type, true, null);\n }\n tsParseDeclaration(node, type, next, decorators) {\n switch (type) {\n case 124:\n if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {\n return this.tsParseAbstractDeclaration(node, decorators);\n }\n break;\n case 127:\n if (this.tsCheckLineTerminator(next)) {\n if (this.match(134)) {\n return this.tsParseAmbientExternalModuleDeclaration(node);\n } else if (tokenIsIdentifier(this.state.type)) {\n node.kind = \"module\";\n return this.tsParseModuleOrNamespaceDeclaration(node);\n }\n }\n break;\n case 128:\n if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {\n node.kind = \"namespace\";\n return this.tsParseModuleOrNamespaceDeclaration(node);\n }\n break;\n case 130:\n if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {\n return this.tsParseTypeAliasDeclaration(node);\n }\n break;\n }\n }\n tsCheckLineTerminator(next) {\n if (next) {\n if (this.hasFollowingLineBreak()) return false;\n this.next();\n return true;\n }\n return !this.isLineTerminator();\n }\n tsTryParseGenericAsyncArrowFunction(startLoc) {\n if (!this.match(47)) return;\n const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n this.state.maybeInArrowParameters = true;\n const res = this.tsTryParseAndCatch(() => {\n const node = this.startNodeAt(startLoc);\n node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n super.parseFunctionParams(node);\n node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();\n this.expect(19);\n return node;\n });\n this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n if (!res) return;\n return super.parseArrowExpression(res, null, true);\n }\n tsParseTypeArgumentsInExpression() {\n if (this.reScan_lt() !== 47) return;\n return this.tsParseTypeArguments();\n }\n tsParseTypeArguments() {\n const node = this.startNode();\n node.params = this.tsInType(() => this.tsInTopLevelContext(() => {\n this.expect(47);\n return this.tsParseDelimitedList(\"TypeParametersOrArguments\", this.tsParseType.bind(this));\n }));\n if (node.params.length === 0) {\n this.raise(TSErrors.EmptyTypeArguments, node);\n } else if (!this.state.inType && this.curContext() === types.brace) {\n this.reScan_lt_gt();\n }\n this.expect(48);\n return this.finishNode(node, \"TSTypeParameterInstantiation\");\n }\n tsIsDeclarationStart() {\n return tokenIsTSDeclarationStart(this.state.type);\n }\n isExportDefaultSpecifier() {\n if (this.tsIsDeclarationStart()) return false;\n return super.isExportDefaultSpecifier();\n }\n parseBindingElement(flags, decorators) {\n const startLoc = decorators.length ? decorators[0].loc.start : this.state.startLoc;\n const modified = {};\n this.tsParseModifiers({\n allowedModifiers: [\"public\", \"private\", \"protected\", \"override\", \"readonly\"]\n }, modified);\n const accessibility = modified.accessibility;\n const override = modified.override;\n const readonly = modified.readonly;\n if (!(flags & 4) && (accessibility || readonly || override)) {\n this.raise(TSErrors.UnexpectedParameterModifier, startLoc);\n }\n const left = this.parseMaybeDefault();\n if (flags & 2) {\n this.parseFunctionParamType(left);\n }\n const elt = this.parseMaybeDefault(left.loc.start, left);\n if (accessibility || readonly || override) {\n const pp = this.startNodeAt(startLoc);\n if (decorators.length) {\n pp.decorators = decorators;\n }\n if (accessibility) pp.accessibility = accessibility;\n if (readonly) pp.readonly = readonly;\n if (override) pp.override = override;\n if (elt.type !== \"Identifier\" && elt.type !== \"AssignmentPattern\") {\n this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);\n }\n pp.parameter = elt;\n return this.finishNode(pp, \"TSParameterProperty\");\n }\n if (decorators.length) {\n left.decorators = decorators;\n }\n return elt;\n }\n isSimpleParameter(node) {\n return node.type === \"TSParameterProperty\" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);\n }\n tsDisallowOptionalPattern(node) {\n for (const param of node.params) {\n if (param.type !== \"Identifier\" && param.optional && !this.state.isAmbientContext) {\n this.raise(TSErrors.PatternIsOptional, param);\n }\n }\n }\n setArrowFunctionParameters(node, params, trailingCommaLoc) {\n super.setArrowFunctionParameters(node, params, trailingCommaLoc);\n this.tsDisallowOptionalPattern(node);\n }\n parseFunctionBodyAndFinish(node, type, isMethod = false) {\n if (this.match(14)) {\n node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);\n }\n const bodilessType = type === \"FunctionDeclaration\" ? \"TSDeclareFunction\" : type === \"ClassMethod\" || type === \"ClassPrivateMethod\" ? \"TSDeclareMethod\" : undefined;\n if (bodilessType && !this.match(5) && this.isLineTerminator()) {\n return this.finishNode(node, bodilessType);\n }\n if (bodilessType === \"TSDeclareFunction\" && this.state.isAmbientContext) {\n this.raise(TSErrors.DeclareFunctionHasImplementation, node);\n if (node.declare) {\n return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);\n }\n }\n this.tsDisallowOptionalPattern(node);\n return super.parseFunctionBodyAndFinish(node, type, isMethod);\n }\n registerFunctionStatementId(node) {\n if (!node.body && node.id) {\n this.checkIdentifier(node.id, 1024);\n } else {\n super.registerFunctionStatementId(node);\n }\n }\n tsCheckForInvalidTypeCasts(items) {\n items.forEach(node => {\n if ((node == null ? void 0 : node.type) === \"TSTypeCastExpression\") {\n this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);\n }\n });\n }\n toReferencedList(exprList, isInParens) {\n this.tsCheckForInvalidTypeCasts(exprList);\n return exprList;\n }\n parseArrayLike(close, isTuple, refExpressionErrors) {\n const node = super.parseArrayLike(close, isTuple, refExpressionErrors);\n if (node.type === \"ArrayExpression\") {\n this.tsCheckForInvalidTypeCasts(node.elements);\n }\n return node;\n }\n parseSubscript(base, startLoc, noCalls, state) {\n if (!this.hasPrecedingLineBreak() && this.match(35)) {\n this.state.canStartJSXElement = false;\n this.next();\n const nonNullExpression = this.startNodeAt(startLoc);\n nonNullExpression.expression = base;\n return this.finishNode(nonNullExpression, \"TSNonNullExpression\");\n }\n let isOptionalCall = false;\n if (this.match(18) && this.lookaheadCharCode() === 60) {\n if (noCalls) {\n state.stop = true;\n return base;\n }\n state.optionalChainMember = isOptionalCall = true;\n this.next();\n }\n if (this.match(47) || this.match(51)) {\n let missingParenErrorLoc;\n const result = this.tsTryParseAndCatch(() => {\n if (!noCalls && this.atPossibleAsyncArrow(base)) {\n const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);\n if (asyncArrowFn) {\n state.stop = true;\n return asyncArrowFn;\n }\n }\n const typeArguments = this.tsParseTypeArgumentsInExpression();\n if (!typeArguments) return;\n if (isOptionalCall && !this.match(10)) {\n missingParenErrorLoc = this.state.curPosition();\n return;\n }\n if (tokenIsTemplate(this.state.type)) {\n const result = super.parseTaggedTemplateExpression(base, startLoc, state);\n result.typeParameters = typeArguments;\n return result;\n }\n if (!noCalls && this.eat(10)) {\n const node = this.startNodeAt(startLoc);\n node.callee = base;\n node.arguments = this.parseCallExpressionArguments();\n this.tsCheckForInvalidTypeCasts(node.arguments);\n node.typeParameters = typeArguments;\n if (state.optionalChainMember) {\n node.optional = isOptionalCall;\n }\n return this.finishCallExpression(node, state.optionalChainMember);\n }\n const tokenType = this.state.type;\n if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenType !== 93 && tokenType !== 120 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {\n return;\n }\n const node = this.startNodeAt(startLoc);\n node.expression = base;\n node.typeParameters = typeArguments;\n return this.finishNode(node, \"TSInstantiationExpression\");\n });\n if (missingParenErrorLoc) {\n this.unexpected(missingParenErrorLoc, 10);\n }\n if (result) {\n if (result.type === \"TSInstantiationExpression\") {\n if (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40) {\n this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);\n }\n if (!this.match(16) && !this.match(18)) {\n result.expression = super.stopParseSubscript(base, state);\n }\n }\n return result;\n }\n }\n return super.parseSubscript(base, startLoc, noCalls, state);\n }\n parseNewCallee(node) {\n var _callee$extra;\n super.parseNewCallee(node);\n const {\n callee\n } = node;\n if (callee.type === \"TSInstantiationExpression\" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {\n node.typeParameters = callee.typeParameters;\n node.callee = callee.expression;\n }\n }\n parseExprOp(left, leftStartLoc, minPrec) {\n let isSatisfies;\n if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {\n const node = this.startNodeAt(leftStartLoc);\n node.expression = left;\n node.typeAnnotation = this.tsInType(() => {\n this.next();\n if (this.match(75)) {\n if (isSatisfies) {\n this.raise(Errors.UnexpectedKeyword, this.state.startLoc, {\n keyword: \"const\"\n });\n }\n return this.tsParseTypeReference();\n }\n return this.tsParseType();\n });\n this.finishNode(node, isSatisfies ? \"TSSatisfiesExpression\" : \"TSAsExpression\");\n this.reScan_lt_gt();\n return this.parseExprOp(node, leftStartLoc, minPrec);\n }\n return super.parseExprOp(left, leftStartLoc, minPrec);\n }\n checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n if (!this.state.isAmbientContext) {\n super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n }\n }\n checkImportReflection(node) {\n super.checkImportReflection(node);\n if (node.module && node.importKind !== \"value\") {\n this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);\n }\n }\n checkDuplicateExports() {}\n isPotentialImportPhase(isExport) {\n if (super.isPotentialImportPhase(isExport)) return true;\n if (this.isContextual(130)) {\n const ch = this.lookaheadCharCode();\n return isExport ? ch === 123 || ch === 42 : ch !== 61;\n }\n return !isExport && this.isContextual(87);\n }\n applyImportPhase(node, isExport, phase, loc) {\n super.applyImportPhase(node, isExport, phase, loc);\n if (isExport) {\n node.exportKind = phase === \"type\" ? \"type\" : \"value\";\n } else {\n node.importKind = phase === \"type\" || phase === \"typeof\" ? phase : \"value\";\n }\n }\n parseImport(node) {\n if (this.match(134)) {\n node.importKind = \"value\";\n return super.parseImport(node);\n }\n let importNode;\n if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {\n node.importKind = \"value\";\n return this.tsParseImportEqualsDeclaration(node);\n } else if (this.isContextual(130)) {\n const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);\n if (this.lookaheadCharCode() === 61) {\n return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);\n } else {\n importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);\n }\n } else {\n importNode = super.parseImport(node);\n }\n if (importNode.importKind === \"type\" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === \"ImportDefaultSpecifier\") {\n this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);\n }\n return importNode;\n }\n parseExport(node, decorators) {\n if (this.match(83)) {\n const nodeImportEquals = node;\n this.next();\n let maybeDefaultIdentifier = null;\n if (this.isContextual(130) && this.isPotentialImportPhase(false)) {\n maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);\n } else {\n nodeImportEquals.importKind = \"value\";\n }\n const declaration = this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);\n return declaration;\n } else if (this.eat(29)) {\n const assign = node;\n assign.expression = super.parseExpression();\n this.semicolon();\n this.sawUnambiguousESM = true;\n return this.finishNode(assign, \"TSExportAssignment\");\n } else if (this.eatContextual(93)) {\n const decl = node;\n this.expectContextual(128);\n decl.id = this.parseIdentifier();\n this.semicolon();\n return this.finishNode(decl, \"TSNamespaceExportDeclaration\");\n } else {\n return super.parseExport(node, decorators);\n }\n }\n isAbstractClass() {\n return this.isContextual(124) && this.isLookaheadContextual(\"class\");\n }\n parseExportDefaultExpression() {\n if (this.isAbstractClass()) {\n const cls = this.startNode();\n this.next();\n cls.abstract = true;\n return this.parseClass(cls, true, true);\n }\n if (this.match(129)) {\n const result = this.tsParseInterfaceDeclaration(this.startNode());\n if (result) return result;\n }\n return super.parseExportDefaultExpression();\n }\n parseVarStatement(node, kind, allowMissingInitializer = false) {\n const {\n isAmbientContext\n } = this.state;\n const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);\n if (!isAmbientContext) return declaration;\n if (!node.declare && (kind === \"using\" || kind === \"await using\")) {\n this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind);\n return declaration;\n }\n for (const {\n id,\n init\n } of declaration.declarations) {\n if (!init) continue;\n if (kind === \"var\" || kind === \"let\" || !!id.typeAnnotation) {\n this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);\n } else if (!isValidAmbientConstInitializer(init, this.hasPlugin(\"estree\"))) {\n this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);\n }\n }\n return declaration;\n }\n parseStatementContent(flags, decorators) {\n if (!this.state.containsEsc) {\n switch (this.state.type) {\n case 75:\n {\n if (this.isLookaheadContextual(\"enum\")) {\n const node = this.startNode();\n this.expect(75);\n return this.tsParseEnumDeclaration(node, {\n const: true\n });\n }\n break;\n }\n case 124:\n case 125:\n {\n if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) {\n const token = this.state.type;\n const node = this.startNode();\n this.next();\n const declaration = token === 125 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);\n if (declaration) {\n if (token === 125) {\n declaration.declare = true;\n }\n return declaration;\n } else {\n node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 125 ? \"declare\" : \"abstract\");\n this.semicolon(false);\n return this.finishNode(node, \"ExpressionStatement\");\n }\n }\n break;\n }\n case 126:\n return this.tsParseEnumDeclaration(this.startNode());\n case 112:\n {\n const nextCh = this.lookaheadCharCode();\n if (nextCh === 123) {\n const node = this.startNode();\n return this.tsParseAmbientExternalModuleDeclaration(node);\n }\n break;\n }\n case 129:\n {\n const result = this.tsParseInterfaceDeclaration(this.startNode());\n if (result) return result;\n break;\n }\n case 127:\n {\n if (this.nextTokenIsIdentifierOrStringLiteralOnSameLine()) {\n const node = this.startNode();\n this.next();\n return this.tsParseDeclaration(node, 127, false, decorators);\n }\n break;\n }\n case 128:\n {\n if (this.nextTokenIsIdentifierOnSameLine()) {\n const node = this.startNode();\n this.next();\n return this.tsParseDeclaration(node, 128, false, decorators);\n }\n break;\n }\n case 130:\n {\n if (this.nextTokenIsIdentifierOnSameLine()) {\n const node = this.startNode();\n this.next();\n return this.tsParseTypeAliasDeclaration(node);\n }\n break;\n }\n }\n }\n return super.parseStatementContent(flags, decorators);\n }\n parseAccessModifier() {\n return this.tsParseModifier([\"public\", \"protected\", \"private\"]);\n }\n tsHasSomeModifiers(member, modifiers) {\n return modifiers.some(modifier => {\n if (tsIsAccessModifier(modifier)) {\n return member.accessibility === modifier;\n }\n return !!member[modifier];\n });\n }\n tsIsStartOfStaticBlocks() {\n return this.isContextual(106) && this.lookaheadCharCode() === 123;\n }\n parseClassMember(classBody, member, state) {\n const modifiers = [\"declare\", \"private\", \"public\", \"protected\", \"override\", \"abstract\", \"readonly\", \"static\"];\n this.tsParseModifiers({\n allowedModifiers: modifiers,\n disallowedModifiers: [\"in\", \"out\"],\n stopOnStartOfClassStaticBlock: true,\n errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions\n }, member);\n const callParseClassMemberWithIsStatic = () => {\n if (this.tsIsStartOfStaticBlocks()) {\n this.next();\n this.next();\n if (this.tsHasSomeModifiers(member, modifiers)) {\n this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());\n }\n super.parseClassStaticBlock(classBody, member);\n } else {\n this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);\n }\n };\n if (member.declare) {\n this.tsInAmbientContext(callParseClassMemberWithIsStatic);\n } else {\n callParseClassMemberWithIsStatic();\n }\n }\n parseClassMemberWithIsStatic(classBody, member, state, isStatic) {\n const idx = this.tsTryParseIndexSignature(member);\n if (idx) {\n classBody.body.push(idx);\n if (member.abstract) {\n this.raise(TSErrors.IndexSignatureHasAbstract, member);\n }\n if (member.accessibility) {\n this.raise(TSErrors.IndexSignatureHasAccessibility, member, {\n modifier: member.accessibility\n });\n }\n if (member.declare) {\n this.raise(TSErrors.IndexSignatureHasDeclare, member);\n }\n if (member.override) {\n this.raise(TSErrors.IndexSignatureHasOverride, member);\n }\n return;\n }\n if (!this.state.inAbstractClass && member.abstract) {\n this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);\n }\n if (member.override) {\n if (!state.hadSuperClass) {\n this.raise(TSErrors.OverrideNotInSubClass, member);\n }\n }\n super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n }\n parsePostMemberNameModifiers(methodOrProp) {\n const optional = this.eat(17);\n if (optional) methodOrProp.optional = true;\n if (methodOrProp.readonly && this.match(10)) {\n this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);\n }\n if (methodOrProp.declare && this.match(10)) {\n this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);\n }\n }\n shouldParseExportDeclaration() {\n if (this.tsIsDeclarationStart()) return true;\n return super.shouldParseExportDeclaration();\n }\n parseConditional(expr, startLoc, refExpressionErrors) {\n if (!this.match(17)) return expr;\n if (this.state.maybeInArrowParameters) {\n const nextCh = this.lookaheadCharCode();\n if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {\n this.setOptionalParametersError(refExpressionErrors);\n return expr;\n }\n }\n return super.parseConditional(expr, startLoc, refExpressionErrors);\n }\n parseParenItem(node, startLoc) {\n const newNode = super.parseParenItem(node, startLoc);\n if (this.eat(17)) {\n newNode.optional = true;\n this.resetEndLocation(node);\n }\n if (this.match(14)) {\n const typeCastNode = this.startNodeAt(startLoc);\n typeCastNode.expression = node;\n typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();\n return this.finishNode(typeCastNode, \"TSTypeCastExpression\");\n }\n return node;\n }\n parseExportDeclaration(node) {\n if (!this.state.isAmbientContext && this.isContextual(125)) {\n return this.tsInAmbientContext(() => this.parseExportDeclaration(node));\n }\n const startLoc = this.state.startLoc;\n const isDeclare = this.eatContextual(125);\n if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {\n throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);\n }\n const isIdentifier = tokenIsIdentifier(this.state.type);\n const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);\n if (!declaration) return null;\n if (declaration.type === \"TSInterfaceDeclaration\" || declaration.type === \"TSTypeAliasDeclaration\" || isDeclare) {\n node.exportKind = \"type\";\n }\n if (isDeclare && declaration.type !== \"TSImportEqualsDeclaration\") {\n this.resetStartLocation(declaration, startLoc);\n declaration.declare = true;\n }\n return declaration;\n }\n parseClassId(node, isStatement, optionalId, bindingType) {\n if ((!isStatement || optionalId) && this.isContextual(113)) {\n return;\n }\n super.parseClassId(node, isStatement, optionalId, node.declare ? 1024 : 8331);\n const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);\n if (typeParameters) node.typeParameters = typeParameters;\n }\n parseClassPropertyAnnotation(node) {\n if (!node.optional) {\n if (this.eat(35)) {\n node.definite = true;\n } else if (this.eat(17)) {\n node.optional = true;\n }\n }\n const type = this.tsTryParseTypeAnnotation();\n if (type) node.typeAnnotation = type;\n }\n parseClassProperty(node) {\n this.parseClassPropertyAnnotation(node);\n if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {\n this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);\n }\n if (node.abstract && this.match(29)) {\n const {\n key\n } = node;\n this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, {\n propertyName: key.type === \"Identifier\" && !node.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]`\n });\n }\n return super.parseClassProperty(node);\n }\n parseClassPrivateProperty(node) {\n if (node.abstract) {\n this.raise(TSErrors.PrivateElementHasAbstract, node);\n }\n if (node.accessibility) {\n this.raise(TSErrors.PrivateElementHasAccessibility, node, {\n modifier: node.accessibility\n });\n }\n this.parseClassPropertyAnnotation(node);\n return super.parseClassPrivateProperty(node);\n }\n parseClassAccessorProperty(node) {\n this.parseClassPropertyAnnotation(node);\n if (node.optional) {\n this.raise(TSErrors.AccessorCannotBeOptional, node);\n }\n return super.parseClassAccessorProperty(node);\n }\n pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n if (typeParameters && isConstructor) {\n this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);\n }\n const {\n declare = false,\n kind\n } = method;\n if (declare && (kind === \"get\" || kind === \"set\")) {\n this.raise(TSErrors.DeclareAccessor, method, {\n kind\n });\n }\n if (typeParameters) method.typeParameters = typeParameters;\n super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);\n }\n pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n if (typeParameters) method.typeParameters = typeParameters;\n super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);\n }\n declareClassPrivateMethodInScope(node, kind) {\n if (node.type === \"TSDeclareMethod\") return;\n if (node.type === \"MethodDefinition\" && node.value.body == null) {\n return;\n }\n super.declareClassPrivateMethodInScope(node, kind);\n }\n parseClassSuper(node) {\n super.parseClassSuper(node);\n if (node.superClass) {\n if (node.superClass.type === \"TSInstantiationExpression\") {\n const tsInstantiationExpression = node.superClass;\n const superClass = tsInstantiationExpression.expression;\n this.takeSurroundingComments(superClass, superClass.start, superClass.end);\n const superTypeArguments = tsInstantiationExpression.typeParameters;\n this.takeSurroundingComments(superTypeArguments, superTypeArguments.start, superTypeArguments.end);\n node.superClass = superClass;\n node.superTypeParameters = superTypeArguments;\n } else if (this.match(47) || this.match(51)) {\n node.superTypeParameters = this.tsParseTypeArgumentsInExpression();\n }\n }\n if (this.eatContextual(113)) {\n node.implements = this.tsParseHeritageClause(\"implements\");\n }\n }\n parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n if (typeParameters) prop.typeParameters = typeParameters;\n return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);\n }\n parseFunctionParams(node, isConstructor) {\n const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);\n if (typeParameters) node.typeParameters = typeParameters;\n super.parseFunctionParams(node, isConstructor);\n }\n parseVarId(decl, kind) {\n super.parseVarId(decl, kind);\n if (decl.id.type === \"Identifier\" && !this.hasPrecedingLineBreak() && this.eat(35)) {\n decl.definite = true;\n }\n const type = this.tsTryParseTypeAnnotation();\n if (type) {\n decl.id.typeAnnotation = type;\n this.resetEndLocation(decl.id);\n }\n }\n parseAsyncArrowFromCallExpression(node, call) {\n if (this.match(14)) {\n node.returnType = this.tsParseTypeAnnotation();\n }\n return super.parseAsyncArrowFromCallExpression(node, call);\n }\n parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;\n let state;\n let jsx;\n let typeCast;\n if (this.hasPlugin(\"jsx\") && (this.match(143) || this.match(47))) {\n state = this.state.clone();\n jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n if (!jsx.error) return jsx.node;\n const {\n context\n } = this.state;\n const currentContext = context[context.length - 1];\n if (currentContext === types.j_oTag || currentContext === types.j_expr) {\n context.pop();\n }\n }\n if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {\n return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n }\n if (!state || state === this.state) state = this.state.clone();\n let typeParameters;\n const arrow = this.tryParse(abort => {\n var _expr$extra, _typeParameters;\n typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);\n const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);\n if (expr.type !== \"ArrowFunctionExpression\" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {\n abort();\n }\n if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {\n this.resetStartLocationFromNode(expr, typeParameters);\n }\n expr.typeParameters = typeParameters;\n return expr;\n }, state);\n if (!arrow.error && !arrow.aborted) {\n if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n return arrow.node;\n }\n if (!jsx) {\n assert(!this.hasPlugin(\"jsx\"));\n typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);\n if (!typeCast.error) return typeCast.node;\n }\n if ((_jsx2 = jsx) != null && _jsx2.node) {\n this.state = jsx.failState;\n return jsx.node;\n }\n if (arrow.node) {\n this.state = arrow.failState;\n if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);\n return arrow.node;\n }\n if ((_typeCast = typeCast) != null && _typeCast.node) {\n this.state = typeCast.failState;\n return typeCast.node;\n }\n throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);\n }\n reportReservedArrowTypeParam(node) {\n var _node$extra2;\n if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra2 = node.extra) != null && _node$extra2.trailingComma) && this.getPluginOption(\"typescript\", \"disallowAmbiguousJSXLike\")) {\n this.raise(TSErrors.ReservedArrowTypeParam, node);\n }\n }\n parseMaybeUnary(refExpressionErrors, sawUnary) {\n if (!this.hasPlugin(\"jsx\") && this.match(47)) {\n return this.tsParseTypeAssertion();\n }\n return super.parseMaybeUnary(refExpressionErrors, sawUnary);\n }\n parseArrow(node) {\n if (this.match(14)) {\n const result = this.tryParse(abort => {\n const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);\n if (this.canInsertSemicolon() || !this.match(19)) abort();\n return returnType;\n });\n if (result.aborted) return;\n if (!result.thrown) {\n if (result.error) this.state = result.failState;\n node.returnType = result.node;\n }\n }\n return super.parseArrow(node);\n }\n parseFunctionParamType(param) {\n if (this.eat(17)) {\n param.optional = true;\n }\n const type = this.tsTryParseTypeAnnotation();\n if (type) param.typeAnnotation = type;\n this.resetEndLocation(param);\n return param;\n }\n isAssignable(node, isBinding) {\n switch (node.type) {\n case \"TSTypeCastExpression\":\n return this.isAssignable(node.expression, isBinding);\n case \"TSParameterProperty\":\n return true;\n default:\n return super.isAssignable(node, isBinding);\n }\n }\n toAssignable(node, isLHS = false) {\n switch (node.type) {\n case \"ParenthesizedExpression\":\n this.toAssignableParenthesizedExpression(node, isLHS);\n break;\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSNonNullExpression\":\n case \"TSTypeAssertion\":\n if (isLHS) {\n this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);\n } else {\n this.raise(TSErrors.UnexpectedTypeCastInParameter, node);\n }\n this.toAssignable(node.expression, isLHS);\n break;\n case \"AssignmentExpression\":\n if (!isLHS && node.left.type === \"TSTypeCastExpression\") {\n node.left = this.typeCastToParameter(node.left);\n }\n default:\n super.toAssignable(node, isLHS);\n }\n }\n toAssignableParenthesizedExpression(node, isLHS) {\n switch (node.expression.type) {\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSNonNullExpression\":\n case \"TSTypeAssertion\":\n case \"ParenthesizedExpression\":\n this.toAssignable(node.expression, isLHS);\n break;\n default:\n super.toAssignable(node, isLHS);\n }\n }\n checkToRestConversion(node, allowPattern) {\n switch (node.type) {\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n this.checkToRestConversion(node.expression, false);\n break;\n default:\n super.checkToRestConversion(node, allowPattern);\n }\n }\n isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {\n switch (type) {\n case \"TSTypeCastExpression\":\n return true;\n case \"TSParameterProperty\":\n return \"parameter\";\n case \"TSNonNullExpression\":\n return \"expression\";\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n return (binding !== 64 || !isUnparenthesizedInAssign) && [\"expression\", true];\n default:\n return super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding);\n }\n }\n parseBindingAtom() {\n if (this.state.type === 78) {\n return this.parseIdentifier(true);\n }\n return super.parseBindingAtom();\n }\n parseMaybeDecoratorArguments(expr, startLoc) {\n if (this.match(47) || this.match(51)) {\n const typeArguments = this.tsParseTypeArgumentsInExpression();\n if (this.match(10)) {\n const call = super.parseMaybeDecoratorArguments(expr, startLoc);\n call.typeParameters = typeArguments;\n return call;\n }\n this.unexpected(null, 10);\n }\n return super.parseMaybeDecoratorArguments(expr, startLoc);\n }\n checkCommaAfterRest(close) {\n if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {\n this.next();\n return false;\n }\n return super.checkCommaAfterRest(close);\n }\n isClassMethod() {\n return this.match(47) || super.isClassMethod();\n }\n isClassProperty() {\n return this.match(35) || this.match(14) || super.isClassProperty();\n }\n parseMaybeDefault(startLoc, left) {\n const node = super.parseMaybeDefault(startLoc, left);\n if (node.type === \"AssignmentPattern\" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {\n this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);\n }\n return node;\n }\n getTokenFromCode(code) {\n if (this.state.inType) {\n if (code === 62) {\n this.finishOp(48, 1);\n return;\n }\n if (code === 60) {\n this.finishOp(47, 1);\n return;\n }\n }\n super.getTokenFromCode(code);\n }\n reScan_lt_gt() {\n const {\n type\n } = this.state;\n if (type === 47) {\n this.state.pos -= 1;\n this.readToken_lt();\n } else if (type === 48) {\n this.state.pos -= 1;\n this.readToken_gt();\n }\n }\n reScan_lt() {\n const {\n type\n } = this.state;\n if (type === 51) {\n this.state.pos -= 2;\n this.finishOp(47, 1);\n return 47;\n }\n return type;\n }\n toAssignableListItem(exprList, index, isLHS) {\n const node = exprList[index];\n if (node.type === \"TSTypeCastExpression\") {\n exprList[index] = this.typeCastToParameter(node);\n }\n super.toAssignableListItem(exprList, index, isLHS);\n }\n typeCastToParameter(node) {\n node.expression.typeAnnotation = node.typeAnnotation;\n this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);\n return node.expression;\n }\n shouldParseArrow(params) {\n if (this.match(14)) {\n return params.every(expr => this.isAssignable(expr, true));\n }\n return super.shouldParseArrow(params);\n }\n shouldParseAsyncArrow() {\n return this.match(14) || super.shouldParseAsyncArrow();\n }\n canHaveLeadingDecorator() {\n return super.canHaveLeadingDecorator() || this.isAbstractClass();\n }\n jsxParseOpeningElementAfterName(node) {\n if (this.match(47) || this.match(51)) {\n const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());\n if (typeArguments) {\n node.typeParameters = typeArguments;\n }\n }\n return super.jsxParseOpeningElementAfterName(node);\n }\n getGetterSetterExpectedParamCount(method) {\n const baseCount = super.getGetterSetterExpectedParamCount(method);\n const params = this.getObjectOrClassMethodParams(method);\n const firstParam = params[0];\n const hasContextParam = firstParam && this.isThisParam(firstParam);\n return hasContextParam ? baseCount + 1 : baseCount;\n }\n parseCatchClauseParam() {\n const param = super.parseCatchClauseParam();\n const type = this.tsTryParseTypeAnnotation();\n if (type) {\n param.typeAnnotation = type;\n this.resetEndLocation(param);\n }\n return param;\n }\n tsInAmbientContext(cb) {\n const {\n isAmbientContext: oldIsAmbientContext,\n strict: oldStrict\n } = this.state;\n this.state.isAmbientContext = true;\n this.state.strict = false;\n try {\n return cb();\n } finally {\n this.state.isAmbientContext = oldIsAmbientContext;\n this.state.strict = oldStrict;\n }\n }\n parseClass(node, isStatement, optionalId) {\n const oldInAbstractClass = this.state.inAbstractClass;\n this.state.inAbstractClass = !!node.abstract;\n try {\n return super.parseClass(node, isStatement, optionalId);\n } finally {\n this.state.inAbstractClass = oldInAbstractClass;\n }\n }\n tsParseAbstractDeclaration(node, decorators) {\n if (this.match(80)) {\n node.abstract = true;\n return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));\n } else if (this.isContextual(129)) {\n if (!this.hasFollowingLineBreak()) {\n node.abstract = true;\n this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);\n return this.tsParseInterfaceDeclaration(node);\n } else {\n return null;\n }\n }\n throw this.unexpected(null, 80);\n }\n parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {\n const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);\n if (method.abstract || method.type === \"TSAbstractMethodDefinition\") {\n const hasEstreePlugin = this.hasPlugin(\"estree\");\n const methodFn = hasEstreePlugin ? method.value : method;\n if (methodFn.body) {\n const {\n key\n } = method;\n this.raise(TSErrors.AbstractMethodHasImplementation, method, {\n methodName: key.type === \"Identifier\" && !method.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]`\n });\n }\n }\n return method;\n }\n tsParseTypeParameterName() {\n const typeName = this.parseIdentifier();\n return typeName.name;\n }\n shouldParseAsAmbientContext() {\n return !!this.getPluginOption(\"typescript\", \"dts\");\n }\n parse() {\n if (this.shouldParseAsAmbientContext()) {\n this.state.isAmbientContext = true;\n }\n return super.parse();\n }\n getExpression() {\n if (this.shouldParseAsAmbientContext()) {\n this.state.isAmbientContext = true;\n }\n return super.getExpression();\n }\n parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {\n if (!isString && isMaybeTypeOnly) {\n this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);\n return this.finishNode(node, \"ExportSpecifier\");\n }\n node.exportKind = \"value\";\n return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);\n }\n parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n if (!importedIsString && isMaybeTypeOnly) {\n this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);\n return this.finishNode(specifier, \"ImportSpecifier\");\n }\n specifier.importKind = \"value\";\n return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);\n }\n parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {\n const leftOfAsKey = isImport ? \"imported\" : \"local\";\n const rightOfAsKey = isImport ? \"local\" : \"exported\";\n let leftOfAs = node[leftOfAsKey];\n let rightOfAs;\n let hasTypeSpecifier = false;\n let canParseAsKeyword = true;\n const loc = leftOfAs.loc.start;\n if (this.isContextual(93)) {\n const firstAs = this.parseIdentifier();\n if (this.isContextual(93)) {\n const secondAs = this.parseIdentifier();\n if (tokenIsKeywordOrIdentifier(this.state.type)) {\n hasTypeSpecifier = true;\n leftOfAs = firstAs;\n rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n canParseAsKeyword = false;\n } else {\n rightOfAs = secondAs;\n canParseAsKeyword = false;\n }\n } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n canParseAsKeyword = false;\n rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n } else {\n hasTypeSpecifier = true;\n leftOfAs = firstAs;\n }\n } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n hasTypeSpecifier = true;\n if (isImport) {\n leftOfAs = this.parseIdentifier(true);\n if (!this.isContextual(93)) {\n this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);\n }\n } else {\n leftOfAs = this.parseModuleExportName();\n }\n }\n if (hasTypeSpecifier && isInTypeOnlyImportExport) {\n this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);\n }\n node[leftOfAsKey] = leftOfAs;\n node[rightOfAsKey] = rightOfAs;\n const kindKey = isImport ? \"importKind\" : \"exportKind\";\n node[kindKey] = hasTypeSpecifier ? \"type\" : \"value\";\n if (canParseAsKeyword && this.eatContextual(93)) {\n node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();\n }\n if (!node[rightOfAsKey]) {\n node[rightOfAsKey] = this.cloneIdentifier(node[leftOfAsKey]);\n }\n if (isImport) {\n this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096);\n }\n }\n fillOptionalPropertiesForTSESLint(node) {\n var _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out;\n switch (node.type) {\n case \"ExpressionStatement\":\n (_node$directive = node.directive) != null ? _node$directive : node.directive = undefined;\n return;\n case \"RestElement\":\n node.value = undefined;\n case \"Identifier\":\n case \"ArrayPattern\":\n case \"AssignmentPattern\":\n case \"ObjectPattern\":\n (_node$decorators = node.decorators) != null ? _node$decorators : node.decorators = [];\n (_node$optional = node.optional) != null ? _node$optional : node.optional = false;\n (_node$typeAnnotation = node.typeAnnotation) != null ? _node$typeAnnotation : node.typeAnnotation = undefined;\n return;\n case \"TSParameterProperty\":\n (_node$accessibility = node.accessibility) != null ? _node$accessibility : node.accessibility = undefined;\n (_node$decorators2 = node.decorators) != null ? _node$decorators2 : node.decorators = [];\n (_node$override = node.override) != null ? _node$override : node.override = false;\n (_node$readonly = node.readonly) != null ? _node$readonly : node.readonly = false;\n (_node$static = node.static) != null ? _node$static : node.static = false;\n return;\n case \"TSEmptyBodyFunctionExpression\":\n node.body = null;\n case \"TSDeclareFunction\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n (_node$declare = node.declare) != null ? _node$declare : node.declare = false;\n (_node$returnType = node.returnType) != null ? _node$returnType : node.returnType = undefined;\n (_node$typeParameters = node.typeParameters) != null ? _node$typeParameters : node.typeParameters = undefined;\n return;\n case \"Property\":\n (_node$optional2 = node.optional) != null ? _node$optional2 : node.optional = false;\n return;\n case \"TSMethodSignature\":\n case \"TSPropertySignature\":\n (_node$optional3 = node.optional) != null ? _node$optional3 : node.optional = false;\n case \"TSIndexSignature\":\n (_node$accessibility2 = node.accessibility) != null ? _node$accessibility2 : node.accessibility = undefined;\n (_node$readonly2 = node.readonly) != null ? _node$readonly2 : node.readonly = false;\n (_node$static2 = node.static) != null ? _node$static2 : node.static = false;\n return;\n case \"TSAbstractPropertyDefinition\":\n case \"PropertyDefinition\":\n case \"TSAbstractAccessorProperty\":\n case \"AccessorProperty\":\n (_node$declare2 = node.declare) != null ? _node$declare2 : node.declare = false;\n (_node$definite = node.definite) != null ? _node$definite : node.definite = false;\n (_node$readonly3 = node.readonly) != null ? _node$readonly3 : node.readonly = false;\n (_node$typeAnnotation2 = node.typeAnnotation) != null ? _node$typeAnnotation2 : node.typeAnnotation = undefined;\n case \"TSAbstractMethodDefinition\":\n case \"MethodDefinition\":\n (_node$accessibility3 = node.accessibility) != null ? _node$accessibility3 : node.accessibility = undefined;\n (_node$decorators3 = node.decorators) != null ? _node$decorators3 : node.decorators = [];\n (_node$override2 = node.override) != null ? _node$override2 : node.override = false;\n (_node$optional4 = node.optional) != null ? _node$optional4 : node.optional = false;\n return;\n case \"ClassExpression\":\n (_node$id = node.id) != null ? _node$id : node.id = null;\n case \"ClassDeclaration\":\n (_node$abstract = node.abstract) != null ? _node$abstract : node.abstract = false;\n (_node$declare3 = node.declare) != null ? _node$declare3 : node.declare = false;\n (_node$decorators4 = node.decorators) != null ? _node$decorators4 : node.decorators = [];\n (_node$implements = node.implements) != null ? _node$implements : node.implements = [];\n (_node$superTypeArgume = node.superTypeArguments) != null ? _node$superTypeArgume : node.superTypeArguments = undefined;\n (_node$typeParameters2 = node.typeParameters) != null ? _node$typeParameters2 : node.typeParameters = undefined;\n return;\n case \"TSTypeAliasDeclaration\":\n case \"VariableDeclaration\":\n (_node$declare4 = node.declare) != null ? _node$declare4 : node.declare = false;\n return;\n case \"VariableDeclarator\":\n (_node$definite2 = node.definite) != null ? _node$definite2 : node.definite = false;\n return;\n case \"TSEnumDeclaration\":\n (_node$const = node.const) != null ? _node$const : node.const = false;\n (_node$declare5 = node.declare) != null ? _node$declare5 : node.declare = false;\n return;\n case \"TSEnumMember\":\n (_node$computed = node.computed) != null ? _node$computed : node.computed = false;\n return;\n case \"TSImportType\":\n (_node$qualifier = node.qualifier) != null ? _node$qualifier : node.qualifier = null;\n (_node$options = node.options) != null ? _node$options : node.options = null;\n return;\n case \"TSInterfaceDeclaration\":\n (_node$declare6 = node.declare) != null ? _node$declare6 : node.declare = false;\n (_node$extends = node.extends) != null ? _node$extends : node.extends = [];\n return;\n case \"TSMappedType\":\n (_node$optional5 = node.optional) != null ? _node$optional5 : node.optional = false;\n (_node$readonly4 = node.readonly) != null ? _node$readonly4 : node.readonly = undefined;\n return;\n case \"TSModuleDeclaration\":\n (_node$declare7 = node.declare) != null ? _node$declare7 : node.declare = false;\n (_node$global = node.global) != null ? _node$global : node.global = node.kind === \"global\";\n return;\n case \"TSTypeParameter\":\n (_node$const2 = node.const) != null ? _node$const2 : node.const = false;\n (_node$in = node.in) != null ? _node$in : node.in = false;\n (_node$out = node.out) != null ? _node$out : node.out = false;\n return;\n }\n }\n chStartsBindingIdentifierAndNotRelationalOperator(ch, pos) {\n if (isIdentifierStart(ch)) {\n keywordAndTSRelationalOperator.lastIndex = pos;\n if (keywordAndTSRelationalOperator.test(this.input)) {\n const endCh = this.codePointAtPos(keywordAndTSRelationalOperator.lastIndex);\n if (!isIdentifierChar(endCh) && endCh !== 92) {\n return false;\n }\n }\n return true;\n } else if (ch === 92) {\n return true;\n } else {\n return false;\n }\n }\n nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine() {\n const next = this.nextTokenInLineStart();\n const nextCh = this.codePointAtPos(next);\n return this.chStartsBindingIdentifierAndNotRelationalOperator(nextCh, next);\n }\n nextTokenIsIdentifierOrStringLiteralOnSameLine() {\n const next = this.nextTokenInLineStart();\n const nextCh = this.codePointAtPos(next);\n return this.chStartsBindingIdentifier(nextCh, next) || nextCh === 34 || nextCh === 39;\n }\n};\nfunction isPossiblyLiteralEnum(expression) {\n if (expression.type !== \"MemberExpression\") return false;\n const {\n computed,\n property\n } = expression;\n if (computed && property.type !== \"StringLiteral\" && (property.type !== \"TemplateLiteral\" || property.expressions.length > 0)) {\n return false;\n }\n return isUncomputedMemberExpressionChain(expression.object);\n}\nfunction isValidAmbientConstInitializer(expression, estree) {\n var _expression$extra;\n const {\n type\n } = expression;\n if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {\n return false;\n }\n if (estree) {\n if (type === \"Literal\") {\n const {\n value\n } = expression;\n if (typeof value === \"string\" || typeof value === \"boolean\") {\n return true;\n }\n }\n } else {\n if (type === \"StringLiteral\" || type === \"BooleanLiteral\") {\n return true;\n }\n }\n if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {\n return true;\n }\n if (type === \"TemplateLiteral\" && expression.expressions.length === 0) {\n return true;\n }\n if (isPossiblyLiteralEnum(expression)) {\n return true;\n }\n return false;\n}\nfunction isNumber(expression, estree) {\n if (estree) {\n return expression.type === \"Literal\" && (typeof expression.value === \"number\" || \"bigint\" in expression);\n }\n return expression.type === \"NumericLiteral\" || expression.type === \"BigIntLiteral\";\n}\nfunction isNegativeNumber(expression, estree) {\n if (expression.type === \"UnaryExpression\") {\n const {\n operator,\n argument\n } = expression;\n if (operator === \"-\" && isNumber(argument, estree)) {\n return true;\n }\n }\n return false;\n}\nfunction isUncomputedMemberExpressionChain(expression) {\n if (expression.type === \"Identifier\") return true;\n if (expression.type !== \"MemberExpression\" || expression.computed) {\n return false;\n }\n return isUncomputedMemberExpressionChain(expression.object);\n}\nconst PlaceholderErrors = ParseErrorEnum`placeholders`({\n ClassNameIsRequired: \"A class name is required.\",\n UnexpectedSpace: \"Unexpected space in placeholder.\"\n});\nvar placeholders = superClass => class PlaceholdersParserMixin extends superClass {\n parsePlaceholder(expectedNode) {\n if (this.match(133)) {\n const node = this.startNode();\n this.next();\n this.assertNoSpace();\n node.name = super.parseIdentifier(true);\n this.assertNoSpace();\n this.expect(133);\n return this.finishPlaceholder(node, expectedNode);\n }\n }\n finishPlaceholder(node, expectedNode) {\n let placeholder = node;\n if (!placeholder.expectedNode || !placeholder.type) {\n placeholder = this.finishNode(placeholder, \"Placeholder\");\n }\n placeholder.expectedNode = expectedNode;\n return placeholder;\n }\n getTokenFromCode(code) {\n if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {\n this.finishOp(133, 2);\n } else {\n super.getTokenFromCode(code);\n }\n }\n parseExprAtom(refExpressionErrors) {\n return this.parsePlaceholder(\"Expression\") || super.parseExprAtom(refExpressionErrors);\n }\n parseIdentifier(liberal) {\n return this.parsePlaceholder(\"Identifier\") || super.parseIdentifier(liberal);\n }\n checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n if (word !== undefined) {\n super.checkReservedWord(word, startLoc, checkKeywords, isBinding);\n }\n }\n cloneIdentifier(node) {\n const cloned = super.cloneIdentifier(node);\n if (cloned.type === \"Placeholder\") {\n cloned.expectedNode = node.expectedNode;\n }\n return cloned;\n }\n cloneStringLiteral(node) {\n if (node.type === \"Placeholder\") {\n return this.cloneIdentifier(node);\n }\n return super.cloneStringLiteral(node);\n }\n parseBindingAtom() {\n return this.parsePlaceholder(\"Pattern\") || super.parseBindingAtom();\n }\n isValidLVal(type, disallowCallExpression, isParenthesized, binding) {\n return type === \"Placeholder\" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding);\n }\n toAssignable(node, isLHS) {\n if (node && node.type === \"Placeholder\" && node.expectedNode === \"Expression\") {\n node.expectedNode = \"Pattern\";\n } else {\n super.toAssignable(node, isLHS);\n }\n }\n chStartsBindingIdentifier(ch, pos) {\n if (super.chStartsBindingIdentifier(ch, pos)) {\n return true;\n }\n const next = this.nextTokenStart();\n if (this.input.charCodeAt(next) === 37 && this.input.charCodeAt(next + 1) === 37) {\n return true;\n }\n return false;\n }\n verifyBreakContinue(node, isBreak) {\n var _node$label;\n if (((_node$label = node.label) == null ? void 0 : _node$label.type) === \"Placeholder\") return;\n super.verifyBreakContinue(node, isBreak);\n }\n parseExpressionStatement(node, expr) {\n var _expr$extra;\n if (expr.type !== \"Placeholder\" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {\n return super.parseExpressionStatement(node, expr);\n }\n if (this.match(14)) {\n const stmt = node;\n stmt.label = this.finishPlaceholder(expr, \"Identifier\");\n this.next();\n stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();\n return this.finishNode(stmt, \"LabeledStatement\");\n }\n this.semicolon();\n const stmtPlaceholder = node;\n stmtPlaceholder.name = expr.name;\n return this.finishPlaceholder(stmtPlaceholder, \"Statement\");\n }\n parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {\n return this.parsePlaceholder(\"BlockStatement\") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);\n }\n parseFunctionId(requireId) {\n return this.parsePlaceholder(\"Identifier\") || super.parseFunctionId(requireId);\n }\n parseClass(node, isStatement, optionalId) {\n const type = isStatement ? \"ClassDeclaration\" : \"ClassExpression\";\n this.next();\n const oldStrict = this.state.strict;\n const placeholder = this.parsePlaceholder(\"Identifier\");\n if (placeholder) {\n if (this.match(81) || this.match(133) || this.match(5)) {\n node.id = placeholder;\n } else if (optionalId || !isStatement) {\n node.id = null;\n node.body = this.finishPlaceholder(placeholder, \"ClassBody\");\n return this.finishNode(node, type);\n } else {\n throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);\n }\n } else {\n this.parseClassId(node, isStatement, optionalId);\n }\n super.parseClassSuper(node);\n node.body = this.parsePlaceholder(\"ClassBody\") || super.parseClassBody(!!node.superClass, oldStrict);\n return this.finishNode(node, type);\n }\n parseExport(node, decorators) {\n const placeholder = this.parsePlaceholder(\"Identifier\");\n if (!placeholder) return super.parseExport(node, decorators);\n const node2 = node;\n if (!this.isContextual(98) && !this.match(12)) {\n node2.specifiers = [];\n node2.source = null;\n node2.declaration = this.finishPlaceholder(placeholder, \"Declaration\");\n return this.finishNode(node2, \"ExportNamedDeclaration\");\n }\n this.expectPlugin(\"exportDefaultFrom\");\n const specifier = this.startNode();\n specifier.exported = placeholder;\n node2.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n return super.parseExport(node2, decorators);\n }\n isExportDefaultSpecifier() {\n if (this.match(65)) {\n const next = this.nextTokenStart();\n if (this.isUnparsedContextual(next, \"from\")) {\n if (this.input.startsWith(tokenLabelName(133), this.nextTokenStartSince(next + 4))) {\n return true;\n }\n }\n }\n return super.isExportDefaultSpecifier();\n }\n maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {\n var _specifiers;\n if ((_specifiers = node.specifiers) != null && _specifiers.length) {\n return true;\n }\n return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);\n }\n checkExport(node) {\n const {\n specifiers\n } = node;\n if (specifiers != null && specifiers.length) {\n node.specifiers = specifiers.filter(node => node.exported.type === \"Placeholder\");\n }\n super.checkExport(node);\n node.specifiers = specifiers;\n }\n parseImport(node) {\n const placeholder = this.parsePlaceholder(\"Identifier\");\n if (!placeholder) return super.parseImport(node);\n node.specifiers = [];\n if (!this.isContextual(98) && !this.match(12)) {\n node.source = this.finishPlaceholder(placeholder, \"StringLiteral\");\n this.semicolon();\n return this.finishNode(node, \"ImportDeclaration\");\n }\n const specifier = this.startNodeAtNode(placeholder);\n specifier.local = placeholder;\n node.specifiers.push(this.finishNode(specifier, \"ImportDefaultSpecifier\"));\n if (this.eat(12)) {\n const hasStarImport = this.maybeParseStarImportSpecifier(node);\n if (!hasStarImport) this.parseNamedImportSpecifiers(node);\n }\n this.expectContextual(98);\n node.source = this.parseImportSource();\n this.semicolon();\n return this.finishNode(node, \"ImportDeclaration\");\n }\n parseImportSource() {\n return this.parsePlaceholder(\"StringLiteral\") || super.parseImportSource();\n }\n assertNoSpace() {\n if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) {\n this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);\n }\n }\n};\nvar v8intrinsic = superClass => class V8IntrinsicMixin extends superClass {\n parseV8Intrinsic() {\n if (this.match(54)) {\n const v8IntrinsicStartLoc = this.state.startLoc;\n const node = this.startNode();\n this.next();\n if (tokenIsIdentifier(this.state.type)) {\n const name = this.parseIdentifierName();\n const identifier = this.createIdentifier(node, name);\n this.castNodeTo(identifier, \"V8IntrinsicIdentifier\");\n if (this.match(10)) {\n return identifier;\n }\n }\n this.unexpected(v8IntrinsicStartLoc);\n }\n }\n parseExprAtom(refExpressionErrors) {\n return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);\n }\n};\nconst PIPELINE_PROPOSALS = [\"minimal\", \"fsharp\", \"hack\", \"smart\"];\nconst TOPIC_TOKENS = [\"^^\", \"@@\", \"^\", \"%\", \"#\"];\nfunction validatePlugins(pluginsMap) {\n if (pluginsMap.has(\"decorators\")) {\n if (pluginsMap.has(\"decorators-legacy\")) {\n throw new Error(\"Cannot use the decorators and decorators-legacy plugin together\");\n }\n const decoratorsBeforeExport = pluginsMap.get(\"decorators\").decoratorsBeforeExport;\n if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== \"boolean\") {\n throw new Error(\"'decoratorsBeforeExport' must be a boolean, if specified.\");\n }\n const allowCallParenthesized = pluginsMap.get(\"decorators\").allowCallParenthesized;\n if (allowCallParenthesized != null && typeof allowCallParenthesized !== \"boolean\") {\n throw new Error(\"'allowCallParenthesized' must be a boolean.\");\n }\n }\n if (pluginsMap.has(\"flow\") && pluginsMap.has(\"typescript\")) {\n throw new Error(\"Cannot combine flow and typescript plugins.\");\n }\n if (pluginsMap.has(\"placeholders\") && pluginsMap.has(\"v8intrinsic\")) {\n throw new Error(\"Cannot combine placeholders and v8intrinsic plugins.\");\n }\n if (pluginsMap.has(\"pipelineOperator\")) {\n var _pluginsMap$get2;\n const proposal = pluginsMap.get(\"pipelineOperator\").proposal;\n if (!PIPELINE_PROPOSALS.includes(proposal)) {\n const proposalList = PIPELINE_PROPOSALS.map(p => `\"${p}\"`).join(\", \");\n throw new Error(`\"pipelineOperator\" requires \"proposal\" option whose value must be one of: ${proposalList}.`);\n }\n if (proposal === \"hack\") {\n var _pluginsMap$get;\n if (pluginsMap.has(\"placeholders\")) {\n throw new Error(\"Cannot combine placeholders plugin and Hack-style pipes.\");\n }\n if (pluginsMap.has(\"v8intrinsic\")) {\n throw new Error(\"Cannot combine v8intrinsic plugin and Hack-style pipes.\");\n }\n const topicToken = pluginsMap.get(\"pipelineOperator\").topicToken;\n if (!TOPIC_TOKENS.includes(topicToken)) {\n const tokenList = TOPIC_TOKENS.map(t => `\"${t}\"`).join(\", \");\n throw new Error(`\"pipelineOperator\" in \"proposal\": \"hack\" mode also requires a \"topicToken\" option whose value must be one of: ${tokenList}.`);\n }\n if (topicToken === \"#\" && ((_pluginsMap$get = pluginsMap.get(\"recordAndTuple\")) == null ? void 0 : _pluginsMap$get.syntaxType) === \"hash\") {\n throw new Error(`Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"hack\", topicToken: \"#\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`);\n }\n } else if (proposal === \"smart\" && ((_pluginsMap$get2 = pluginsMap.get(\"recordAndTuple\")) == null ? void 0 : _pluginsMap$get2.syntaxType) === \"hash\") {\n throw new Error(`Plugin conflict between \\`[\"pipelineOperator\", { proposal: \"smart\" }]\\` and \\`${JSON.stringify([\"recordAndTuple\", pluginsMap.get(\"recordAndTuple\")])}\\`.`);\n }\n }\n if (pluginsMap.has(\"moduleAttributes\")) {\n if (pluginsMap.has(\"deprecatedImportAssert\") || pluginsMap.has(\"importAssertions\")) {\n throw new Error(\"Cannot combine importAssertions, deprecatedImportAssert and moduleAttributes plugins.\");\n }\n const moduleAttributesVersionPluginOption = pluginsMap.get(\"moduleAttributes\").version;\n if (moduleAttributesVersionPluginOption !== \"may-2020\") {\n throw new Error(\"The 'moduleAttributes' plugin requires a 'version' option,\" + \" representing the last proposal update. Currently, the\" + \" only supported value is 'may-2020'.\");\n }\n }\n if (pluginsMap.has(\"importAssertions\")) {\n if (pluginsMap.has(\"deprecatedImportAssert\")) {\n throw new Error(\"Cannot combine importAssertions and deprecatedImportAssert plugins.\");\n }\n }\n if (pluginsMap.has(\"deprecatedImportAssert\")) ;else if (pluginsMap.has(\"importAttributes\") && pluginsMap.get(\"importAttributes\").deprecatedAssertSyntax) {\n pluginsMap.set(\"deprecatedImportAssert\", {});\n }\n if (pluginsMap.has(\"recordAndTuple\")) {\n const syntaxType = pluginsMap.get(\"recordAndTuple\").syntaxType;\n if (syntaxType != null) {\n const RECORD_AND_TUPLE_SYNTAX_TYPES = [\"hash\", \"bar\"];\n if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) {\n throw new Error(\"The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: \" + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(\", \"));\n }\n }\n }\n if (pluginsMap.has(\"asyncDoExpressions\") && !pluginsMap.has(\"doExpressions\")) {\n const error = new Error(\"'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.\");\n error.missingPlugins = \"doExpressions\";\n throw error;\n }\n if (pluginsMap.has(\"optionalChainingAssign\") && pluginsMap.get(\"optionalChainingAssign\").version !== \"2023-07\") {\n throw new Error(\"The 'optionalChainingAssign' plugin requires a 'version' option,\" + \" representing the last proposal update. Currently, the\" + \" only supported value is '2023-07'.\");\n }\n if (pluginsMap.has(\"discardBinding\") && pluginsMap.get(\"discardBinding\").syntaxType !== \"void\") {\n throw new Error(\"The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'.\");\n }\n}\nconst mixinPlugins = {\n estree,\n jsx,\n flow,\n typescript,\n v8intrinsic,\n placeholders\n};\nconst mixinPluginNames = Object.keys(mixinPlugins);\nclass ExpressionParser extends LValParser {\n checkProto(prop, isRecord, sawProto, refExpressionErrors) {\n if (prop.type === \"SpreadElement\" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {\n return sawProto;\n }\n const key = prop.key;\n const name = key.type === \"Identifier\" ? key.name : key.value;\n if (name === \"__proto__\") {\n if (isRecord) {\n this.raise(Errors.RecordNoProto, key);\n return true;\n }\n if (sawProto) {\n if (refExpressionErrors) {\n if (refExpressionErrors.doubleProtoLoc === null) {\n refExpressionErrors.doubleProtoLoc = key.loc.start;\n }\n } else {\n this.raise(Errors.DuplicateProto, key);\n }\n }\n return true;\n }\n return sawProto;\n }\n shouldExitDescending(expr, potentialArrowAt) {\n return expr.type === \"ArrowFunctionExpression\" && this.offsetToSourcePos(expr.start) === potentialArrowAt;\n }\n getExpression() {\n this.enterInitialScopes();\n this.nextToken();\n if (this.match(140)) {\n throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);\n }\n const expr = this.parseExpression();\n if (!this.match(140)) {\n throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, {\n unexpected: this.input.codePointAt(this.state.start)\n });\n }\n this.finalizeRemainingComments();\n expr.comments = this.comments;\n expr.errors = this.state.errors;\n if (this.optionFlags & 256) {\n expr.tokens = this.tokens;\n }\n return expr;\n }\n parseExpression(disallowIn, refExpressionErrors) {\n if (disallowIn) {\n return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n }\n return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));\n }\n parseExpressionBase(refExpressionErrors) {\n const startLoc = this.state.startLoc;\n const expr = this.parseMaybeAssign(refExpressionErrors);\n if (this.match(12)) {\n const node = this.startNodeAt(startLoc);\n node.expressions = [expr];\n while (this.eat(12)) {\n node.expressions.push(this.parseMaybeAssign(refExpressionErrors));\n }\n this.toReferencedList(node.expressions);\n return this.finishNode(node, \"SequenceExpression\");\n }\n return expr;\n }\n parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {\n return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));\n }\n parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {\n return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));\n }\n setOptionalParametersError(refExpressionErrors) {\n refExpressionErrors.optionalParametersLoc = this.state.startLoc;\n }\n parseMaybeAssign(refExpressionErrors, afterLeftParse) {\n const startLoc = this.state.startLoc;\n const isYield = this.isContextual(108);\n if (isYield) {\n if (this.prodParam.hasYield) {\n this.next();\n let left = this.parseYield(startLoc);\n if (afterLeftParse) {\n left = afterLeftParse.call(this, left, startLoc);\n }\n return left;\n }\n }\n let ownExpressionErrors;\n if (refExpressionErrors) {\n ownExpressionErrors = false;\n } else {\n refExpressionErrors = new ExpressionErrors();\n ownExpressionErrors = true;\n }\n const {\n type\n } = this.state;\n if (type === 10 || tokenIsIdentifier(type)) {\n this.state.potentialArrowAt = this.state.start;\n }\n let left = this.parseMaybeConditional(refExpressionErrors);\n if (afterLeftParse) {\n left = afterLeftParse.call(this, left, startLoc);\n }\n if (tokenIsAssignment(this.state.type)) {\n const node = this.startNodeAt(startLoc);\n const operator = this.state.value;\n node.operator = operator;\n if (this.match(29)) {\n this.toAssignable(left, true);\n node.left = left;\n const startIndex = startLoc.index;\n if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {\n refExpressionErrors.doubleProtoLoc = null;\n }\n if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {\n refExpressionErrors.shorthandAssignLoc = null;\n }\n if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {\n this.checkDestructuringPrivate(refExpressionErrors);\n refExpressionErrors.privateKeyLoc = null;\n }\n if (refExpressionErrors.voidPatternLoc != null && refExpressionErrors.voidPatternLoc.index >= startIndex) {\n refExpressionErrors.voidPatternLoc = null;\n }\n } else {\n node.left = left;\n }\n this.next();\n node.right = this.parseMaybeAssign();\n this.checkLVal(left, this.finishNode(node, \"AssignmentExpression\"), undefined, undefined, undefined, undefined, operator === \"||=\" || operator === \"&&=\" || operator === \"??=\");\n return node;\n } else if (ownExpressionErrors) {\n this.checkExpressionErrors(refExpressionErrors, true);\n }\n if (isYield) {\n const {\n type\n } = this.state;\n const startsExpr = this.hasPlugin(\"v8intrinsic\") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);\n if (startsExpr && !this.isAmbiguousPrefixOrIdentifier()) {\n this.raiseOverwrite(Errors.YieldNotInGeneratorFunction, startLoc);\n return this.parseYield(startLoc);\n }\n }\n return left;\n }\n parseMaybeConditional(refExpressionErrors) {\n const startLoc = this.state.startLoc;\n const potentialArrowAt = this.state.potentialArrowAt;\n const expr = this.parseExprOps(refExpressionErrors);\n if (this.shouldExitDescending(expr, potentialArrowAt)) {\n return expr;\n }\n return this.parseConditional(expr, startLoc, refExpressionErrors);\n }\n parseConditional(expr, startLoc, refExpressionErrors) {\n if (this.eat(17)) {\n const node = this.startNodeAt(startLoc);\n node.test = expr;\n node.consequent = this.parseMaybeAssignAllowIn();\n this.expect(14);\n node.alternate = this.parseMaybeAssign();\n return this.finishNode(node, \"ConditionalExpression\");\n }\n return expr;\n }\n parseMaybeUnaryOrPrivate(refExpressionErrors) {\n return this.match(139) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);\n }\n parseExprOps(refExpressionErrors) {\n const startLoc = this.state.startLoc;\n const potentialArrowAt = this.state.potentialArrowAt;\n const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);\n if (this.shouldExitDescending(expr, potentialArrowAt)) {\n return expr;\n }\n return this.parseExprOp(expr, startLoc, -1);\n }\n parseExprOp(left, leftStartLoc, minPrec) {\n if (this.isPrivateName(left)) {\n const value = this.getPrivateNameSV(left);\n if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {\n this.raise(Errors.PrivateInExpectedIn, left, {\n identifierName: value\n });\n }\n this.classScope.usePrivateName(value, left.loc.start);\n }\n const op = this.state.type;\n if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {\n let prec = tokenOperatorPrecedence(op);\n if (prec > minPrec) {\n if (op === 39) {\n this.expectPlugin(\"pipelineOperator\");\n if (this.state.inFSharpPipelineDirectBody) {\n return left;\n }\n this.checkPipelineAtInfixOperator(left, leftStartLoc);\n }\n const node = this.startNodeAt(leftStartLoc);\n node.left = left;\n node.operator = this.state.value;\n const logical = op === 41 || op === 42;\n const coalesce = op === 40;\n if (coalesce) {\n prec = tokenOperatorPrecedence(42);\n }\n this.next();\n if (op === 39 && this.hasPlugin([\"pipelineOperator\", {\n proposal: \"minimal\"\n }])) {\n if (this.state.type === 96 && this.prodParam.hasAwait) {\n throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, this.state.startLoc);\n }\n }\n node.right = this.parseExprOpRightExpr(op, prec);\n const finishedNode = this.finishNode(node, logical || coalesce ? \"LogicalExpression\" : \"BinaryExpression\");\n const nextOp = this.state.type;\n if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {\n throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);\n }\n return this.parseExprOp(finishedNode, leftStartLoc, minPrec);\n }\n }\n return left;\n }\n parseExprOpRightExpr(op, prec) {\n const startLoc = this.state.startLoc;\n switch (op) {\n case 39:\n switch (this.getPluginOption(\"pipelineOperator\", \"proposal\")) {\n case \"hack\":\n return this.withTopicBindingContext(() => {\n return this.parseHackPipeBody();\n });\n case \"fsharp\":\n return this.withSoloAwaitPermittingContext(() => {\n return this.parseFSharpPipelineBody(prec);\n });\n }\n if (this.getPluginOption(\"pipelineOperator\", \"proposal\") === \"smart\") {\n return this.withTopicBindingContext(() => {\n if (this.prodParam.hasYield && this.isContextual(108)) {\n throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);\n }\n return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);\n });\n }\n default:\n return this.parseExprOpBaseRightExpr(op, prec);\n }\n }\n parseExprOpBaseRightExpr(op, prec) {\n const startLoc = this.state.startLoc;\n return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);\n }\n parseHackPipeBody() {\n var _body$extra;\n const {\n startLoc\n } = this.state;\n const body = this.parseMaybeAssign();\n const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);\n if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {\n this.raise(Errors.PipeUnparenthesizedBody, startLoc, {\n type: body.type\n });\n }\n if (!this.topicReferenceWasUsedInCurrentContext()) {\n this.raise(Errors.PipeTopicUnused, startLoc);\n }\n return body;\n }\n checkExponentialAfterUnary(node) {\n if (this.match(57)) {\n this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);\n }\n }\n parseMaybeUnary(refExpressionErrors, sawUnary) {\n const startLoc = this.state.startLoc;\n const isAwait = this.isContextual(96);\n if (isAwait && this.recordAwaitIfAllowed()) {\n this.next();\n const expr = this.parseAwait(startLoc);\n if (!sawUnary) this.checkExponentialAfterUnary(expr);\n return expr;\n }\n const update = this.match(34);\n const node = this.startNode();\n if (tokenIsPrefix(this.state.type)) {\n node.operator = this.state.value;\n node.prefix = true;\n if (this.match(72)) {\n this.expectPlugin(\"throwExpressions\");\n }\n const isDelete = this.match(89);\n this.next();\n node.argument = this.parseMaybeUnary(null, true);\n this.checkExpressionErrors(refExpressionErrors, true);\n if (this.state.strict && isDelete) {\n const arg = node.argument;\n if (arg.type === \"Identifier\") {\n this.raise(Errors.StrictDelete, node);\n } else if (this.hasPropertyAsPrivateName(arg)) {\n this.raise(Errors.DeletePrivateField, node);\n }\n }\n if (!update) {\n if (!sawUnary) {\n this.checkExponentialAfterUnary(node);\n }\n return this.finishNode(node, \"UnaryExpression\");\n }\n }\n const expr = this.parseUpdate(node, update, refExpressionErrors);\n if (isAwait) {\n const {\n type\n } = this.state;\n const startsExpr = this.hasPlugin(\"v8intrinsic\") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);\n if (startsExpr && !this.isAmbiguousPrefixOrIdentifier()) {\n this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);\n return this.parseAwait(startLoc);\n }\n }\n return expr;\n }\n parseUpdate(node, update, refExpressionErrors) {\n if (update) {\n const updateExpressionNode = node;\n this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, \"UpdateExpression\"));\n return node;\n }\n const startLoc = this.state.startLoc;\n let expr = this.parseExprSubscripts(refExpressionErrors);\n if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;\n while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {\n const node = this.startNodeAt(startLoc);\n node.operator = this.state.value;\n node.prefix = false;\n node.argument = expr;\n this.next();\n this.checkLVal(expr, expr = this.finishNode(node, \"UpdateExpression\"));\n }\n return expr;\n }\n parseExprSubscripts(refExpressionErrors) {\n const startLoc = this.state.startLoc;\n const potentialArrowAt = this.state.potentialArrowAt;\n const expr = this.parseExprAtom(refExpressionErrors);\n if (this.shouldExitDescending(expr, potentialArrowAt)) {\n return expr;\n }\n return this.parseSubscripts(expr, startLoc);\n }\n parseSubscripts(base, startLoc, noCalls) {\n const state = {\n optionalChainMember: false,\n maybeAsyncArrow: this.atPossibleAsyncArrow(base),\n stop: false\n };\n do {\n base = this.parseSubscript(base, startLoc, noCalls, state);\n state.maybeAsyncArrow = false;\n } while (!state.stop);\n return base;\n }\n parseSubscript(base, startLoc, noCalls, state) {\n const {\n type\n } = this.state;\n if (!noCalls && type === 15) {\n return this.parseBind(base, startLoc, noCalls, state);\n } else if (tokenIsTemplate(type)) {\n return this.parseTaggedTemplateExpression(base, startLoc, state);\n }\n let optional = false;\n if (type === 18) {\n if (noCalls) {\n this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);\n if (this.lookaheadCharCode() === 40) {\n return this.stopParseSubscript(base, state);\n }\n }\n state.optionalChainMember = optional = true;\n this.next();\n }\n if (!noCalls && this.match(10)) {\n return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);\n } else {\n const computed = this.eat(0);\n if (computed || optional || this.eat(16)) {\n return this.parseMember(base, startLoc, state, computed, optional);\n } else {\n return this.stopParseSubscript(base, state);\n }\n }\n }\n stopParseSubscript(base, state) {\n state.stop = true;\n return base;\n }\n parseMember(base, startLoc, state, computed, optional) {\n const node = this.startNodeAt(startLoc);\n node.object = base;\n node.computed = computed;\n if (computed) {\n node.property = this.parseExpression();\n this.expect(3);\n } else if (this.match(139)) {\n if (base.type === \"Super\") {\n this.raise(Errors.SuperPrivateField, startLoc);\n }\n this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n node.property = this.parsePrivateName();\n } else {\n node.property = this.parseIdentifier(true);\n }\n if (state.optionalChainMember) {\n node.optional = optional;\n return this.finishNode(node, \"OptionalMemberExpression\");\n } else {\n return this.finishNode(node, \"MemberExpression\");\n }\n }\n parseBind(base, startLoc, noCalls, state) {\n const node = this.startNodeAt(startLoc);\n node.object = base;\n this.next();\n node.callee = this.parseNoCallExpr();\n state.stop = true;\n return this.parseSubscripts(this.finishNode(node, \"BindExpression\"), startLoc, noCalls);\n }\n parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {\n const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n let refExpressionErrors = null;\n this.state.maybeInArrowParameters = true;\n this.next();\n const node = this.startNodeAt(startLoc);\n node.callee = base;\n const {\n maybeAsyncArrow,\n optionalChainMember\n } = state;\n if (maybeAsyncArrow) {\n this.expressionScope.enter(newAsyncArrowScope());\n refExpressionErrors = new ExpressionErrors();\n }\n if (optionalChainMember) {\n node.optional = optional;\n }\n if (optional) {\n node.arguments = this.parseCallExpressionArguments();\n } else {\n node.arguments = this.parseCallExpressionArguments(base.type !== \"Super\", node, refExpressionErrors);\n }\n let finishedNode = this.finishCallExpression(node, optionalChainMember);\n if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {\n state.stop = true;\n this.checkDestructuringPrivate(refExpressionErrors);\n this.expressionScope.validateAsPattern();\n this.expressionScope.exit();\n finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);\n } else {\n if (maybeAsyncArrow) {\n this.checkExpressionErrors(refExpressionErrors, true);\n this.expressionScope.exit();\n }\n this.toReferencedArguments(finishedNode);\n }\n this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n return finishedNode;\n }\n toReferencedArguments(node, isParenthesizedExpr) {\n this.toReferencedListDeep(node.arguments, isParenthesizedExpr);\n }\n parseTaggedTemplateExpression(base, startLoc, state) {\n const node = this.startNodeAt(startLoc);\n node.tag = base;\n node.quasi = this.parseTemplate(true);\n if (state.optionalChainMember) {\n this.raise(Errors.OptionalChainingNoTemplate, startLoc);\n }\n return this.finishNode(node, \"TaggedTemplateExpression\");\n }\n atPossibleAsyncArrow(base) {\n return base.type === \"Identifier\" && base.name === \"async\" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && this.offsetToSourcePos(base.start) === this.state.potentialArrowAt;\n }\n finishCallExpression(node, optional) {\n if (node.callee.type === \"Import\") {\n if (node.arguments.length === 0 || node.arguments.length > 2) {\n this.raise(Errors.ImportCallArity, node);\n } else {\n for (const arg of node.arguments) {\n if (arg.type === \"SpreadElement\") {\n this.raise(Errors.ImportCallSpreadArgument, arg);\n }\n }\n }\n }\n return this.finishNode(node, optional ? \"OptionalCallExpression\" : \"CallExpression\");\n }\n parseCallExpressionArguments(allowPlaceholder, nodeForExtra, refExpressionErrors) {\n const elts = [];\n let first = true;\n const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n this.state.inFSharpPipelineDirectBody = false;\n while (!this.eat(11)) {\n if (first) {\n first = false;\n } else {\n this.expect(12);\n if (this.match(11)) {\n if (nodeForExtra) {\n this.addTrailingCommaExtraToNode(nodeForExtra);\n }\n this.next();\n break;\n }\n }\n elts.push(this.parseExprListItem(11, false, refExpressionErrors, allowPlaceholder));\n }\n this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n return elts;\n }\n shouldParseAsyncArrow() {\n return this.match(19) && !this.canInsertSemicolon();\n }\n parseAsyncArrowFromCallExpression(node, call) {\n var _call$extra;\n this.resetPreviousNodeTrailingComments(call);\n this.expect(19);\n this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);\n if (call.innerComments) {\n setInnerComments(node, call.innerComments);\n }\n if (call.callee.trailingComments) {\n setInnerComments(node, call.callee.trailingComments);\n }\n return node;\n }\n parseNoCallExpr() {\n const startLoc = this.state.startLoc;\n return this.parseSubscripts(this.parseExprAtom(), startLoc, true);\n }\n parseExprAtom(refExpressionErrors) {\n let node;\n let decorators = null;\n const {\n type\n } = this.state;\n switch (type) {\n case 79:\n return this.parseSuper();\n case 83:\n node = this.startNode();\n this.next();\n if (this.match(16)) {\n return this.parseImportMetaPropertyOrPhaseCall(node);\n }\n if (this.match(10)) {\n if (this.optionFlags & 512) {\n return this.parseImportCall(node);\n } else {\n return this.finishNode(node, \"Import\");\n }\n } else {\n this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);\n return this.finishNode(node, \"Import\");\n }\n case 78:\n node = this.startNode();\n this.next();\n return this.finishNode(node, \"ThisExpression\");\n case 90:\n {\n return this.parseDo(this.startNode(), false);\n }\n case 56:\n case 31:\n {\n this.readRegexp();\n return this.parseRegExpLiteral(this.state.value);\n }\n case 135:\n return this.parseNumericLiteral(this.state.value);\n case 136:\n return this.parseBigIntLiteral(this.state.value);\n case 134:\n return this.parseStringLiteral(this.state.value);\n case 84:\n return this.parseNullLiteral();\n case 85:\n return this.parseBooleanLiteral(true);\n case 86:\n return this.parseBooleanLiteral(false);\n case 10:\n {\n const canBeArrow = this.state.potentialArrowAt === this.state.start;\n return this.parseParenAndDistinguishExpression(canBeArrow);\n }\n case 0:\n {\n return this.parseArrayLike(3, false, refExpressionErrors);\n }\n case 5:\n {\n return this.parseObjectLike(8, false, false, refExpressionErrors);\n }\n case 68:\n return this.parseFunctionOrFunctionSent();\n case 26:\n decorators = this.parseDecorators();\n case 80:\n return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);\n case 77:\n return this.parseNewOrNewTarget();\n case 25:\n case 24:\n return this.parseTemplate(false);\n case 15:\n {\n node = this.startNode();\n this.next();\n node.object = null;\n const callee = node.callee = this.parseNoCallExpr();\n if (callee.type === \"MemberExpression\") {\n return this.finishNode(node, \"BindExpression\");\n } else {\n throw this.raise(Errors.UnsupportedBind, callee);\n }\n }\n case 139:\n {\n this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, {\n identifierName: this.state.value\n });\n return this.parsePrivateName();\n }\n case 33:\n {\n return this.parseTopicReferenceThenEqualsSign(54, \"%\");\n }\n case 32:\n {\n return this.parseTopicReferenceThenEqualsSign(44, \"^\");\n }\n case 37:\n case 38:\n {\n return this.parseTopicReference(\"hack\");\n }\n case 44:\n case 54:\n case 27:\n {\n const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n if (pipeProposal) {\n return this.parseTopicReference(pipeProposal);\n }\n throw this.unexpected();\n }\n case 47:\n {\n const lookaheadCh = this.input.codePointAt(this.nextTokenStart());\n if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {\n throw this.expectOnePlugin([\"jsx\", \"flow\", \"typescript\"]);\n }\n throw this.unexpected();\n }\n default:\n if (type === 137) {\n return this.parseDecimalLiteral(this.state.value);\n } else if (type === 2 || type === 1) {\n return this.parseArrayLike(this.state.type === 2 ? 4 : 3, true);\n } else if (type === 6 || type === 7) {\n return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);\n }\n if (tokenIsIdentifier(type)) {\n if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) {\n return this.parseModuleExpression();\n }\n const canBeArrow = this.state.potentialArrowAt === this.state.start;\n const containsEsc = this.state.containsEsc;\n const id = this.parseIdentifier();\n if (!containsEsc && id.name === \"async\" && !this.canInsertSemicolon()) {\n const {\n type\n } = this.state;\n if (type === 68) {\n this.resetPreviousNodeTrailingComments(id);\n this.next();\n return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));\n } else if (tokenIsIdentifier(type)) {\n if (this.lookaheadCharCode() === 61) {\n return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));\n } else {\n return id;\n }\n } else if (type === 90) {\n this.resetPreviousNodeTrailingComments(id);\n return this.parseDo(this.startNodeAtNode(id), true);\n }\n }\n if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {\n this.next();\n return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);\n }\n return id;\n } else {\n throw this.unexpected();\n }\n }\n }\n parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {\n const pipeProposal = this.getPluginOption(\"pipelineOperator\", \"proposal\");\n if (pipeProposal) {\n this.state.type = topicTokenType;\n this.state.value = topicTokenValue;\n this.state.pos--;\n this.state.end--;\n this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);\n return this.parseTopicReference(pipeProposal);\n }\n throw this.unexpected();\n }\n parseTopicReference(pipeProposal) {\n const node = this.startNode();\n const startLoc = this.state.startLoc;\n const tokenType = this.state.type;\n this.next();\n return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);\n }\n finishTopicReference(node, startLoc, pipeProposal, tokenType) {\n if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {\n if (pipeProposal === \"hack\") {\n if (!this.topicReferenceIsAllowedInCurrentContext()) {\n this.raise(Errors.PipeTopicUnbound, startLoc);\n }\n this.registerTopicReference();\n return this.finishNode(node, \"TopicReference\");\n } else {\n if (!this.topicReferenceIsAllowedInCurrentContext()) {\n this.raise(Errors.PrimaryTopicNotAllowed, startLoc);\n }\n this.registerTopicReference();\n return this.finishNode(node, \"PipelinePrimaryTopicReference\");\n }\n } else {\n throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {\n token: tokenLabelName(tokenType)\n });\n }\n }\n testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {\n switch (pipeProposal) {\n case \"hack\":\n {\n return this.hasPlugin([\"pipelineOperator\", {\n topicToken: tokenLabelName(tokenType)\n }]);\n }\n case \"smart\":\n return tokenType === 27;\n default:\n throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);\n }\n }\n parseAsyncArrowUnaryFunction(node) {\n this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));\n const params = [this.parseIdentifier()];\n this.prodParam.exit();\n if (this.hasPrecedingLineBreak()) {\n this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());\n }\n this.expect(19);\n return this.parseArrowExpression(node, params, true);\n }\n parseDo(node, isAsync) {\n this.expectPlugin(\"doExpressions\");\n if (isAsync) {\n this.expectPlugin(\"asyncDoExpressions\");\n }\n node.async = isAsync;\n this.next();\n const oldLabels = this.state.labels;\n this.state.labels = [];\n if (isAsync) {\n this.prodParam.enter(2);\n node.body = this.parseBlock();\n this.prodParam.exit();\n } else {\n node.body = this.parseBlock();\n }\n this.state.labels = oldLabels;\n return this.finishNode(node, \"DoExpression\");\n }\n parseSuper() {\n const node = this.startNode();\n this.next();\n if (this.match(10) && !this.scope.allowDirectSuper) {\n if (!(this.optionFlags & 16)) {\n this.raise(Errors.SuperNotAllowed, node);\n }\n } else if (!this.scope.allowSuper) {\n if (!(this.optionFlags & 16)) {\n this.raise(Errors.UnexpectedSuper, node);\n }\n }\n if (!this.match(10) && !this.match(0) && !this.match(16)) {\n this.raise(Errors.UnsupportedSuper, node);\n }\n return this.finishNode(node, \"Super\");\n }\n parsePrivateName() {\n const node = this.startNode();\n const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));\n const name = this.state.value;\n this.next();\n node.id = this.createIdentifier(id, name);\n return this.finishNode(node, \"PrivateName\");\n }\n parseFunctionOrFunctionSent() {\n const node = this.startNode();\n this.next();\n if (this.prodParam.hasYield && this.match(16)) {\n const meta = this.createIdentifier(this.startNodeAtNode(node), \"function\");\n this.next();\n if (this.match(103)) {\n this.expectPlugin(\"functionSent\");\n } else if (!this.hasPlugin(\"functionSent\")) {\n this.unexpected();\n }\n return this.parseMetaProperty(node, meta, \"sent\");\n }\n return this.parseFunction(node);\n }\n parseMetaProperty(node, meta, propertyName) {\n node.meta = meta;\n const containsEsc = this.state.containsEsc;\n node.property = this.parseIdentifier(true);\n if (node.property.name !== propertyName || containsEsc) {\n this.raise(Errors.UnsupportedMetaProperty, node.property, {\n target: meta.name,\n onlyValidPropertyName: propertyName\n });\n }\n return this.finishNode(node, \"MetaProperty\");\n }\n parseImportMetaPropertyOrPhaseCall(node) {\n this.next();\n if (this.isContextual(105) || this.isContextual(97)) {\n const isSource = this.isContextual(105);\n this.expectPlugin(isSource ? \"sourcePhaseImports\" : \"deferredImportEvaluation\");\n this.next();\n node.phase = isSource ? \"source\" : \"defer\";\n return this.parseImportCall(node);\n } else {\n const id = this.createIdentifierAt(this.startNodeAtNode(node), \"import\", this.state.lastTokStartLoc);\n if (this.isContextual(101)) {\n if (!this.inModule) {\n this.raise(Errors.ImportMetaOutsideModule, id);\n }\n this.sawUnambiguousESM = true;\n }\n return this.parseMetaProperty(node, id, \"meta\");\n }\n }\n parseLiteralAtNode(value, type, node) {\n this.addExtra(node, \"rawValue\", value);\n this.addExtra(node, \"raw\", this.input.slice(this.offsetToSourcePos(node.start), this.state.end));\n node.value = value;\n this.next();\n return this.finishNode(node, type);\n }\n parseLiteral(value, type) {\n const node = this.startNode();\n return this.parseLiteralAtNode(value, type, node);\n }\n parseStringLiteral(value) {\n return this.parseLiteral(value, \"StringLiteral\");\n }\n parseNumericLiteral(value) {\n return this.parseLiteral(value, \"NumericLiteral\");\n }\n parseBigIntLiteral(value) {\n return this.parseLiteral(value, \"BigIntLiteral\");\n }\n parseDecimalLiteral(value) {\n return this.parseLiteral(value, \"DecimalLiteral\");\n }\n parseRegExpLiteral(value) {\n const node = this.startNode();\n this.addExtra(node, \"raw\", this.input.slice(this.offsetToSourcePos(node.start), this.state.end));\n node.pattern = value.pattern;\n node.flags = value.flags;\n this.next();\n return this.finishNode(node, \"RegExpLiteral\");\n }\n parseBooleanLiteral(value) {\n const node = this.startNode();\n node.value = value;\n this.next();\n return this.finishNode(node, \"BooleanLiteral\");\n }\n parseNullLiteral() {\n const node = this.startNode();\n this.next();\n return this.finishNode(node, \"NullLiteral\");\n }\n parseParenAndDistinguishExpression(canBeArrow) {\n const startLoc = this.state.startLoc;\n let val;\n this.next();\n this.expressionScope.enter(newArrowHeadScope());\n const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n this.state.maybeInArrowParameters = true;\n this.state.inFSharpPipelineDirectBody = false;\n const innerStartLoc = this.state.startLoc;\n const exprList = [];\n const refExpressionErrors = new ExpressionErrors();\n let first = true;\n let spreadStartLoc;\n let optionalCommaStartLoc;\n while (!this.match(11)) {\n if (first) {\n first = false;\n } else {\n this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);\n if (this.match(11)) {\n optionalCommaStartLoc = this.state.startLoc;\n break;\n }\n }\n if (this.match(21)) {\n const spreadNodeStartLoc = this.state.startLoc;\n spreadStartLoc = this.state.startLoc;\n exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));\n if (!this.checkCommaAfterRest(41)) {\n break;\n }\n } else {\n exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(11, refExpressionErrors, this.parseParenItem));\n }\n }\n const innerEndLoc = this.state.lastTokEndLoc;\n this.expect(11);\n this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n let arrowNode = this.startNodeAt(startLoc);\n if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {\n this.checkDestructuringPrivate(refExpressionErrors);\n this.expressionScope.validateAsPattern();\n this.expressionScope.exit();\n this.parseArrowExpression(arrowNode, exprList, false);\n return arrowNode;\n }\n this.expressionScope.exit();\n if (!exprList.length) {\n this.unexpected(this.state.lastTokStartLoc);\n }\n if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);\n if (spreadStartLoc) this.unexpected(spreadStartLoc);\n this.checkExpressionErrors(refExpressionErrors, true);\n this.toReferencedListDeep(exprList, true);\n if (exprList.length > 1) {\n val = this.startNodeAt(innerStartLoc);\n val.expressions = exprList;\n this.finishNode(val, \"SequenceExpression\");\n this.resetEndLocation(val, innerEndLoc);\n } else {\n val = exprList[0];\n }\n return this.wrapParenthesis(startLoc, val);\n }\n wrapParenthesis(startLoc, expression) {\n if (!(this.optionFlags & 1024)) {\n this.addExtra(expression, \"parenthesized\", true);\n this.addExtra(expression, \"parenStart\", startLoc.index);\n this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);\n return expression;\n }\n const parenExpression = this.startNodeAt(startLoc);\n parenExpression.expression = expression;\n return this.finishNode(parenExpression, \"ParenthesizedExpression\");\n }\n shouldParseArrow(params) {\n return !this.canInsertSemicolon();\n }\n parseArrow(node) {\n if (this.eat(19)) {\n return node;\n }\n }\n parseParenItem(node, startLoc) {\n return node;\n }\n parseNewOrNewTarget() {\n const node = this.startNode();\n this.next();\n if (this.match(16)) {\n const meta = this.createIdentifier(this.startNodeAtNode(node), \"new\");\n this.next();\n const metaProp = this.parseMetaProperty(node, meta, \"target\");\n if (!this.scope.allowNewTarget) {\n this.raise(Errors.UnexpectedNewTarget, metaProp);\n }\n return metaProp;\n }\n return this.parseNew(node);\n }\n parseNew(node) {\n this.parseNewCallee(node);\n if (this.eat(10)) {\n const args = this.parseExprList(11);\n this.toReferencedList(args);\n node.arguments = args;\n } else {\n node.arguments = [];\n }\n return this.finishNode(node, \"NewExpression\");\n }\n parseNewCallee(node) {\n const isImport = this.match(83);\n const callee = this.parseNoCallExpr();\n node.callee = callee;\n if (isImport && (callee.type === \"Import\" || callee.type === \"ImportExpression\")) {\n this.raise(Errors.ImportCallNotNewExpression, callee);\n }\n }\n parseTemplateElement(isTagged) {\n const {\n start,\n startLoc,\n end,\n value\n } = this.state;\n const elemStart = start + 1;\n const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));\n if (value === null) {\n if (!isTagged) {\n this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));\n }\n }\n const isTail = this.match(24);\n const endOffset = isTail ? -1 : -2;\n const elemEnd = end + endOffset;\n elem.value = {\n raw: this.input.slice(elemStart, elemEnd).replace(/\\r\\n?/g, \"\\n\"),\n cooked: value === null ? null : value.slice(1, endOffset)\n };\n elem.tail = isTail;\n this.next();\n const finishedNode = this.finishNode(elem, \"TemplateElement\");\n this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));\n return finishedNode;\n }\n parseTemplate(isTagged) {\n const node = this.startNode();\n let curElt = this.parseTemplateElement(isTagged);\n const quasis = [curElt];\n const substitutions = [];\n while (!curElt.tail) {\n substitutions.push(this.parseTemplateSubstitution());\n this.readTemplateContinuation();\n quasis.push(curElt = this.parseTemplateElement(isTagged));\n }\n node.expressions = substitutions;\n node.quasis = quasis;\n return this.finishNode(node, \"TemplateLiteral\");\n }\n parseTemplateSubstitution() {\n return this.parseExpression();\n }\n parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {\n if (isRecord) {\n this.expectPlugin(\"recordAndTuple\");\n }\n const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n this.state.inFSharpPipelineDirectBody = false;\n let sawProto = false;\n let first = true;\n const node = this.startNode();\n node.properties = [];\n this.next();\n while (!this.match(close)) {\n if (first) {\n first = false;\n } else {\n this.expect(12);\n if (this.match(close)) {\n this.addTrailingCommaExtraToNode(node);\n break;\n }\n }\n let prop;\n if (isPattern) {\n prop = this.parseBindingProperty();\n } else {\n prop = this.parsePropertyDefinition(refExpressionErrors);\n sawProto = this.checkProto(prop, isRecord, sawProto, refExpressionErrors);\n }\n if (isRecord && !this.isObjectProperty(prop) && prop.type !== \"SpreadElement\") {\n this.raise(Errors.InvalidRecordProperty, prop);\n }\n if (prop.shorthand) {\n this.addExtra(prop, \"shorthand\", true);\n }\n node.properties.push(prop);\n }\n this.next();\n this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n let type = \"ObjectExpression\";\n if (isPattern) {\n type = \"ObjectPattern\";\n } else if (isRecord) {\n type = \"RecordExpression\";\n }\n return this.finishNode(node, type);\n }\n addTrailingCommaExtraToNode(node) {\n this.addExtra(node, \"trailingComma\", this.state.lastTokStartLoc.index);\n this.addExtra(node, \"trailingCommaLoc\", this.state.lastTokStartLoc, false);\n }\n maybeAsyncOrAccessorProp(prop) {\n return !prop.computed && prop.key.type === \"Identifier\" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));\n }\n parsePropertyDefinition(refExpressionErrors) {\n let decorators = [];\n if (this.match(26)) {\n if (this.hasPlugin(\"decorators\")) {\n this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);\n }\n while (this.match(26)) {\n decorators.push(this.parseDecorator());\n }\n }\n const prop = this.startNode();\n let isAsync = false;\n let isAccessor = false;\n let startLoc;\n if (this.match(21)) {\n if (decorators.length) this.unexpected();\n return this.parseSpread();\n }\n if (decorators.length) {\n prop.decorators = decorators;\n decorators = [];\n }\n prop.method = false;\n if (refExpressionErrors) {\n startLoc = this.state.startLoc;\n }\n let isGenerator = this.eat(55);\n this.parsePropertyNamePrefixOperator(prop);\n const containsEsc = this.state.containsEsc;\n this.parsePropertyName(prop, refExpressionErrors);\n if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {\n const {\n key\n } = prop;\n const keyName = key.name;\n if (keyName === \"async\" && !this.hasPrecedingLineBreak()) {\n isAsync = true;\n this.resetPreviousNodeTrailingComments(key);\n isGenerator = this.eat(55);\n this.parsePropertyName(prop);\n }\n if (keyName === \"get\" || keyName === \"set\") {\n isAccessor = true;\n this.resetPreviousNodeTrailingComments(key);\n prop.kind = keyName;\n if (this.match(55)) {\n isGenerator = true;\n this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), {\n kind: keyName\n });\n this.next();\n }\n this.parsePropertyName(prop);\n }\n }\n return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);\n }\n getGetterSetterExpectedParamCount(method) {\n return method.kind === \"get\" ? 0 : 1;\n }\n getObjectOrClassMethodParams(method) {\n return method.params;\n }\n checkGetterSetterParams(method) {\n var _params;\n const paramCount = this.getGetterSetterExpectedParamCount(method);\n const params = this.getObjectOrClassMethodParams(method);\n if (params.length !== paramCount) {\n this.raise(method.kind === \"get\" ? Errors.BadGetterArity : Errors.BadSetterArity, method);\n }\n if (method.kind === \"set\" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === \"RestElement\") {\n this.raise(Errors.BadSetterRestParameter, method);\n }\n }\n parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {\n if (isAccessor) {\n const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, \"ObjectMethod\");\n this.checkGetterSetterParams(finishedProp);\n return finishedProp;\n }\n if (isAsync || isGenerator || this.match(10)) {\n if (isPattern) this.unexpected();\n prop.kind = \"method\";\n prop.method = true;\n return this.parseMethod(prop, isGenerator, isAsync, false, false, \"ObjectMethod\");\n }\n }\n parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {\n prop.shorthand = false;\n if (this.eat(14)) {\n prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, refExpressionErrors);\n return this.finishObjectProperty(prop);\n }\n if (!prop.computed && prop.key.type === \"Identifier\") {\n this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);\n if (isPattern) {\n prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));\n } else if (this.match(29)) {\n const shorthandAssignLoc = this.state.startLoc;\n if (refExpressionErrors != null) {\n if (refExpressionErrors.shorthandAssignLoc === null) {\n refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;\n }\n } else {\n this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);\n }\n prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));\n } else {\n prop.value = this.cloneIdentifier(prop.key);\n }\n prop.shorthand = true;\n return this.finishObjectProperty(prop);\n }\n }\n finishObjectProperty(node) {\n return this.finishNode(node, \"ObjectProperty\");\n }\n parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {\n const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);\n if (!node) this.unexpected();\n return node;\n }\n parsePropertyName(prop, refExpressionErrors) {\n if (this.eat(0)) {\n prop.computed = true;\n prop.key = this.parseMaybeAssignAllowIn();\n this.expect(3);\n } else {\n const {\n type,\n value\n } = this.state;\n let key;\n if (tokenIsKeywordOrIdentifier(type)) {\n key = this.parseIdentifier(true);\n } else {\n switch (type) {\n case 135:\n key = this.parseNumericLiteral(value);\n break;\n case 134:\n key = this.parseStringLiteral(value);\n break;\n case 136:\n key = this.parseBigIntLiteral(value);\n break;\n case 139:\n {\n const privateKeyLoc = this.state.startLoc;\n if (refExpressionErrors != null) {\n if (refExpressionErrors.privateKeyLoc === null) {\n refExpressionErrors.privateKeyLoc = privateKeyLoc;\n }\n } else {\n this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);\n }\n key = this.parsePrivateName();\n break;\n }\n default:\n if (type === 137) {\n key = this.parseDecimalLiteral(value);\n break;\n }\n this.unexpected();\n }\n }\n prop.key = key;\n if (type !== 139) {\n prop.computed = false;\n }\n }\n }\n initFunction(node, isAsync) {\n node.id = null;\n node.generator = false;\n node.async = isAsync;\n }\n parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {\n this.initFunction(node, isAsync);\n node.generator = isGenerator;\n this.scope.enter(514 | 16 | (inClassScope ? 576 : 0) | (allowDirectSuper ? 32 : 0));\n this.prodParam.enter(functionFlags(isAsync, node.generator));\n this.parseFunctionParams(node, isConstructor);\n const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);\n this.prodParam.exit();\n this.scope.exit();\n return finishedNode;\n }\n parseArrayLike(close, isTuple, refExpressionErrors) {\n if (isTuple) {\n this.expectPlugin(\"recordAndTuple\");\n }\n const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n this.state.inFSharpPipelineDirectBody = false;\n const node = this.startNode();\n this.next();\n node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);\n this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n return this.finishNode(node, isTuple ? \"TupleExpression\" : \"ArrayExpression\");\n }\n parseArrowExpression(node, params, isAsync, trailingCommaLoc) {\n this.scope.enter(514 | 4);\n let flags = functionFlags(isAsync, false);\n if (!this.match(5) && this.prodParam.hasIn) {\n flags |= 8;\n }\n this.prodParam.enter(flags);\n this.initFunction(node, isAsync);\n const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n if (params) {\n this.state.maybeInArrowParameters = true;\n this.setArrowFunctionParameters(node, params, trailingCommaLoc);\n }\n this.state.maybeInArrowParameters = false;\n this.parseFunctionBody(node, true);\n this.prodParam.exit();\n this.scope.exit();\n this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n return this.finishNode(node, \"ArrowFunctionExpression\");\n }\n setArrowFunctionParameters(node, params, trailingCommaLoc) {\n this.toAssignableList(params, trailingCommaLoc, false);\n node.params = params;\n }\n parseFunctionBodyAndFinish(node, type, isMethod = false) {\n this.parseFunctionBody(node, false, isMethod);\n return this.finishNode(node, type);\n }\n parseFunctionBody(node, allowExpression, isMethod = false) {\n const isExpression = allowExpression && !this.match(5);\n this.expressionScope.enter(newExpressionScope());\n if (isExpression) {\n node.body = this.parseMaybeAssign();\n this.checkParams(node, false, allowExpression, false);\n } else {\n const oldStrict = this.state.strict;\n const oldLabels = this.state.labels;\n this.state.labels = [];\n this.prodParam.enter(this.prodParam.currentFlags() | 4);\n node.body = this.parseBlock(true, false, hasStrictModeDirective => {\n const nonSimple = !this.isSimpleParamList(node.params);\n if (hasStrictModeDirective && nonSimple) {\n this.raise(Errors.IllegalLanguageModeDirective, (node.kind === \"method\" || node.kind === \"constructor\") && !!node.key ? node.key.loc.end : node);\n }\n const strictModeChanged = !oldStrict && this.state.strict;\n this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);\n if (this.state.strict && node.id) {\n this.checkIdentifier(node.id, 65, strictModeChanged);\n }\n });\n this.prodParam.exit();\n this.state.labels = oldLabels;\n }\n this.expressionScope.exit();\n }\n isSimpleParameter(node) {\n return node.type === \"Identifier\";\n }\n isSimpleParamList(params) {\n for (let i = 0, len = params.length; i < len; i++) {\n if (!this.isSimpleParameter(params[i])) return false;\n }\n return true;\n }\n checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {\n const checkClashes = !allowDuplicates && new Set();\n const formalParameters = {\n type: \"FormalParameters\"\n };\n for (const param of node.params) {\n this.checkLVal(param, formalParameters, 5, checkClashes, strictModeChanged);\n }\n }\n parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {\n const elts = [];\n let first = true;\n while (!this.eat(close)) {\n if (first) {\n first = false;\n } else {\n this.expect(12);\n if (this.match(close)) {\n if (nodeForExtra) {\n this.addTrailingCommaExtraToNode(nodeForExtra);\n }\n this.next();\n break;\n }\n }\n elts.push(this.parseExprListItem(close, allowEmpty, refExpressionErrors));\n }\n return elts;\n }\n parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) {\n let elt;\n if (this.match(12)) {\n if (!allowEmpty) {\n this.raise(Errors.UnexpectedToken, this.state.curPosition(), {\n unexpected: \",\"\n });\n }\n elt = null;\n } else if (this.match(21)) {\n const spreadNodeStartLoc = this.state.startLoc;\n elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);\n } else if (this.match(17)) {\n this.expectPlugin(\"partialApplication\");\n if (!allowPlaceholder) {\n this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);\n }\n const node = this.startNode();\n this.next();\n elt = this.finishNode(node, \"ArgumentPlaceholder\");\n } else {\n elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, this.parseParenItem);\n }\n return elt;\n }\n parseIdentifier(liberal) {\n const node = this.startNode();\n const name = this.parseIdentifierName(liberal);\n return this.createIdentifier(node, name);\n }\n createIdentifier(node, name) {\n node.name = name;\n node.loc.identifierName = name;\n return this.finishNode(node, \"Identifier\");\n }\n createIdentifierAt(node, name, endLoc) {\n node.name = name;\n node.loc.identifierName = name;\n return this.finishNodeAt(node, \"Identifier\", endLoc);\n }\n parseIdentifierName(liberal) {\n let name;\n const {\n startLoc,\n type\n } = this.state;\n if (tokenIsKeywordOrIdentifier(type)) {\n name = this.state.value;\n } else {\n this.unexpected();\n }\n const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);\n if (liberal) {\n if (tokenIsKeyword) {\n this.replaceToken(132);\n }\n } else {\n this.checkReservedWord(name, startLoc, tokenIsKeyword, false);\n }\n this.next();\n return name;\n }\n checkReservedWord(word, startLoc, checkKeywords, isBinding) {\n if (word.length > 10) {\n return;\n }\n if (!canBeReservedWord(word)) {\n return;\n }\n if (checkKeywords && isKeyword(word)) {\n this.raise(Errors.UnexpectedKeyword, startLoc, {\n keyword: word\n });\n return;\n }\n const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;\n if (reservedTest(word, this.inModule)) {\n this.raise(Errors.UnexpectedReservedWord, startLoc, {\n reservedWord: word\n });\n return;\n } else if (word === \"yield\") {\n if (this.prodParam.hasYield) {\n this.raise(Errors.YieldBindingIdentifier, startLoc);\n return;\n }\n } else if (word === \"await\") {\n if (this.prodParam.hasAwait) {\n this.raise(Errors.AwaitBindingIdentifier, startLoc);\n return;\n }\n if (this.scope.inStaticBlock) {\n this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);\n return;\n }\n this.expressionScope.recordAsyncArrowParametersError(startLoc);\n } else if (word === \"arguments\") {\n if (this.scope.inClassAndNotInNonArrowFunction) {\n this.raise(Errors.ArgumentsInClass, startLoc);\n return;\n }\n }\n }\n recordAwaitIfAllowed() {\n const isAwaitAllowed = this.prodParam.hasAwait;\n if (isAwaitAllowed && !this.scope.inFunction) {\n this.state.hasTopLevelAwait = true;\n }\n return isAwaitAllowed;\n }\n parseAwait(startLoc) {\n const node = this.startNodeAt(startLoc);\n this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);\n if (this.eat(55)) {\n this.raise(Errors.ObsoleteAwaitStar, node);\n }\n if (!this.scope.inFunction && !(this.optionFlags & 1)) {\n if (this.isAmbiguousPrefixOrIdentifier()) {\n this.ambiguousScriptDifferentAst = true;\n } else {\n this.sawUnambiguousESM = true;\n }\n }\n if (!this.state.soloAwait) {\n node.argument = this.parseMaybeUnary(null, true);\n }\n return this.finishNode(node, \"AwaitExpression\");\n }\n isAmbiguousPrefixOrIdentifier() {\n if (this.hasPrecedingLineBreak()) return true;\n const {\n type\n } = this.state;\n return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 102 && !this.state.containsEsc || type === 138 || type === 56 || this.hasPlugin(\"v8intrinsic\") && type === 54;\n }\n parseYield(startLoc) {\n const node = this.startNodeAt(startLoc);\n this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);\n let delegating = false;\n let argument = null;\n if (!this.hasPrecedingLineBreak()) {\n delegating = this.eat(55);\n switch (this.state.type) {\n case 13:\n case 140:\n case 8:\n case 11:\n case 3:\n case 9:\n case 14:\n case 12:\n if (!delegating) break;\n default:\n argument = this.parseMaybeAssign();\n }\n }\n node.delegate = delegating;\n node.argument = argument;\n return this.finishNode(node, \"YieldExpression\");\n }\n parseImportCall(node) {\n this.next();\n node.source = this.parseMaybeAssignAllowIn();\n node.options = null;\n if (this.eat(12)) {\n if (!this.match(11)) {\n node.options = this.parseMaybeAssignAllowIn();\n if (this.eat(12)) {\n this.addTrailingCommaExtraToNode(node.options);\n if (!this.match(11)) {\n do {\n this.parseMaybeAssignAllowIn();\n } while (this.eat(12) && !this.match(11));\n this.raise(Errors.ImportCallArity, node);\n }\n }\n } else {\n this.addTrailingCommaExtraToNode(node.source);\n }\n }\n this.expect(11);\n return this.finishNode(node, \"ImportExpression\");\n }\n checkPipelineAtInfixOperator(left, leftStartLoc) {\n if (this.hasPlugin([\"pipelineOperator\", {\n proposal: \"smart\"\n }])) {\n if (left.type === \"SequenceExpression\") {\n this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);\n }\n }\n }\n parseSmartPipelineBodyInStyle(childExpr, startLoc) {\n if (this.isSimpleReference(childExpr)) {\n const bodyNode = this.startNodeAt(startLoc);\n bodyNode.callee = childExpr;\n return this.finishNode(bodyNode, \"PipelineBareFunction\");\n } else {\n const bodyNode = this.startNodeAt(startLoc);\n this.checkSmartPipeTopicBodyEarlyErrors(startLoc);\n bodyNode.expression = childExpr;\n return this.finishNode(bodyNode, \"PipelineTopicExpression\");\n }\n }\n isSimpleReference(expression) {\n switch (expression.type) {\n case \"MemberExpression\":\n return !expression.computed && this.isSimpleReference(expression.object);\n case \"Identifier\":\n return true;\n default:\n return false;\n }\n }\n checkSmartPipeTopicBodyEarlyErrors(startLoc) {\n if (this.match(19)) {\n throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc);\n }\n if (!this.topicReferenceWasUsedInCurrentContext()) {\n this.raise(Errors.PipelineTopicUnused, startLoc);\n }\n }\n withTopicBindingContext(callback) {\n const outerContextTopicState = this.state.topicContext;\n this.state.topicContext = {\n maxNumOfResolvableTopics: 1,\n maxTopicIndex: null\n };\n try {\n return callback();\n } finally {\n this.state.topicContext = outerContextTopicState;\n }\n }\n withSmartMixTopicForbiddingContext(callback) {\n if (this.hasPlugin([\"pipelineOperator\", {\n proposal: \"smart\"\n }])) {\n const outerContextTopicState = this.state.topicContext;\n this.state.topicContext = {\n maxNumOfResolvableTopics: 0,\n maxTopicIndex: null\n };\n try {\n return callback();\n } finally {\n this.state.topicContext = outerContextTopicState;\n }\n } else {\n return callback();\n }\n }\n withSoloAwaitPermittingContext(callback) {\n const outerContextSoloAwaitState = this.state.soloAwait;\n this.state.soloAwait = true;\n try {\n return callback();\n } finally {\n this.state.soloAwait = outerContextSoloAwaitState;\n }\n }\n allowInAnd(callback) {\n const flags = this.prodParam.currentFlags();\n const prodParamToSet = 8 & ~flags;\n if (prodParamToSet) {\n this.prodParam.enter(flags | 8);\n try {\n return callback();\n } finally {\n this.prodParam.exit();\n }\n }\n return callback();\n }\n disallowInAnd(callback) {\n const flags = this.prodParam.currentFlags();\n const prodParamToClear = 8 & flags;\n if (prodParamToClear) {\n this.prodParam.enter(flags & ~8);\n try {\n return callback();\n } finally {\n this.prodParam.exit();\n }\n }\n return callback();\n }\n registerTopicReference() {\n this.state.topicContext.maxTopicIndex = 0;\n }\n topicReferenceIsAllowedInCurrentContext() {\n return this.state.topicContext.maxNumOfResolvableTopics >= 1;\n }\n topicReferenceWasUsedInCurrentContext() {\n return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;\n }\n parseFSharpPipelineBody(prec) {\n const startLoc = this.state.startLoc;\n this.state.potentialArrowAt = this.state.start;\n const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;\n this.state.inFSharpPipelineDirectBody = true;\n const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);\n this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;\n return ret;\n }\n parseModuleExpression() {\n this.expectPlugin(\"moduleBlocks\");\n const node = this.startNode();\n this.next();\n if (!this.match(5)) {\n this.unexpected(null, 5);\n }\n const program = this.startNodeAt(this.state.endLoc);\n this.next();\n const revertScopes = this.initializeScopes(true);\n this.enterInitialScopes();\n try {\n node.body = this.parseProgram(program, 8, \"module\");\n } finally {\n revertScopes();\n }\n return this.finishNode(node, \"ModuleExpression\");\n }\n parseVoidPattern(refExpressionErrors) {\n this.expectPlugin(\"discardBinding\");\n const node = this.startNode();\n if (refExpressionErrors != null) {\n refExpressionErrors.voidPatternLoc = this.state.startLoc;\n }\n this.next();\n return this.finishNode(node, \"VoidPattern\");\n }\n parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) {\n if (refExpressionErrors != null && this.match(88)) {\n const nextCode = this.lookaheadCharCode();\n if (nextCode === 44 || nextCode === (close === 3 ? 93 : close === 8 ? 125 : 41) || nextCode === 61) {\n return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors));\n }\n }\n return this.parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse);\n }\n parsePropertyNamePrefixOperator(prop) {}\n}\nconst loopLabel = {\n kind: 1\n },\n switchLabel = {\n kind: 2\n };\nconst loneSurrogate = /[\\uD800-\\uDFFF]/u;\nconst keywordRelationalOperator = /in(?:stanceof)?/y;\nfunction babel7CompatTokens(tokens, input, startIndex) {\n for (let i = 0; i < tokens.length; i++) {\n const token = tokens[i];\n const {\n type\n } = token;\n if (typeof type === \"number\") {\n if (type === 139) {\n const {\n loc,\n start,\n value,\n end\n } = token;\n const hashEndPos = start + 1;\n const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);\n tokens.splice(i, 1, new Token({\n type: getExportedToken(27),\n value: \"#\",\n start: start,\n end: hashEndPos,\n startLoc: loc.start,\n endLoc: hashEndLoc\n }), new Token({\n type: getExportedToken(132),\n value: value,\n start: hashEndPos,\n end: end,\n startLoc: hashEndLoc,\n endLoc: loc.end\n }));\n i++;\n continue;\n }\n if (tokenIsTemplate(type)) {\n const {\n loc,\n start,\n value,\n end\n } = token;\n const backquoteEnd = start + 1;\n const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);\n let startToken;\n if (input.charCodeAt(start - startIndex) === 96) {\n startToken = new Token({\n type: getExportedToken(22),\n value: \"`\",\n start: start,\n end: backquoteEnd,\n startLoc: loc.start,\n endLoc: backquoteEndLoc\n });\n } else {\n startToken = new Token({\n type: getExportedToken(8),\n value: \"}\",\n start: start,\n end: backquoteEnd,\n startLoc: loc.start,\n endLoc: backquoteEndLoc\n });\n }\n let templateValue, templateElementEnd, templateElementEndLoc, endToken;\n if (type === 24) {\n templateElementEnd = end - 1;\n templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);\n templateValue = value === null ? null : value.slice(1, -1);\n endToken = new Token({\n type: getExportedToken(22),\n value: \"`\",\n start: templateElementEnd,\n end: end,\n startLoc: templateElementEndLoc,\n endLoc: loc.end\n });\n } else {\n templateElementEnd = end - 2;\n templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);\n templateValue = value === null ? null : value.slice(1, -2);\n endToken = new Token({\n type: getExportedToken(23),\n value: \"${\",\n start: templateElementEnd,\n end: end,\n startLoc: templateElementEndLoc,\n endLoc: loc.end\n });\n }\n tokens.splice(i, 1, startToken, new Token({\n type: getExportedToken(20),\n value: templateValue,\n start: backquoteEnd,\n end: templateElementEnd,\n startLoc: backquoteEndLoc,\n endLoc: templateElementEndLoc\n }), endToken);\n i += 2;\n continue;\n }\n token.type = getExportedToken(type);\n }\n }\n return tokens;\n}\nclass StatementParser extends ExpressionParser {\n parseTopLevel(file, program) {\n file.program = this.parseProgram(program, 140, this.options.sourceType === \"module\" ? \"module\" : \"script\");\n file.comments = this.comments;\n if (this.optionFlags & 256) {\n file.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex);\n }\n return this.finishNode(file, \"File\");\n }\n parseProgram(program, end, sourceType) {\n program.sourceType = sourceType;\n program.interpreter = this.parseInterpreterDirective();\n this.parseBlockBody(program, true, true, end);\n if (this.inModule) {\n if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) {\n for (const [localName, at] of Array.from(this.scope.undefinedExports)) {\n this.raise(Errors.ModuleExportUndefined, at, {\n localName\n });\n }\n }\n this.addExtra(program, \"topLevelAwait\", this.state.hasTopLevelAwait);\n }\n let finishedProgram;\n if (end === 140) {\n finishedProgram = this.finishNode(program, \"Program\");\n } else {\n finishedProgram = this.finishNodeAt(program, \"Program\", createPositionWithColumnOffset(this.state.startLoc, -1));\n }\n return finishedProgram;\n }\n stmtToDirective(stmt) {\n const directive = this.castNodeTo(stmt, \"Directive\");\n const directiveLiteral = this.castNodeTo(stmt.expression, \"DirectiveLiteral\");\n const expressionValue = directiveLiteral.value;\n const raw = this.input.slice(this.offsetToSourcePos(directiveLiteral.start), this.offsetToSourcePos(directiveLiteral.end));\n const val = directiveLiteral.value = raw.slice(1, -1);\n this.addExtra(directiveLiteral, \"raw\", raw);\n this.addExtra(directiveLiteral, \"rawValue\", val);\n this.addExtra(directiveLiteral, \"expressionValue\", expressionValue);\n directive.value = directiveLiteral;\n delete stmt.expression;\n return directive;\n }\n parseInterpreterDirective() {\n if (!this.match(28)) {\n return null;\n }\n const node = this.startNode();\n node.value = this.state.value;\n this.next();\n return this.finishNode(node, \"InterpreterDirective\");\n }\n isLet() {\n if (!this.isContextual(100)) {\n return false;\n }\n return this.hasFollowingBindingAtom();\n }\n isUsing() {\n if (!this.isContextual(107)) {\n return false;\n }\n return this.nextTokenIsIdentifierOnSameLine();\n }\n isForUsing() {\n if (!this.isContextual(107)) {\n return false;\n }\n const next = this.nextTokenInLineStart();\n const nextCh = this.codePointAtPos(next);\n if (this.isUnparsedContextual(next, \"of\")) {\n const nextCharAfterOf = this.lookaheadCharCodeSince(next + 2);\n if (nextCharAfterOf !== 61 && nextCharAfterOf !== 58 && nextCharAfterOf !== 59) {\n return false;\n }\n }\n if (this.chStartsBindingIdentifier(nextCh, next) || this.isUnparsedContextual(next, \"void\")) {\n return true;\n }\n return false;\n }\n nextTokenIsIdentifierOnSameLine() {\n const next = this.nextTokenInLineStart();\n const nextCh = this.codePointAtPos(next);\n return this.chStartsBindingIdentifier(nextCh, next);\n }\n isAwaitUsing() {\n if (!this.isContextual(96)) {\n return false;\n }\n let next = this.nextTokenInLineStart();\n if (this.isUnparsedContextual(next, \"using\")) {\n next = this.nextTokenInLineStartSince(next + 5);\n const nextCh = this.codePointAtPos(next);\n if (this.chStartsBindingIdentifier(nextCh, next)) {\n return true;\n }\n }\n return false;\n }\n chStartsBindingIdentifier(ch, pos) {\n if (isIdentifierStart(ch)) {\n keywordRelationalOperator.lastIndex = pos;\n if (keywordRelationalOperator.test(this.input)) {\n const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);\n if (!isIdentifierChar(endCh) && endCh !== 92) {\n return false;\n }\n }\n return true;\n } else if (ch === 92) {\n return true;\n } else {\n return false;\n }\n }\n chStartsBindingPattern(ch) {\n return ch === 91 || ch === 123;\n }\n hasFollowingBindingAtom() {\n const next = this.nextTokenStart();\n const nextCh = this.codePointAtPos(next);\n return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);\n }\n hasInLineFollowingBindingIdentifierOrBrace() {\n const next = this.nextTokenInLineStart();\n const nextCh = this.codePointAtPos(next);\n return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next);\n }\n allowsUsing() {\n return (this.scope.inModule || !this.scope.inTopLevel) && !this.scope.inBareCaseStatement;\n }\n parseModuleItem() {\n return this.parseStatementLike(1 | 2 | 4 | 8);\n }\n parseStatementListItem() {\n return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));\n }\n parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {\n let flags = 0;\n if (this.options.annexB && !this.state.strict) {\n flags |= 4;\n if (allowLabeledFunction) {\n flags |= 8;\n }\n }\n return this.parseStatementLike(flags);\n }\n parseStatement() {\n return this.parseStatementLike(0);\n }\n parseStatementLike(flags) {\n let decorators = null;\n if (this.match(26)) {\n decorators = this.parseDecorators(true);\n }\n return this.parseStatementContent(flags, decorators);\n }\n parseStatementContent(flags, decorators) {\n const startType = this.state.type;\n const node = this.startNode();\n const allowDeclaration = !!(flags & 2);\n const allowFunctionDeclaration = !!(flags & 4);\n const topLevel = flags & 1;\n switch (startType) {\n case 60:\n return this.parseBreakContinueStatement(node, true);\n case 63:\n return this.parseBreakContinueStatement(node, false);\n case 64:\n return this.parseDebuggerStatement(node);\n case 90:\n return this.parseDoWhileStatement(node);\n case 91:\n return this.parseForStatement(node);\n case 68:\n if (this.lookaheadCharCode() === 46) break;\n if (!allowFunctionDeclaration) {\n this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc);\n }\n return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);\n case 80:\n if (!allowDeclaration) this.unexpected();\n return this.parseClass(this.maybeTakeDecorators(decorators, node), true);\n case 69:\n return this.parseIfStatement(node);\n case 70:\n return this.parseReturnStatement(node);\n case 71:\n return this.parseSwitchStatement(node);\n case 72:\n return this.parseThrowStatement(node);\n case 73:\n return this.parseTryStatement(node);\n case 96:\n if (this.isAwaitUsing()) {\n if (!this.allowsUsing()) {\n this.raise(Errors.UnexpectedUsingDeclaration, node);\n } else if (!allowDeclaration) {\n this.raise(Errors.UnexpectedLexicalDeclaration, node);\n } else if (!this.recordAwaitIfAllowed()) {\n this.raise(Errors.AwaitUsingNotInAsyncContext, node);\n }\n this.next();\n return this.parseVarStatement(node, \"await using\");\n }\n break;\n case 107:\n if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) {\n break;\n }\n if (!this.allowsUsing()) {\n this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);\n } else if (!allowDeclaration) {\n this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);\n }\n return this.parseVarStatement(node, \"using\");\n case 100:\n {\n if (this.state.containsEsc) {\n break;\n }\n const next = this.nextTokenStart();\n const nextCh = this.codePointAtPos(next);\n if (nextCh !== 91) {\n if (!allowDeclaration && this.hasFollowingLineBreak()) break;\n if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {\n break;\n }\n }\n }\n case 75:\n {\n if (!allowDeclaration) {\n this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);\n }\n }\n case 74:\n {\n const kind = this.state.value;\n return this.parseVarStatement(node, kind);\n }\n case 92:\n return this.parseWhileStatement(node);\n case 76:\n return this.parseWithStatement(node);\n case 5:\n return this.parseBlock();\n case 13:\n return this.parseEmptyStatement(node);\n case 83:\n {\n const nextTokenCharCode = this.lookaheadCharCode();\n if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {\n break;\n }\n }\n case 82:\n {\n if (!(this.optionFlags & 8) && !topLevel) {\n this.raise(Errors.UnexpectedImportExport, this.state.startLoc);\n }\n this.next();\n let result;\n if (startType === 83) {\n result = this.parseImport(node);\n } else {\n result = this.parseExport(node, decorators);\n }\n this.assertModuleNodeAllowed(result);\n return result;\n }\n default:\n {\n if (this.isAsyncFunction()) {\n if (!allowDeclaration) {\n this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc);\n }\n this.next();\n return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);\n }\n }\n }\n const maybeName = this.state.value;\n const expr = this.parseExpression();\n if (tokenIsIdentifier(startType) && expr.type === \"Identifier\" && this.eat(14)) {\n return this.parseLabeledStatement(node, maybeName, expr, flags);\n } else {\n return this.parseExpressionStatement(node, expr, decorators);\n }\n }\n assertModuleNodeAllowed(node) {\n if (!(this.optionFlags & 8) && !this.inModule) {\n this.raise(Errors.ImportOutsideModule, node);\n }\n }\n decoratorsEnabledBeforeExport() {\n if (this.hasPlugin(\"decorators-legacy\")) return true;\n return this.hasPlugin(\"decorators\") && this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== false;\n }\n maybeTakeDecorators(maybeDecorators, classNode, exportNode) {\n if (maybeDecorators) {\n var _classNode$decorators;\n if ((_classNode$decorators = classNode.decorators) != null && _classNode$decorators.length) {\n if (typeof this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") !== \"boolean\") {\n this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);\n }\n classNode.decorators.unshift(...maybeDecorators);\n } else {\n classNode.decorators = maybeDecorators;\n }\n this.resetStartLocationFromNode(classNode, maybeDecorators[0]);\n if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);\n }\n return classNode;\n }\n canHaveLeadingDecorator() {\n return this.match(80);\n }\n parseDecorators(allowExport) {\n const decorators = [];\n do {\n decorators.push(this.parseDecorator());\n } while (this.match(26));\n if (this.match(82)) {\n if (!allowExport) {\n this.unexpected();\n }\n if (!this.decoratorsEnabledBeforeExport()) {\n this.raise(Errors.DecoratorExportClass, this.state.startLoc);\n }\n } else if (!this.canHaveLeadingDecorator()) {\n throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);\n }\n return decorators;\n }\n parseDecorator() {\n this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n const node = this.startNode();\n this.next();\n if (this.hasPlugin(\"decorators\")) {\n const startLoc = this.state.startLoc;\n let expr;\n if (this.match(10)) {\n const startLoc = this.state.startLoc;\n this.next();\n expr = this.parseExpression();\n this.expect(11);\n expr = this.wrapParenthesis(startLoc, expr);\n const paramsStartLoc = this.state.startLoc;\n node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);\n if (this.getPluginOption(\"decorators\", \"allowCallParenthesized\") === false && node.expression !== expr) {\n this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);\n }\n } else {\n expr = this.parseIdentifier(false);\n while (this.eat(16)) {\n const node = this.startNodeAt(startLoc);\n node.object = expr;\n if (this.match(139)) {\n this.classScope.usePrivateName(this.state.value, this.state.startLoc);\n node.property = this.parsePrivateName();\n } else {\n node.property = this.parseIdentifier(true);\n }\n node.computed = false;\n expr = this.finishNode(node, \"MemberExpression\");\n }\n node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);\n }\n } else {\n node.expression = this.parseExprSubscripts();\n }\n return this.finishNode(node, \"Decorator\");\n }\n parseMaybeDecoratorArguments(expr, startLoc) {\n if (this.eat(10)) {\n const node = this.startNodeAt(startLoc);\n node.callee = expr;\n node.arguments = this.parseCallExpressionArguments();\n this.toReferencedList(node.arguments);\n return this.finishNode(node, \"CallExpression\");\n }\n return expr;\n }\n parseBreakContinueStatement(node, isBreak) {\n this.next();\n if (this.isLineTerminator()) {\n node.label = null;\n } else {\n node.label = this.parseIdentifier();\n this.semicolon();\n }\n this.verifyBreakContinue(node, isBreak);\n return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\");\n }\n verifyBreakContinue(node, isBreak) {\n let i;\n for (i = 0; i < this.state.labels.length; ++i) {\n const lab = this.state.labels[i];\n if (node.label == null || lab.name === node.label.name) {\n if (lab.kind != null && (isBreak || lab.kind === 1)) {\n break;\n }\n if (node.label && isBreak) break;\n }\n }\n if (i === this.state.labels.length) {\n const type = isBreak ? \"BreakStatement\" : \"ContinueStatement\";\n this.raise(Errors.IllegalBreakContinue, node, {\n type\n });\n }\n }\n parseDebuggerStatement(node) {\n this.next();\n this.semicolon();\n return this.finishNode(node, \"DebuggerStatement\");\n }\n parseHeaderExpression() {\n this.expect(10);\n const val = this.parseExpression();\n this.expect(11);\n return val;\n }\n parseDoWhileStatement(node) {\n this.next();\n this.state.labels.push(loopLabel);\n node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n this.state.labels.pop();\n this.expect(92);\n node.test = this.parseHeaderExpression();\n this.eat(13);\n return this.finishNode(node, \"DoWhileStatement\");\n }\n parseForStatement(node) {\n this.next();\n this.state.labels.push(loopLabel);\n let awaitAt = null;\n if (this.isContextual(96) && this.recordAwaitIfAllowed()) {\n awaitAt = this.state.startLoc;\n this.next();\n }\n this.scope.enter(0);\n this.expect(10);\n if (this.match(13)) {\n if (awaitAt !== null) {\n this.unexpected(awaitAt);\n }\n return this.parseFor(node, null);\n }\n const startsWithLet = this.isContextual(100);\n {\n const startsWithAwaitUsing = this.isAwaitUsing();\n const starsWithUsingDeclaration = startsWithAwaitUsing || this.isForUsing();\n const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;\n if (this.match(74) || this.match(75) || isLetOrUsing) {\n const initNode = this.startNode();\n let kind;\n if (startsWithAwaitUsing) {\n kind = \"await using\";\n if (!this.recordAwaitIfAllowed()) {\n this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc);\n }\n this.next();\n } else {\n kind = this.state.value;\n }\n this.next();\n this.parseVar(initNode, true, kind);\n const init = this.finishNode(initNode, \"VariableDeclaration\");\n const isForIn = this.match(58);\n if (isForIn && starsWithUsingDeclaration) {\n this.raise(Errors.ForInUsing, init);\n }\n if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) {\n return this.parseForIn(node, init, awaitAt);\n }\n if (awaitAt !== null) {\n this.unexpected(awaitAt);\n }\n return this.parseFor(node, init);\n }\n }\n const startsWithAsync = this.isContextual(95);\n const refExpressionErrors = new ExpressionErrors();\n const init = this.parseExpression(true, refExpressionErrors);\n const isForOf = this.isContextual(102);\n if (isForOf) {\n if (startsWithLet) {\n this.raise(Errors.ForOfLet, init);\n }\n if (awaitAt === null && startsWithAsync && init.type === \"Identifier\") {\n this.raise(Errors.ForOfAsync, init);\n }\n }\n if (isForOf || this.match(58)) {\n this.checkDestructuringPrivate(refExpressionErrors);\n this.toAssignable(init, true);\n const type = isForOf ? \"ForOfStatement\" : \"ForInStatement\";\n this.checkLVal(init, {\n type\n });\n return this.parseForIn(node, init, awaitAt);\n } else {\n this.checkExpressionErrors(refExpressionErrors, true);\n }\n if (awaitAt !== null) {\n this.unexpected(awaitAt);\n }\n return this.parseFor(node, init);\n }\n parseFunctionStatement(node, isAsync, isHangingDeclaration) {\n this.next();\n return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));\n }\n parseIfStatement(node) {\n this.next();\n node.test = this.parseHeaderExpression();\n node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();\n node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;\n return this.finishNode(node, \"IfStatement\");\n }\n parseReturnStatement(node) {\n if (!this.prodParam.hasReturn) {\n this.raise(Errors.IllegalReturn, this.state.startLoc);\n }\n this.next();\n if (this.isLineTerminator()) {\n node.argument = null;\n } else {\n node.argument = this.parseExpression();\n this.semicolon();\n }\n return this.finishNode(node, \"ReturnStatement\");\n }\n parseSwitchStatement(node) {\n this.next();\n node.discriminant = this.parseHeaderExpression();\n const cases = node.cases = [];\n this.expect(5);\n this.state.labels.push(switchLabel);\n this.scope.enter(256);\n let cur;\n for (let sawDefault; !this.match(8);) {\n if (this.match(61) || this.match(65)) {\n const isCase = this.match(61);\n if (cur) this.finishNode(cur, \"SwitchCase\");\n cases.push(cur = this.startNode());\n cur.consequent = [];\n this.next();\n if (isCase) {\n cur.test = this.parseExpression();\n } else {\n if (sawDefault) {\n this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);\n }\n sawDefault = true;\n cur.test = null;\n }\n this.expect(14);\n } else {\n if (cur) {\n cur.consequent.push(this.parseStatementListItem());\n } else {\n this.unexpected();\n }\n }\n }\n this.scope.exit();\n if (cur) this.finishNode(cur, \"SwitchCase\");\n this.next();\n this.state.labels.pop();\n return this.finishNode(node, \"SwitchStatement\");\n }\n parseThrowStatement(node) {\n this.next();\n if (this.hasPrecedingLineBreak()) {\n this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc);\n }\n node.argument = this.parseExpression();\n this.semicolon();\n return this.finishNode(node, \"ThrowStatement\");\n }\n parseCatchClauseParam() {\n const param = this.parseBindingAtom();\n this.scope.enter(this.options.annexB && param.type === \"Identifier\" ? 8 : 0);\n this.checkLVal(param, {\n type: \"CatchClause\"\n }, 9);\n return param;\n }\n parseTryStatement(node) {\n this.next();\n node.block = this.parseBlock();\n node.handler = null;\n if (this.match(62)) {\n const clause = this.startNode();\n this.next();\n if (this.match(10)) {\n this.expect(10);\n clause.param = this.parseCatchClauseParam();\n this.expect(11);\n } else {\n clause.param = null;\n this.scope.enter(0);\n }\n clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));\n this.scope.exit();\n node.handler = this.finishNode(clause, \"CatchClause\");\n }\n node.finalizer = this.eat(67) ? this.parseBlock() : null;\n if (!node.handler && !node.finalizer) {\n this.raise(Errors.NoCatchOrFinally, node);\n }\n return this.finishNode(node, \"TryStatement\");\n }\n parseVarStatement(node, kind, allowMissingInitializer = false) {\n this.next();\n this.parseVar(node, false, kind, allowMissingInitializer);\n this.semicolon();\n return this.finishNode(node, \"VariableDeclaration\");\n }\n parseWhileStatement(node) {\n this.next();\n node.test = this.parseHeaderExpression();\n this.state.labels.push(loopLabel);\n node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n this.state.labels.pop();\n return this.finishNode(node, \"WhileStatement\");\n }\n parseWithStatement(node) {\n if (this.state.strict) {\n this.raise(Errors.StrictWith, this.state.startLoc);\n }\n this.next();\n node.object = this.parseHeaderExpression();\n node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n return this.finishNode(node, \"WithStatement\");\n }\n parseEmptyStatement(node) {\n this.next();\n return this.finishNode(node, \"EmptyStatement\");\n }\n parseLabeledStatement(node, maybeName, expr, flags) {\n for (const label of this.state.labels) {\n if (label.name === maybeName) {\n this.raise(Errors.LabelRedeclaration, expr, {\n labelName: maybeName\n });\n }\n }\n const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null;\n for (let i = this.state.labels.length - 1; i >= 0; i--) {\n const label = this.state.labels[i];\n if (label.statementStart === node.start) {\n label.statementStart = this.sourceToOffsetPos(this.state.start);\n label.kind = kind;\n } else {\n break;\n }\n }\n this.state.labels.push({\n name: maybeName,\n kind: kind,\n statementStart: this.sourceToOffsetPos(this.state.start)\n });\n node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();\n this.state.labels.pop();\n node.label = expr;\n return this.finishNode(node, \"LabeledStatement\");\n }\n parseExpressionStatement(node, expr, decorators) {\n node.expression = expr;\n this.semicolon();\n return this.finishNode(node, \"ExpressionStatement\");\n }\n parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {\n const node = this.startNode();\n if (allowDirectives) {\n this.state.strictErrors.clear();\n }\n this.expect(5);\n if (createNewLexicalScope) {\n this.scope.enter(0);\n }\n this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);\n if (createNewLexicalScope) {\n this.scope.exit();\n }\n return this.finishNode(node, \"BlockStatement\");\n }\n isValidDirective(stmt) {\n return stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"StringLiteral\" && !stmt.expression.extra.parenthesized;\n }\n parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {\n const body = node.body = [];\n const directives = node.directives = [];\n this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);\n }\n parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {\n const oldStrict = this.state.strict;\n let hasStrictModeDirective = false;\n let parsedNonDirective = false;\n while (!this.match(end)) {\n const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();\n if (directives && !parsedNonDirective) {\n if (this.isValidDirective(stmt)) {\n const directive = this.stmtToDirective(stmt);\n directives.push(directive);\n if (!hasStrictModeDirective && directive.value.value === \"use strict\") {\n hasStrictModeDirective = true;\n this.setStrict(true);\n }\n continue;\n }\n parsedNonDirective = true;\n this.state.strictErrors.clear();\n }\n body.push(stmt);\n }\n afterBlockParse == null || afterBlockParse.call(this, hasStrictModeDirective);\n if (!oldStrict) {\n this.setStrict(false);\n }\n this.next();\n }\n parseFor(node, init) {\n node.init = init;\n this.semicolon(false);\n node.test = this.match(13) ? null : this.parseExpression();\n this.semicolon(false);\n node.update = this.match(11) ? null : this.parseExpression();\n this.expect(11);\n node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n this.scope.exit();\n this.state.labels.pop();\n return this.finishNode(node, \"ForStatement\");\n }\n parseForIn(node, init, awaitAt) {\n const isForIn = this.match(58);\n this.next();\n if (isForIn) {\n if (awaitAt !== null) this.unexpected(awaitAt);\n } else {\n node.await = awaitAt !== null;\n }\n if (init.type === \"VariableDeclaration\" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== \"var\" || init.declarations[0].id.type !== \"Identifier\")) {\n this.raise(Errors.ForInOfLoopInitializer, init, {\n type: isForIn ? \"ForInStatement\" : \"ForOfStatement\"\n });\n }\n if (init.type === \"AssignmentPattern\") {\n this.raise(Errors.InvalidLhs, init, {\n ancestor: {\n type: \"ForStatement\"\n }\n });\n }\n node.left = init;\n node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();\n this.expect(11);\n node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());\n this.scope.exit();\n this.state.labels.pop();\n return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\");\n }\n parseVar(node, isFor, kind, allowMissingInitializer = false) {\n const declarations = node.declarations = [];\n node.kind = kind;\n for (;;) {\n const decl = this.startNode();\n this.parseVarId(decl, kind);\n decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();\n if (decl.init === null && !allowMissingInitializer) {\n if (decl.id.type !== \"Identifier\" && !(isFor && (this.match(58) || this.isContextual(102)))) {\n this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {\n kind: \"destructuring\"\n });\n } else if ((kind === \"const\" || kind === \"using\" || kind === \"await using\") && !(this.match(58) || this.isContextual(102))) {\n this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, {\n kind\n });\n }\n }\n declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n if (!this.eat(12)) break;\n }\n return node;\n }\n parseVarId(decl, kind) {\n const id = this.parseBindingAtom();\n if (kind === \"using\" || kind === \"await using\") {\n if (id.type === \"ArrayPattern\" || id.type === \"ObjectPattern\") {\n this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start);\n }\n } else {\n if (id.type === \"VoidPattern\") {\n this.raise(Errors.UnexpectedVoidPattern, id.loc.start);\n }\n }\n this.checkLVal(id, {\n type: \"VariableDeclarator\"\n }, kind === \"var\" ? 5 : 8201);\n decl.id = id;\n }\n parseAsyncFunctionExpression(node) {\n return this.parseFunction(node, 8);\n }\n parseFunction(node, flags = 0) {\n const hangingDeclaration = flags & 2;\n const isDeclaration = !!(flags & 1);\n const requireId = isDeclaration && !(flags & 4);\n const isAsync = !!(flags & 8);\n this.initFunction(node, isAsync);\n if (this.match(55)) {\n if (hangingDeclaration) {\n this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);\n }\n this.next();\n node.generator = true;\n }\n if (isDeclaration) {\n node.id = this.parseFunctionId(requireId);\n }\n const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;\n this.state.maybeInArrowParameters = false;\n this.scope.enter(514);\n this.prodParam.enter(functionFlags(isAsync, node.generator));\n if (!isDeclaration) {\n node.id = this.parseFunctionId();\n }\n this.parseFunctionParams(node, false);\n this.withSmartMixTopicForbiddingContext(() => {\n this.parseFunctionBodyAndFinish(node, isDeclaration ? \"FunctionDeclaration\" : \"FunctionExpression\");\n });\n this.prodParam.exit();\n this.scope.exit();\n if (isDeclaration && !hangingDeclaration) {\n this.registerFunctionStatementId(node);\n }\n this.state.maybeInArrowParameters = oldMaybeInArrowParameters;\n return node;\n }\n parseFunctionId(requireId) {\n return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;\n }\n parseFunctionParams(node, isConstructor) {\n this.expect(10);\n this.expressionScope.enter(newParameterDeclarationScope());\n node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));\n this.expressionScope.exit();\n }\n registerFunctionStatementId(node) {\n if (!node.id) return;\n this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);\n }\n parseClass(node, isStatement, optionalId) {\n this.next();\n const oldStrict = this.state.strict;\n this.state.strict = true;\n this.parseClassId(node, isStatement, optionalId);\n this.parseClassSuper(node);\n node.body = this.parseClassBody(!!node.superClass, oldStrict);\n return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\");\n }\n isClassProperty() {\n return this.match(29) || this.match(13) || this.match(8);\n }\n isClassMethod() {\n return this.match(10);\n }\n nameIsConstructor(key) {\n return key.type === \"Identifier\" && key.name === \"constructor\" || key.type === \"StringLiteral\" && key.value === \"constructor\";\n }\n isNonstaticConstructor(method) {\n return !method.computed && !method.static && this.nameIsConstructor(method.key);\n }\n parseClassBody(hadSuperClass, oldStrict) {\n this.classScope.enter();\n const state = {\n hadConstructor: false,\n hadSuperClass\n };\n let decorators = [];\n const classBody = this.startNode();\n classBody.body = [];\n this.expect(5);\n this.withSmartMixTopicForbiddingContext(() => {\n while (!this.match(8)) {\n if (this.eat(13)) {\n if (decorators.length > 0) {\n throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);\n }\n continue;\n }\n if (this.match(26)) {\n decorators.push(this.parseDecorator());\n continue;\n }\n const member = this.startNode();\n if (decorators.length) {\n member.decorators = decorators;\n this.resetStartLocationFromNode(member, decorators[0]);\n decorators = [];\n }\n this.parseClassMember(classBody, member, state);\n if (member.kind === \"constructor\" && member.decorators && member.decorators.length > 0) {\n this.raise(Errors.DecoratorConstructor, member);\n }\n }\n });\n this.state.strict = oldStrict;\n this.next();\n if (decorators.length) {\n throw this.raise(Errors.TrailingDecorator, this.state.startLoc);\n }\n this.classScope.exit();\n return this.finishNode(classBody, \"ClassBody\");\n }\n parseClassMemberFromModifier(classBody, member) {\n const key = this.parseIdentifier(true);\n if (this.isClassMethod()) {\n const method = member;\n method.kind = \"method\";\n method.computed = false;\n method.key = key;\n method.static = false;\n this.pushClassMethod(classBody, method, false, false, false, false);\n return true;\n } else if (this.isClassProperty()) {\n const prop = member;\n prop.computed = false;\n prop.key = key;\n prop.static = false;\n classBody.body.push(this.parseClassProperty(prop));\n return true;\n }\n this.resetPreviousNodeTrailingComments(key);\n return false;\n }\n parseClassMember(classBody, member, state) {\n const isStatic = this.isContextual(106);\n if (isStatic) {\n if (this.parseClassMemberFromModifier(classBody, member)) {\n return;\n }\n if (this.eat(5)) {\n this.parseClassStaticBlock(classBody, member);\n return;\n }\n }\n this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);\n }\n parseClassMemberWithIsStatic(classBody, member, state, isStatic) {\n const publicMethod = member;\n const privateMethod = member;\n const publicProp = member;\n const privateProp = member;\n const accessorProp = member;\n const method = publicMethod;\n const publicMember = publicMethod;\n member.static = isStatic;\n this.parsePropertyNamePrefixOperator(member);\n if (this.eat(55)) {\n method.kind = \"method\";\n const isPrivateName = this.match(139);\n this.parseClassElementName(method);\n this.parsePostMemberNameModifiers(method);\n if (isPrivateName) {\n this.pushClassPrivateMethod(classBody, privateMethod, true, false);\n return;\n }\n if (this.isNonstaticConstructor(publicMethod)) {\n this.raise(Errors.ConstructorIsGenerator, publicMethod.key);\n }\n this.pushClassMethod(classBody, publicMethod, true, false, false, false);\n return;\n }\n const isContextual = !this.state.containsEsc && tokenIsIdentifier(this.state.type);\n const key = this.parseClassElementName(member);\n const maybeContextualKw = isContextual ? key.name : null;\n const isPrivate = this.isPrivateName(key);\n const maybeQuestionTokenStartLoc = this.state.startLoc;\n this.parsePostMemberNameModifiers(publicMember);\n if (this.isClassMethod()) {\n method.kind = \"method\";\n if (isPrivate) {\n this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n return;\n }\n const isConstructor = this.isNonstaticConstructor(publicMethod);\n let allowsDirectSuper = false;\n if (isConstructor) {\n publicMethod.kind = \"constructor\";\n if (state.hadConstructor && !this.hasPlugin(\"typescript\")) {\n this.raise(Errors.DuplicateConstructor, key);\n }\n if (isConstructor && this.hasPlugin(\"typescript\") && member.override) {\n this.raise(Errors.OverrideOnConstructor, key);\n }\n state.hadConstructor = true;\n allowsDirectSuper = state.hadSuperClass;\n }\n this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);\n } else if (this.isClassProperty()) {\n if (isPrivate) {\n this.pushClassPrivateProperty(classBody, privateProp);\n } else {\n this.pushClassProperty(classBody, publicProp);\n }\n } else if (maybeContextualKw === \"async\" && !this.isLineTerminator()) {\n this.resetPreviousNodeTrailingComments(key);\n const isGenerator = this.eat(55);\n if (publicMember.optional) {\n this.unexpected(maybeQuestionTokenStartLoc);\n }\n method.kind = \"method\";\n const isPrivate = this.match(139);\n this.parseClassElementName(method);\n this.parsePostMemberNameModifiers(publicMember);\n if (isPrivate) {\n this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);\n } else {\n if (this.isNonstaticConstructor(publicMethod)) {\n this.raise(Errors.ConstructorIsAsync, publicMethod.key);\n }\n this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);\n }\n } else if ((maybeContextualKw === \"get\" || maybeContextualKw === \"set\") && !(this.match(55) && this.isLineTerminator())) {\n this.resetPreviousNodeTrailingComments(key);\n method.kind = maybeContextualKw;\n const isPrivate = this.match(139);\n this.parseClassElementName(publicMethod);\n if (isPrivate) {\n this.pushClassPrivateMethod(classBody, privateMethod, false, false);\n } else {\n if (this.isNonstaticConstructor(publicMethod)) {\n this.raise(Errors.ConstructorIsAccessor, publicMethod.key);\n }\n this.pushClassMethod(classBody, publicMethod, false, false, false, false);\n }\n this.checkGetterSetterParams(publicMethod);\n } else if (maybeContextualKw === \"accessor\" && !this.isLineTerminator()) {\n this.expectPlugin(\"decoratorAutoAccessors\");\n this.resetPreviousNodeTrailingComments(key);\n const isPrivate = this.match(139);\n this.parseClassElementName(publicProp);\n this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);\n } else if (this.isLineTerminator()) {\n if (isPrivate) {\n this.pushClassPrivateProperty(classBody, privateProp);\n } else {\n this.pushClassProperty(classBody, publicProp);\n }\n } else {\n this.unexpected();\n }\n }\n parseClassElementName(member) {\n const {\n type,\n value\n } = this.state;\n if ((type === 132 || type === 134) && member.static && value === \"prototype\") {\n this.raise(Errors.StaticPrototype, this.state.startLoc);\n }\n if (type === 139) {\n if (value === \"constructor\") {\n this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);\n }\n const key = this.parsePrivateName();\n member.key = key;\n return key;\n }\n this.parsePropertyName(member);\n return member.key;\n }\n parseClassStaticBlock(classBody, member) {\n var _member$decorators;\n this.scope.enter(576 | 128 | 16);\n const oldLabels = this.state.labels;\n this.state.labels = [];\n this.prodParam.enter(0);\n const body = member.body = [];\n this.parseBlockOrModuleBlockBody(body, undefined, false, 8);\n this.prodParam.exit();\n this.scope.exit();\n this.state.labels = oldLabels;\n classBody.body.push(this.finishNode(member, \"StaticBlock\"));\n if ((_member$decorators = member.decorators) != null && _member$decorators.length) {\n this.raise(Errors.DecoratorStaticBlock, member);\n }\n }\n pushClassProperty(classBody, prop) {\n if (!prop.computed && this.nameIsConstructor(prop.key)) {\n this.raise(Errors.ConstructorClassField, prop.key);\n }\n classBody.body.push(this.parseClassProperty(prop));\n }\n pushClassPrivateProperty(classBody, prop) {\n const node = this.parseClassPrivateProperty(prop);\n classBody.body.push(node);\n this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);\n }\n pushClassAccessorProperty(classBody, prop, isPrivate) {\n if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) {\n this.raise(Errors.ConstructorClassField, prop.key);\n }\n const node = this.parseClassAccessorProperty(prop);\n classBody.body.push(node);\n if (isPrivate) {\n this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);\n }\n }\n pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {\n classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, \"ClassMethod\", true));\n }\n pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {\n const node = this.parseMethod(method, isGenerator, isAsync, false, false, \"ClassPrivateMethod\", true);\n classBody.body.push(node);\n const kind = node.kind === \"get\" ? node.static ? 6 : 2 : node.kind === \"set\" ? node.static ? 5 : 1 : 0;\n this.declareClassPrivateMethodInScope(node, kind);\n }\n declareClassPrivateMethodInScope(node, kind) {\n this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);\n }\n parsePostMemberNameModifiers(methodOrProp) {}\n parseClassPrivateProperty(node) {\n this.parseInitializer(node);\n this.semicolon();\n return this.finishNode(node, \"ClassPrivateProperty\");\n }\n parseClassProperty(node) {\n this.parseInitializer(node);\n this.semicolon();\n return this.finishNode(node, \"ClassProperty\");\n }\n parseClassAccessorProperty(node) {\n this.parseInitializer(node);\n this.semicolon();\n return this.finishNode(node, \"ClassAccessorProperty\");\n }\n parseInitializer(node) {\n this.scope.enter(576 | 16);\n this.expressionScope.enter(newExpressionScope());\n this.prodParam.enter(0);\n node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;\n this.expressionScope.exit();\n this.prodParam.exit();\n this.scope.exit();\n }\n parseClassId(node, isStatement, optionalId, bindingType = 8331) {\n if (tokenIsIdentifier(this.state.type)) {\n node.id = this.parseIdentifier();\n if (isStatement) {\n this.declareNameFromIdentifier(node.id, bindingType);\n }\n } else {\n if (optionalId || !isStatement) {\n node.id = null;\n } else {\n throw this.raise(Errors.MissingClassName, this.state.startLoc);\n }\n }\n }\n parseClassSuper(node) {\n node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;\n }\n parseExport(node, decorators) {\n const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);\n const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);\n const parseAfterDefault = !hasDefault || this.eat(12);\n const hasStar = parseAfterDefault && this.eatExportStar(node);\n const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);\n const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));\n const isFromRequired = hasDefault || hasStar;\n if (hasStar && !hasNamespace) {\n if (hasDefault) this.unexpected();\n if (decorators) {\n throw this.raise(Errors.UnsupportedDecoratorExport, node);\n }\n this.parseExportFrom(node, true);\n this.sawUnambiguousESM = true;\n return this.finishNode(node, \"ExportAllDeclaration\");\n }\n const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);\n if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {\n this.unexpected(null, 5);\n }\n if (hasNamespace && parseAfterNamespace) {\n this.unexpected(null, 98);\n }\n let hasDeclaration;\n if (isFromRequired || hasSpecifiers) {\n hasDeclaration = false;\n if (decorators) {\n throw this.raise(Errors.UnsupportedDecoratorExport, node);\n }\n this.parseExportFrom(node, isFromRequired);\n } else {\n hasDeclaration = this.maybeParseExportDeclaration(node);\n }\n if (isFromRequired || hasSpecifiers || hasDeclaration) {\n var _node2$declaration;\n const node2 = node;\n this.checkExport(node2, true, false, !!node2.source);\n if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === \"ClassDeclaration\") {\n this.maybeTakeDecorators(decorators, node2.declaration, node2);\n } else if (decorators) {\n throw this.raise(Errors.UnsupportedDecoratorExport, node);\n }\n this.sawUnambiguousESM = true;\n return this.finishNode(node2, \"ExportNamedDeclaration\");\n }\n if (this.eat(65)) {\n const node2 = node;\n const decl = this.parseExportDefaultExpression();\n node2.declaration = decl;\n if (decl.type === \"ClassDeclaration\") {\n this.maybeTakeDecorators(decorators, decl, node2);\n } else if (decorators) {\n throw this.raise(Errors.UnsupportedDecoratorExport, node);\n }\n this.checkExport(node2, true, true);\n this.sawUnambiguousESM = true;\n return this.finishNode(node2, \"ExportDefaultDeclaration\");\n }\n throw this.unexpected(null, 5);\n }\n eatExportStar(node) {\n return this.eat(55);\n }\n maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {\n if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {\n this.expectPlugin(\"exportDefaultFrom\", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);\n const id = maybeDefaultIdentifier || this.parseIdentifier(true);\n const specifier = this.startNodeAtNode(id);\n specifier.exported = id;\n node.specifiers = [this.finishNode(specifier, \"ExportDefaultSpecifier\")];\n return true;\n }\n return false;\n }\n maybeParseExportNamespaceSpecifier(node) {\n if (this.isContextual(93)) {\n var _ref, _ref$specifiers;\n (_ref$specifiers = (_ref = node).specifiers) != null ? _ref$specifiers : _ref.specifiers = [];\n const specifier = this.startNodeAt(this.state.lastTokStartLoc);\n this.next();\n specifier.exported = this.parseModuleExportName();\n node.specifiers.push(this.finishNode(specifier, \"ExportNamespaceSpecifier\"));\n return true;\n }\n return false;\n }\n maybeParseExportNamedSpecifiers(node) {\n if (this.match(5)) {\n const node2 = node;\n if (!node2.specifiers) node2.specifiers = [];\n const isTypeExport = node2.exportKind === \"type\";\n node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));\n node2.source = null;\n if (this.hasPlugin(\"importAssertions\")) {\n node2.assertions = [];\n } else {\n node2.attributes = [];\n }\n node2.declaration = null;\n return true;\n }\n return false;\n }\n maybeParseExportDeclaration(node) {\n if (this.shouldParseExportDeclaration()) {\n node.specifiers = [];\n node.source = null;\n if (this.hasPlugin(\"importAssertions\")) {\n node.assertions = [];\n } else {\n node.attributes = [];\n }\n node.declaration = this.parseExportDeclaration(node);\n return true;\n }\n return false;\n }\n isAsyncFunction() {\n if (!this.isContextual(95)) return false;\n const next = this.nextTokenInLineStart();\n return this.isUnparsedContextual(next, \"function\");\n }\n parseExportDefaultExpression() {\n const expr = this.startNode();\n if (this.match(68)) {\n this.next();\n return this.parseFunction(expr, 1 | 4);\n } else if (this.isAsyncFunction()) {\n this.next();\n this.next();\n return this.parseFunction(expr, 1 | 4 | 8);\n }\n if (this.match(80)) {\n return this.parseClass(expr, true, true);\n }\n if (this.match(26)) {\n if (this.hasPlugin(\"decorators\") && this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true) {\n this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n }\n return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);\n }\n if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) {\n throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);\n }\n const res = this.parseMaybeAssignAllowIn();\n this.semicolon();\n return res;\n }\n parseExportDeclaration(node) {\n if (this.match(80)) {\n const node = this.parseClass(this.startNode(), true, false);\n return node;\n }\n return this.parseStatementListItem();\n }\n isExportDefaultSpecifier() {\n const {\n type\n } = this.state;\n if (tokenIsIdentifier(type)) {\n if (type === 95 && !this.state.containsEsc || type === 100) {\n return false;\n }\n if ((type === 130 || type === 129) && !this.state.containsEsc) {\n const next = this.nextTokenStart();\n const nextChar = this.input.charCodeAt(next);\n if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.input.startsWith(\"from\", next)) {\n this.expectOnePlugin([\"flow\", \"typescript\"]);\n return false;\n }\n }\n } else if (!this.match(65)) {\n return false;\n }\n const next = this.nextTokenStart();\n const hasFrom = this.isUnparsedContextual(next, \"from\");\n if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {\n return true;\n }\n if (this.match(65) && hasFrom) {\n const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));\n return nextAfterFrom === 34 || nextAfterFrom === 39;\n }\n return false;\n }\n parseExportFrom(node, expect) {\n if (this.eatContextual(98)) {\n node.source = this.parseImportSource();\n this.checkExport(node);\n this.maybeParseImportAttributes(node);\n this.checkJSONModuleImport(node);\n } else if (expect) {\n this.unexpected();\n }\n this.semicolon();\n }\n shouldParseExportDeclaration() {\n const {\n type\n } = this.state;\n if (type === 26) {\n this.expectOnePlugin([\"decorators\", \"decorators-legacy\"]);\n if (this.hasPlugin(\"decorators\")) {\n if (this.getPluginOption(\"decorators\", \"decoratorsBeforeExport\") === true) {\n this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);\n }\n return true;\n }\n }\n if (this.isUsing()) {\n this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n return true;\n }\n if (this.isAwaitUsing()) {\n this.raise(Errors.UsingDeclarationExport, this.state.startLoc);\n return true;\n }\n return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();\n }\n checkExport(node, checkNames, isDefault, isFrom) {\n if (checkNames) {\n var _node$specifiers;\n if (isDefault) {\n this.checkDuplicateExports(node, \"default\");\n if (this.hasPlugin(\"exportDefaultFrom\")) {\n var _declaration$extra;\n const declaration = node.declaration;\n if (declaration.type === \"Identifier\" && declaration.name === \"from\" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {\n this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);\n }\n }\n } else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) {\n for (const specifier of node.specifiers) {\n const {\n exported\n } = specifier;\n const exportName = exported.type === \"Identifier\" ? exported.name : exported.value;\n this.checkDuplicateExports(specifier, exportName);\n if (!isFrom && specifier.local) {\n const {\n local\n } = specifier;\n if (local.type !== \"Identifier\") {\n this.raise(Errors.ExportBindingIsString, specifier, {\n localName: local.value,\n exportName\n });\n } else {\n this.checkReservedWord(local.name, local.loc.start, true, false);\n this.scope.checkLocalExport(local);\n }\n }\n }\n } else if (node.declaration) {\n const decl = node.declaration;\n if (decl.type === \"FunctionDeclaration\" || decl.type === \"ClassDeclaration\") {\n const {\n id\n } = decl;\n if (!id) throw new Error(\"Assertion failure\");\n this.checkDuplicateExports(node, id.name);\n } else if (decl.type === \"VariableDeclaration\") {\n for (const declaration of decl.declarations) {\n this.checkDeclaration(declaration.id);\n }\n }\n }\n }\n }\n checkDeclaration(node) {\n if (node.type === \"Identifier\") {\n this.checkDuplicateExports(node, node.name);\n } else if (node.type === \"ObjectPattern\") {\n for (const prop of node.properties) {\n this.checkDeclaration(prop);\n }\n } else if (node.type === \"ArrayPattern\") {\n for (const elem of node.elements) {\n if (elem) {\n this.checkDeclaration(elem);\n }\n }\n } else if (node.type === \"ObjectProperty\") {\n this.checkDeclaration(node.value);\n } else if (node.type === \"RestElement\") {\n this.checkDeclaration(node.argument);\n } else if (node.type === \"AssignmentPattern\") {\n this.checkDeclaration(node.left);\n }\n }\n checkDuplicateExports(node, exportName) {\n if (this.exportedIdentifiers.has(exportName)) {\n if (exportName === \"default\") {\n this.raise(Errors.DuplicateDefaultExport, node);\n } else {\n this.raise(Errors.DuplicateExport, node, {\n exportName\n });\n }\n }\n this.exportedIdentifiers.add(exportName);\n }\n parseExportSpecifiers(isInTypeExport) {\n const nodes = [];\n let first = true;\n this.expect(5);\n while (!this.eat(8)) {\n if (first) {\n first = false;\n } else {\n this.expect(12);\n if (this.eat(8)) break;\n }\n const isMaybeTypeOnly = this.isContextual(130);\n const isString = this.match(134);\n const node = this.startNode();\n node.local = this.parseModuleExportName();\n nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));\n }\n return nodes;\n }\n parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {\n if (this.eatContextual(93)) {\n node.exported = this.parseModuleExportName();\n } else if (isString) {\n node.exported = this.cloneStringLiteral(node.local);\n } else if (!node.exported) {\n node.exported = this.cloneIdentifier(node.local);\n }\n return this.finishNode(node, \"ExportSpecifier\");\n }\n parseModuleExportName() {\n if (this.match(134)) {\n const result = this.parseStringLiteral(this.state.value);\n const surrogate = loneSurrogate.exec(result.value);\n if (surrogate) {\n this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, {\n surrogateCharCode: surrogate[0].charCodeAt(0)\n });\n }\n return result;\n }\n return this.parseIdentifier(true);\n }\n isJSONModuleImport(node) {\n if (node.assertions != null) {\n return node.assertions.some(({\n key,\n value\n }) => {\n return value.value === \"json\" && (key.type === \"Identifier\" ? key.name === \"type\" : key.value === \"type\");\n });\n }\n return false;\n }\n checkImportReflection(node) {\n const {\n specifiers\n } = node;\n const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;\n if (node.phase === \"source\") {\n if (singleBindingType !== \"ImportDefaultSpecifier\") {\n this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);\n }\n } else if (node.phase === \"defer\") {\n if (singleBindingType !== \"ImportNamespaceSpecifier\") {\n this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);\n }\n } else if (node.module) {\n var _node$assertions;\n if (singleBindingType !== \"ImportDefaultSpecifier\") {\n this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);\n }\n if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {\n this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);\n }\n }\n }\n checkJSONModuleImport(node) {\n if (this.isJSONModuleImport(node) && node.type !== \"ExportAllDeclaration\") {\n const {\n specifiers\n } = node;\n if (specifiers != null) {\n const nonDefaultNamedSpecifier = specifiers.find(specifier => {\n let imported;\n if (specifier.type === \"ExportSpecifier\") {\n imported = specifier.local;\n } else if (specifier.type === \"ImportSpecifier\") {\n imported = specifier.imported;\n }\n if (imported !== undefined) {\n return imported.type === \"Identifier\" ? imported.name !== \"default\" : imported.value !== \"default\";\n }\n });\n if (nonDefaultNamedSpecifier !== undefined) {\n this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);\n }\n }\n }\n }\n isPotentialImportPhase(isExport) {\n if (isExport) return false;\n return this.isContextual(105) || this.isContextual(97) || this.isContextual(127);\n }\n applyImportPhase(node, isExport, phase, loc) {\n if (isExport) {\n return;\n }\n if (phase === \"module\") {\n this.expectPlugin(\"importReflection\", loc);\n node.module = true;\n } else if (this.hasPlugin(\"importReflection\")) {\n node.module = false;\n }\n if (phase === \"source\") {\n this.expectPlugin(\"sourcePhaseImports\", loc);\n node.phase = \"source\";\n } else if (phase === \"defer\") {\n this.expectPlugin(\"deferredImportEvaluation\", loc);\n node.phase = \"defer\";\n } else if (this.hasPlugin(\"sourcePhaseImports\")) {\n node.phase = null;\n }\n }\n parseMaybeImportPhase(node, isExport) {\n if (!this.isPotentialImportPhase(isExport)) {\n this.applyImportPhase(node, isExport, null);\n return null;\n }\n const phaseIdentifier = this.startNode();\n const phaseIdentifierName = this.parseIdentifierName(true);\n const {\n type\n } = this.state;\n const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;\n if (isImportPhase) {\n this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);\n return null;\n } else {\n this.applyImportPhase(node, isExport, null);\n return this.createIdentifier(phaseIdentifier, phaseIdentifierName);\n }\n }\n isPrecedingIdImportPhase(phase) {\n const {\n type\n } = this.state;\n return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;\n }\n parseImport(node) {\n if (this.match(134)) {\n return this.parseImportSourceAndAttributes(node);\n }\n return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));\n }\n parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {\n node.specifiers = [];\n const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);\n const parseNext = !hasDefault || this.eat(12);\n const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);\n if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);\n this.expectContextual(98);\n return this.parseImportSourceAndAttributes(node);\n }\n parseImportSourceAndAttributes(node) {\n var _node$specifiers2;\n (_node$specifiers2 = node.specifiers) != null ? _node$specifiers2 : node.specifiers = [];\n node.source = this.parseImportSource();\n this.maybeParseImportAttributes(node);\n this.checkImportReflection(node);\n this.checkJSONModuleImport(node);\n this.semicolon();\n this.sawUnambiguousESM = true;\n return this.finishNode(node, \"ImportDeclaration\");\n }\n parseImportSource() {\n if (!this.match(134)) this.unexpected();\n return this.parseExprAtom();\n }\n parseImportSpecifierLocal(node, specifier, type) {\n specifier.local = this.parseIdentifier();\n node.specifiers.push(this.finishImportSpecifier(specifier, type));\n }\n finishImportSpecifier(specifier, type, bindingType = 8201) {\n this.checkLVal(specifier.local, {\n type\n }, bindingType);\n return this.finishNode(specifier, type);\n }\n parseImportAttributes() {\n this.expect(5);\n const attrs = [];\n const attrNames = new Set();\n do {\n if (this.match(8)) {\n break;\n }\n const node = this.startNode();\n const keyName = this.state.value;\n if (attrNames.has(keyName)) {\n this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, {\n key: keyName\n });\n }\n attrNames.add(keyName);\n if (this.match(134)) {\n node.key = this.parseStringLiteral(keyName);\n } else {\n node.key = this.parseIdentifier(true);\n }\n this.expect(14);\n if (!this.match(134)) {\n throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);\n }\n node.value = this.parseStringLiteral(this.state.value);\n attrs.push(this.finishNode(node, \"ImportAttribute\"));\n } while (this.eat(12));\n this.expect(8);\n return attrs;\n }\n parseModuleAttributes() {\n const attrs = [];\n const attributes = new Set();\n do {\n const node = this.startNode();\n node.key = this.parseIdentifier(true);\n if (node.key.name !== \"type\") {\n this.raise(Errors.ModuleAttributeDifferentFromType, node.key);\n }\n if (attributes.has(node.key.name)) {\n this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, {\n key: node.key.name\n });\n }\n attributes.add(node.key.name);\n this.expect(14);\n if (!this.match(134)) {\n throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);\n }\n node.value = this.parseStringLiteral(this.state.value);\n attrs.push(this.finishNode(node, \"ImportAttribute\"));\n } while (this.eat(12));\n return attrs;\n }\n maybeParseImportAttributes(node) {\n let attributes;\n var useWith = false;\n if (this.match(76)) {\n if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {\n return;\n }\n this.next();\n if (this.hasPlugin(\"moduleAttributes\")) {\n attributes = this.parseModuleAttributes();\n this.addExtra(node, \"deprecatedWithLegacySyntax\", true);\n } else {\n attributes = this.parseImportAttributes();\n }\n useWith = true;\n } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {\n if (!this.hasPlugin(\"deprecatedImportAssert\") && !this.hasPlugin(\"importAssertions\")) {\n this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc);\n }\n if (!this.hasPlugin(\"importAssertions\")) {\n this.addExtra(node, \"deprecatedAssertSyntax\", true);\n }\n this.next();\n attributes = this.parseImportAttributes();\n } else {\n attributes = [];\n }\n if (!useWith && this.hasPlugin(\"importAssertions\")) {\n node.assertions = attributes;\n } else {\n node.attributes = attributes;\n }\n }\n maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {\n if (maybeDefaultIdentifier) {\n const specifier = this.startNodeAtNode(maybeDefaultIdentifier);\n specifier.local = maybeDefaultIdentifier;\n node.specifiers.push(this.finishImportSpecifier(specifier, \"ImportDefaultSpecifier\"));\n return true;\n } else if (tokenIsKeywordOrIdentifier(this.state.type)) {\n this.parseImportSpecifierLocal(node, this.startNode(), \"ImportDefaultSpecifier\");\n return true;\n }\n return false;\n }\n maybeParseStarImportSpecifier(node) {\n if (this.match(55)) {\n const specifier = this.startNode();\n this.next();\n this.expectContextual(93);\n this.parseImportSpecifierLocal(node, specifier, \"ImportNamespaceSpecifier\");\n return true;\n }\n return false;\n }\n parseNamedImportSpecifiers(node) {\n let first = true;\n this.expect(5);\n while (!this.eat(8)) {\n if (first) {\n first = false;\n } else {\n if (this.eat(14)) {\n throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);\n }\n this.expect(12);\n if (this.eat(8)) break;\n }\n const specifier = this.startNode();\n const importedIsString = this.match(134);\n const isMaybeTypeOnly = this.isContextual(130);\n specifier.imported = this.parseModuleExportName();\n const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === \"type\" || node.importKind === \"typeof\", isMaybeTypeOnly, undefined);\n node.specifiers.push(importSpecifier);\n }\n }\n parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {\n if (this.eatContextual(93)) {\n specifier.local = this.parseIdentifier();\n } else {\n const {\n imported\n } = specifier;\n if (importedIsString) {\n throw this.raise(Errors.ImportBindingIsString, specifier, {\n importName: imported.value\n });\n }\n this.checkReservedWord(imported.name, specifier.loc.start, true, true);\n if (!specifier.local) {\n specifier.local = this.cloneIdentifier(imported);\n }\n }\n return this.finishImportSpecifier(specifier, \"ImportSpecifier\", bindingType);\n }\n isThisParam(param) {\n return param.type === \"Identifier\" && param.name === \"this\";\n }\n}\nclass Parser extends StatementParser {\n constructor(options, input, pluginsMap) {\n const normalizedOptions = getOptions(options);\n super(normalizedOptions, input);\n this.options = normalizedOptions;\n this.initializeScopes();\n this.plugins = pluginsMap;\n this.filename = normalizedOptions.sourceFilename;\n this.startIndex = normalizedOptions.startIndex;\n let optionFlags = 0;\n if (normalizedOptions.allowAwaitOutsideFunction) {\n optionFlags |= 1;\n }\n if (normalizedOptions.allowReturnOutsideFunction) {\n optionFlags |= 2;\n }\n if (normalizedOptions.allowImportExportEverywhere) {\n optionFlags |= 8;\n }\n if (normalizedOptions.allowSuperOutsideMethod) {\n optionFlags |= 16;\n }\n if (normalizedOptions.allowUndeclaredExports) {\n optionFlags |= 64;\n }\n if (normalizedOptions.allowNewTargetOutsideFunction) {\n optionFlags |= 4;\n }\n if (normalizedOptions.allowYieldOutsideFunction) {\n optionFlags |= 32;\n }\n if (normalizedOptions.ranges) {\n optionFlags |= 128;\n }\n if (normalizedOptions.tokens) {\n optionFlags |= 256;\n }\n if (normalizedOptions.createImportExpressions) {\n optionFlags |= 512;\n }\n if (normalizedOptions.createParenthesizedExpressions) {\n optionFlags |= 1024;\n }\n if (normalizedOptions.errorRecovery) {\n optionFlags |= 2048;\n }\n if (normalizedOptions.attachComment) {\n optionFlags |= 4096;\n }\n if (normalizedOptions.annexB) {\n optionFlags |= 8192;\n }\n this.optionFlags = optionFlags;\n }\n getScopeHandler() {\n return ScopeHandler;\n }\n parse() {\n this.enterInitialScopes();\n const file = this.startNode();\n const program = this.startNode();\n this.nextToken();\n file.errors = null;\n const result = this.parseTopLevel(file, program);\n result.errors = this.state.errors;\n result.comments.length = this.state.commentsLen;\n return result;\n }\n}\nfunction parse(input, options) {\n var _options;\n if (((_options = options) == null ? void 0 : _options.sourceType) === \"unambiguous\") {\n options = Object.assign({}, options);\n try {\n options.sourceType = \"module\";\n const parser = getParser(options, input);\n const ast = parser.parse();\n if (parser.sawUnambiguousESM) {\n return ast;\n }\n if (parser.ambiguousScriptDifferentAst) {\n try {\n options.sourceType = \"script\";\n return getParser(options, input).parse();\n } catch (_unused) {}\n } else {\n ast.program.sourceType = \"script\";\n }\n return ast;\n } catch (moduleError) {\n try {\n options.sourceType = \"script\";\n return getParser(options, input).parse();\n } catch (_unused2) {}\n throw moduleError;\n }\n } else {\n return getParser(options, input).parse();\n }\n}\nfunction parseExpression(input, options) {\n const parser = getParser(options, input);\n if (parser.options.strictMode) {\n parser.state.strict = true;\n }\n return parser.getExpression();\n}\nfunction generateExportedTokenTypes(internalTokenTypes) {\n const tokenTypes = {};\n for (const typeName of Object.keys(internalTokenTypes)) {\n tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);\n }\n return tokenTypes;\n}\nconst tokTypes = generateExportedTokenTypes(tt);\nfunction getParser(options, input) {\n let cls = Parser;\n const pluginsMap = new Map();\n if (options != null && options.plugins) {\n for (const plugin of options.plugins) {\n let name, opts;\n if (typeof plugin === \"string\") {\n name = plugin;\n } else {\n [name, opts] = plugin;\n }\n if (!pluginsMap.has(name)) {\n pluginsMap.set(name, opts || {});\n }\n }\n validatePlugins(pluginsMap);\n cls = getParserClass(pluginsMap);\n }\n return new cls(options, input, pluginsMap);\n}\nconst parserClassCache = new Map();\nfunction getParserClass(pluginsMap) {\n const pluginList = [];\n for (const name of mixinPluginNames) {\n if (pluginsMap.has(name)) {\n pluginList.push(name);\n }\n }\n const key = pluginList.join(\"|\");\n let cls = parserClassCache.get(key);\n if (!cls) {\n cls = Parser;\n for (const plugin of pluginList) {\n cls = mixinPlugins[plugin](cls);\n }\n parserClassCache.set(key, cls);\n }\n return cls;\n}\nexports.parse = parse;\nexports.parseExpression = parseExpression;\nexports.tokTypes = tokTypes;\n//# sourceMappingURL=index.js.map\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/types/index.js b/miniapp/miniprogram_npm/@babel/types/index.js new file mode 100644 index 0000000..7859288 --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/types/index.js @@ -0,0 +1,13599 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509019, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _exportNames = { + react: true, + assertNode: true, + createTypeAnnotationBasedOnTypeof: true, + createUnionTypeAnnotation: true, + createFlowUnionType: true, + createTSUnionType: true, + cloneNode: true, + clone: true, + cloneDeep: true, + cloneDeepWithoutLoc: true, + cloneWithoutLoc: true, + addComment: true, + addComments: true, + inheritInnerComments: true, + inheritLeadingComments: true, + inheritsComments: true, + inheritTrailingComments: true, + removeComments: true, + ensureBlock: true, + toBindingIdentifierName: true, + toBlock: true, + toComputedKey: true, + toExpression: true, + toIdentifier: true, + toKeyAlias: true, + toStatement: true, + valueToNode: true, + appendToMemberExpression: true, + inherits: true, + prependToMemberExpression: true, + removeProperties: true, + removePropertiesDeep: true, + removeTypeDuplicates: true, + getAssignmentIdentifiers: true, + getBindingIdentifiers: true, + getOuterBindingIdentifiers: true, + getFunctionName: true, + traverse: true, + traverseFast: true, + shallowEqual: true, + is: true, + isBinding: true, + isBlockScoped: true, + isImmutable: true, + isLet: true, + isNode: true, + isNodesEquivalent: true, + isPlaceholderType: true, + isReferenced: true, + isScope: true, + isSpecifierDefault: true, + isType: true, + isValidES3Identifier: true, + isValidIdentifier: true, + isVar: true, + matchesPattern: true, + validate: true, + buildMatchMemberExpression: true, + __internal__deprecationWarning: true +}; +Object.defineProperty(exports, "__internal__deprecationWarning", { + enumerable: true, + get: function () { + return _deprecationWarning.default; + } +}); +Object.defineProperty(exports, "addComment", { + enumerable: true, + get: function () { + return _addComment.default; + } +}); +Object.defineProperty(exports, "addComments", { + enumerable: true, + get: function () { + return _addComments.default; + } +}); +Object.defineProperty(exports, "appendToMemberExpression", { + enumerable: true, + get: function () { + return _appendToMemberExpression.default; + } +}); +Object.defineProperty(exports, "assertNode", { + enumerable: true, + get: function () { + return _assertNode.default; + } +}); +Object.defineProperty(exports, "buildMatchMemberExpression", { + enumerable: true, + get: function () { + return _buildMatchMemberExpression.default; + } +}); +Object.defineProperty(exports, "clone", { + enumerable: true, + get: function () { + return _clone.default; + } +}); +Object.defineProperty(exports, "cloneDeep", { + enumerable: true, + get: function () { + return _cloneDeep.default; + } +}); +Object.defineProperty(exports, "cloneDeepWithoutLoc", { + enumerable: true, + get: function () { + return _cloneDeepWithoutLoc.default; + } +}); +Object.defineProperty(exports, "cloneNode", { + enumerable: true, + get: function () { + return _cloneNode.default; + } +}); +Object.defineProperty(exports, "cloneWithoutLoc", { + enumerable: true, + get: function () { + return _cloneWithoutLoc.default; + } +}); +Object.defineProperty(exports, "createFlowUnionType", { + enumerable: true, + get: function () { + return _createFlowUnionType.default; + } +}); +Object.defineProperty(exports, "createTSUnionType", { + enumerable: true, + get: function () { + return _createTSUnionType.default; + } +}); +Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { + enumerable: true, + get: function () { + return _createTypeAnnotationBasedOnTypeof.default; + } +}); +Object.defineProperty(exports, "createUnionTypeAnnotation", { + enumerable: true, + get: function () { + return _createFlowUnionType.default; + } +}); +Object.defineProperty(exports, "ensureBlock", { + enumerable: true, + get: function () { + return _ensureBlock.default; + } +}); +Object.defineProperty(exports, "getAssignmentIdentifiers", { + enumerable: true, + get: function () { + return _getAssignmentIdentifiers.default; + } +}); +Object.defineProperty(exports, "getBindingIdentifiers", { + enumerable: true, + get: function () { + return _getBindingIdentifiers.default; + } +}); +Object.defineProperty(exports, "getFunctionName", { + enumerable: true, + get: function () { + return _getFunctionName.default; + } +}); +Object.defineProperty(exports, "getOuterBindingIdentifiers", { + enumerable: true, + get: function () { + return _getOuterBindingIdentifiers.default; + } +}); +Object.defineProperty(exports, "inheritInnerComments", { + enumerable: true, + get: function () { + return _inheritInnerComments.default; + } +}); +Object.defineProperty(exports, "inheritLeadingComments", { + enumerable: true, + get: function () { + return _inheritLeadingComments.default; + } +}); +Object.defineProperty(exports, "inheritTrailingComments", { + enumerable: true, + get: function () { + return _inheritTrailingComments.default; + } +}); +Object.defineProperty(exports, "inherits", { + enumerable: true, + get: function () { + return _inherits.default; + } +}); +Object.defineProperty(exports, "inheritsComments", { + enumerable: true, + get: function () { + return _inheritsComments.default; + } +}); +Object.defineProperty(exports, "is", { + enumerable: true, + get: function () { + return _is.default; + } +}); +Object.defineProperty(exports, "isBinding", { + enumerable: true, + get: function () { + return _isBinding.default; + } +}); +Object.defineProperty(exports, "isBlockScoped", { + enumerable: true, + get: function () { + return _isBlockScoped.default; + } +}); +Object.defineProperty(exports, "isImmutable", { + enumerable: true, + get: function () { + return _isImmutable.default; + } +}); +Object.defineProperty(exports, "isLet", { + enumerable: true, + get: function () { + return _isLet.default; + } +}); +Object.defineProperty(exports, "isNode", { + enumerable: true, + get: function () { + return _isNode.default; + } +}); +Object.defineProperty(exports, "isNodesEquivalent", { + enumerable: true, + get: function () { + return _isNodesEquivalent.default; + } +}); +Object.defineProperty(exports, "isPlaceholderType", { + enumerable: true, + get: function () { + return _isPlaceholderType.default; + } +}); +Object.defineProperty(exports, "isReferenced", { + enumerable: true, + get: function () { + return _isReferenced.default; + } +}); +Object.defineProperty(exports, "isScope", { + enumerable: true, + get: function () { + return _isScope.default; + } +}); +Object.defineProperty(exports, "isSpecifierDefault", { + enumerable: true, + get: function () { + return _isSpecifierDefault.default; + } +}); +Object.defineProperty(exports, "isType", { + enumerable: true, + get: function () { + return _isType.default; + } +}); +Object.defineProperty(exports, "isValidES3Identifier", { + enumerable: true, + get: function () { + return _isValidES3Identifier.default; + } +}); +Object.defineProperty(exports, "isValidIdentifier", { + enumerable: true, + get: function () { + return _isValidIdentifier.default; + } +}); +Object.defineProperty(exports, "isVar", { + enumerable: true, + get: function () { + return _isVar.default; + } +}); +Object.defineProperty(exports, "matchesPattern", { + enumerable: true, + get: function () { + return _matchesPattern.default; + } +}); +Object.defineProperty(exports, "prependToMemberExpression", { + enumerable: true, + get: function () { + return _prependToMemberExpression.default; + } +}); +exports.react = void 0; +Object.defineProperty(exports, "removeComments", { + enumerable: true, + get: function () { + return _removeComments.default; + } +}); +Object.defineProperty(exports, "removeProperties", { + enumerable: true, + get: function () { + return _removeProperties.default; + } +}); +Object.defineProperty(exports, "removePropertiesDeep", { + enumerable: true, + get: function () { + return _removePropertiesDeep.default; + } +}); +Object.defineProperty(exports, "removeTypeDuplicates", { + enumerable: true, + get: function () { + return _removeTypeDuplicates.default; + } +}); +Object.defineProperty(exports, "shallowEqual", { + enumerable: true, + get: function () { + return _shallowEqual.default; + } +}); +Object.defineProperty(exports, "toBindingIdentifierName", { + enumerable: true, + get: function () { + return _toBindingIdentifierName.default; + } +}); +Object.defineProperty(exports, "toBlock", { + enumerable: true, + get: function () { + return _toBlock.default; + } +}); +Object.defineProperty(exports, "toComputedKey", { + enumerable: true, + get: function () { + return _toComputedKey.default; + } +}); +Object.defineProperty(exports, "toExpression", { + enumerable: true, + get: function () { + return _toExpression.default; + } +}); +Object.defineProperty(exports, "toIdentifier", { + enumerable: true, + get: function () { + return _toIdentifier.default; + } +}); +Object.defineProperty(exports, "toKeyAlias", { + enumerable: true, + get: function () { + return _toKeyAlias.default; + } +}); +Object.defineProperty(exports, "toStatement", { + enumerable: true, + get: function () { + return _toStatement.default; + } +}); +Object.defineProperty(exports, "traverse", { + enumerable: true, + get: function () { + return _traverse.default; + } +}); +Object.defineProperty(exports, "traverseFast", { + enumerable: true, + get: function () { + return _traverseFast.default; + } +}); +Object.defineProperty(exports, "validate", { + enumerable: true, + get: function () { + return _validate.default; + } +}); +Object.defineProperty(exports, "valueToNode", { + enumerable: true, + get: function () { + return _valueToNode.default; + } +}); +var _isReactComponent = require("./validators/react/isReactComponent.js"); +var _isCompatTag = require("./validators/react/isCompatTag.js"); +var _buildChildren = require("./builders/react/buildChildren.js"); +var _assertNode = require("./asserts/assertNode.js"); +var _index = require("./asserts/generated/index.js"); +Object.keys(_index).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index[key]; + } + }); +}); +var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof.js"); +var _createFlowUnionType = require("./builders/flow/createFlowUnionType.js"); +var _createTSUnionType = require("./builders/typescript/createTSUnionType.js"); +var _productions = require("./builders/productions.js"); +Object.keys(_productions).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _productions[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _productions[key]; + } + }); +}); +var _index2 = require("./builders/generated/index.js"); +Object.keys(_index2).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index2[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index2[key]; + } + }); +}); +var _cloneNode = require("./clone/cloneNode.js"); +var _clone = require("./clone/clone.js"); +var _cloneDeep = require("./clone/cloneDeep.js"); +var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc.js"); +var _cloneWithoutLoc = require("./clone/cloneWithoutLoc.js"); +var _addComment = require("./comments/addComment.js"); +var _addComments = require("./comments/addComments.js"); +var _inheritInnerComments = require("./comments/inheritInnerComments.js"); +var _inheritLeadingComments = require("./comments/inheritLeadingComments.js"); +var _inheritsComments = require("./comments/inheritsComments.js"); +var _inheritTrailingComments = require("./comments/inheritTrailingComments.js"); +var _removeComments = require("./comments/removeComments.js"); +var _index3 = require("./constants/generated/index.js"); +Object.keys(_index3).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index3[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index3[key]; + } + }); +}); +var _index4 = require("./constants/index.js"); +Object.keys(_index4).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index4[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index4[key]; + } + }); +}); +var _ensureBlock = require("./converters/ensureBlock.js"); +var _toBindingIdentifierName = require("./converters/toBindingIdentifierName.js"); +var _toBlock = require("./converters/toBlock.js"); +var _toComputedKey = require("./converters/toComputedKey.js"); +var _toExpression = require("./converters/toExpression.js"); +var _toIdentifier = require("./converters/toIdentifier.js"); +var _toKeyAlias = require("./converters/toKeyAlias.js"); +var _toStatement = require("./converters/toStatement.js"); +var _valueToNode = require("./converters/valueToNode.js"); +var _index5 = require("./definitions/index.js"); +Object.keys(_index5).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index5[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index5[key]; + } + }); +}); +var _appendToMemberExpression = require("./modifications/appendToMemberExpression.js"); +var _inherits = require("./modifications/inherits.js"); +var _prependToMemberExpression = require("./modifications/prependToMemberExpression.js"); +var _removeProperties = require("./modifications/removeProperties.js"); +var _removePropertiesDeep = require("./modifications/removePropertiesDeep.js"); +var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates.js"); +var _getAssignmentIdentifiers = require("./retrievers/getAssignmentIdentifiers.js"); +var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers.js"); +var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers.js"); +var _getFunctionName = require("./retrievers/getFunctionName.js"); +var _traverse = require("./traverse/traverse.js"); +Object.keys(_traverse).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _traverse[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _traverse[key]; + } + }); +}); +var _traverseFast = require("./traverse/traverseFast.js"); +var _shallowEqual = require("./utils/shallowEqual.js"); +var _is = require("./validators/is.js"); +var _isBinding = require("./validators/isBinding.js"); +var _isBlockScoped = require("./validators/isBlockScoped.js"); +var _isImmutable = require("./validators/isImmutable.js"); +var _isLet = require("./validators/isLet.js"); +var _isNode = require("./validators/isNode.js"); +var _isNodesEquivalent = require("./validators/isNodesEquivalent.js"); +var _isPlaceholderType = require("./validators/isPlaceholderType.js"); +var _isReferenced = require("./validators/isReferenced.js"); +var _isScope = require("./validators/isScope.js"); +var _isSpecifierDefault = require("./validators/isSpecifierDefault.js"); +var _isType = require("./validators/isType.js"); +var _isValidES3Identifier = require("./validators/isValidES3Identifier.js"); +var _isValidIdentifier = require("./validators/isValidIdentifier.js"); +var _isVar = require("./validators/isVar.js"); +var _matchesPattern = require("./validators/matchesPattern.js"); +var _validate = require("./validators/validate.js"); +var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression.js"); +var _index6 = require("./validators/generated/index.js"); +Object.keys(_index6).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; + if (key in exports && exports[key] === _index6[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _index6[key]; + } + }); +}); +var _deprecationWarning = require("./utils/deprecationWarning.js"); +var _toSequenceExpression = require("./converters/toSequenceExpression.js"); +const react = exports.react = { + isReactComponent: _isReactComponent.default, + isCompatTag: _isCompatTag.default, + buildChildren: _buildChildren.default +}; +exports.toSequenceExpression = _toSequenceExpression.default; +if (process.env.BABEL_TYPES_8_BREAKING) { + console.warn("BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!"); +} + +//# sourceMappingURL=index.js.map + +}, function(modId) {var map = {"./validators/react/isReactComponent.js":1771034509020,"./validators/react/isCompatTag.js":1771034509026,"./builders/react/buildChildren.js":1771034509027,"./asserts/assertNode.js":1771034509048,"./asserts/generated/index.js":1771034509050,"./builders/flow/createTypeAnnotationBasedOnTypeof.js":1771034509051,"./builders/flow/createFlowUnionType.js":1771034509052,"./builders/typescript/createTSUnionType.js":1771034509054,"./builders/productions.js":1771034509056,"./builders/generated/index.js":1771034509029,"./clone/cloneNode.js":1771034509057,"./clone/clone.js":1771034509058,"./clone/cloneDeep.js":1771034509059,"./clone/cloneDeepWithoutLoc.js":1771034509060,"./clone/cloneWithoutLoc.js":1771034509061,"./comments/addComment.js":1771034509062,"./comments/addComments.js":1771034509063,"./comments/inheritInnerComments.js":1771034509064,"./comments/inheritLeadingComments.js":1771034509066,"./comments/inheritsComments.js":1771034509067,"./comments/inheritTrailingComments.js":1771034509068,"./comments/removeComments.js":1771034509069,"./constants/generated/index.js":1771034509070,"./constants/index.js":1771034509038,"./converters/ensureBlock.js":1771034509071,"./converters/toBindingIdentifierName.js":1771034509073,"./converters/toBlock.js":1771034509072,"./converters/toComputedKey.js":1771034509075,"./converters/toExpression.js":1771034509076,"./converters/toIdentifier.js":1771034509074,"./converters/toKeyAlias.js":1771034509077,"./converters/toStatement.js":1771034509081,"./converters/valueToNode.js":1771034509082,"./definitions/index.js":1771034509032,"./modifications/appendToMemberExpression.js":1771034509083,"./modifications/inherits.js":1771034509084,"./modifications/prependToMemberExpression.js":1771034509085,"./modifications/removeProperties.js":1771034509080,"./modifications/removePropertiesDeep.js":1771034509078,"./modifications/flow/removeTypeDuplicates.js":1771034509053,"./retrievers/getAssignmentIdentifiers.js":1771034509086,"./retrievers/getBindingIdentifiers.js":1771034509087,"./retrievers/getOuterBindingIdentifiers.js":1771034509088,"./retrievers/getFunctionName.js":1771034509089,"./traverse/traverse.js":1771034509090,"./traverse/traverseFast.js":1771034509079,"./utils/shallowEqual.js":1771034509024,"./validators/is.js":1771034509034,"./validators/isBinding.js":1771034509091,"./validators/isBlockScoped.js":1771034509092,"./validators/isImmutable.js":1771034509094,"./validators/isLet.js":1771034509093,"./validators/isNode.js":1771034509049,"./validators/isNodesEquivalent.js":1771034509095,"./validators/isPlaceholderType.js":1771034509036,"./validators/isReferenced.js":1771034509096,"./validators/isScope.js":1771034509097,"./validators/isSpecifierDefault.js":1771034509098,"./validators/isType.js":1771034509035,"./validators/isValidES3Identifier.js":1771034509099,"./validators/isValidIdentifier.js":1771034509037,"./validators/isVar.js":1771034509100,"./validators/matchesPattern.js":1771034509022,"./validators/validate.js":1771034509031,"./validators/buildMatchMemberExpression.js":1771034509021,"./validators/generated/index.js":1771034509023,"./utils/deprecationWarning.js":1771034509025,"./converters/toSequenceExpression.js":1771034509101}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509020, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _buildMatchMemberExpression = require("../buildMatchMemberExpression.js"); +const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component"); +var _default = exports.default = isReactComponent; + +//# sourceMappingURL=isReactComponent.js.map + +}, function(modId) { var map = {"../buildMatchMemberExpression.js":1771034509021}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509021, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = buildMatchMemberExpression; +var _matchesPattern = require("./matchesPattern.js"); +function buildMatchMemberExpression(match, allowPartial) { + const parts = match.split("."); + return member => (0, _matchesPattern.default)(member, parts, allowPartial); +} + +//# sourceMappingURL=buildMatchMemberExpression.js.map + +}, function(modId) { var map = {"./matchesPattern.js":1771034509022}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509022, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = matchesPattern; +var _index = require("./generated/index.js"); +function isMemberExpressionLike(node) { + return (0, _index.isMemberExpression)(node) || (0, _index.isMetaProperty)(node); +} +function matchesPattern(member, match, allowPartial) { + if (!isMemberExpressionLike(member)) return false; + const parts = Array.isArray(match) ? match : match.split("."); + const nodes = []; + let node; + for (node = member; isMemberExpressionLike(node); node = (_object = node.object) != null ? _object : node.meta) { + var _object; + nodes.push(node.property); + } + nodes.push(node); + if (nodes.length < parts.length) return false; + if (!allowPartial && nodes.length > parts.length) return false; + for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) { + const node = nodes[j]; + let value; + if ((0, _index.isIdentifier)(node)) { + value = node.name; + } else if ((0, _index.isStringLiteral)(node)) { + value = node.value; + } else if ((0, _index.isThisExpression)(node)) { + value = "this"; + } else if ((0, _index.isSuper)(node)) { + value = "super"; + } else if ((0, _index.isPrivateName)(node)) { + value = "#" + node.id.name; + } else { + return false; + } + if (parts[i] !== value) return false; + } + return true; +} + +//# sourceMappingURL=matchesPattern.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509023, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isAccessor = isAccessor; +exports.isAnyTypeAnnotation = isAnyTypeAnnotation; +exports.isArgumentPlaceholder = isArgumentPlaceholder; +exports.isArrayExpression = isArrayExpression; +exports.isArrayPattern = isArrayPattern; +exports.isArrayTypeAnnotation = isArrayTypeAnnotation; +exports.isArrowFunctionExpression = isArrowFunctionExpression; +exports.isAssignmentExpression = isAssignmentExpression; +exports.isAssignmentPattern = isAssignmentPattern; +exports.isAwaitExpression = isAwaitExpression; +exports.isBigIntLiteral = isBigIntLiteral; +exports.isBinary = isBinary; +exports.isBinaryExpression = isBinaryExpression; +exports.isBindExpression = isBindExpression; +exports.isBlock = isBlock; +exports.isBlockParent = isBlockParent; +exports.isBlockStatement = isBlockStatement; +exports.isBooleanLiteral = isBooleanLiteral; +exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; +exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; +exports.isBreakStatement = isBreakStatement; +exports.isCallExpression = isCallExpression; +exports.isCatchClause = isCatchClause; +exports.isClass = isClass; +exports.isClassAccessorProperty = isClassAccessorProperty; +exports.isClassBody = isClassBody; +exports.isClassDeclaration = isClassDeclaration; +exports.isClassExpression = isClassExpression; +exports.isClassImplements = isClassImplements; +exports.isClassMethod = isClassMethod; +exports.isClassPrivateMethod = isClassPrivateMethod; +exports.isClassPrivateProperty = isClassPrivateProperty; +exports.isClassProperty = isClassProperty; +exports.isCompletionStatement = isCompletionStatement; +exports.isConditional = isConditional; +exports.isConditionalExpression = isConditionalExpression; +exports.isContinueStatement = isContinueStatement; +exports.isDebuggerStatement = isDebuggerStatement; +exports.isDecimalLiteral = isDecimalLiteral; +exports.isDeclaration = isDeclaration; +exports.isDeclareClass = isDeclareClass; +exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; +exports.isDeclareExportDeclaration = isDeclareExportDeclaration; +exports.isDeclareFunction = isDeclareFunction; +exports.isDeclareInterface = isDeclareInterface; +exports.isDeclareModule = isDeclareModule; +exports.isDeclareModuleExports = isDeclareModuleExports; +exports.isDeclareOpaqueType = isDeclareOpaqueType; +exports.isDeclareTypeAlias = isDeclareTypeAlias; +exports.isDeclareVariable = isDeclareVariable; +exports.isDeclaredPredicate = isDeclaredPredicate; +exports.isDecorator = isDecorator; +exports.isDirective = isDirective; +exports.isDirectiveLiteral = isDirectiveLiteral; +exports.isDoExpression = isDoExpression; +exports.isDoWhileStatement = isDoWhileStatement; +exports.isEmptyStatement = isEmptyStatement; +exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; +exports.isEnumBody = isEnumBody; +exports.isEnumBooleanBody = isEnumBooleanBody; +exports.isEnumBooleanMember = isEnumBooleanMember; +exports.isEnumDeclaration = isEnumDeclaration; +exports.isEnumDefaultedMember = isEnumDefaultedMember; +exports.isEnumMember = isEnumMember; +exports.isEnumNumberBody = isEnumNumberBody; +exports.isEnumNumberMember = isEnumNumberMember; +exports.isEnumStringBody = isEnumStringBody; +exports.isEnumStringMember = isEnumStringMember; +exports.isEnumSymbolBody = isEnumSymbolBody; +exports.isExistsTypeAnnotation = isExistsTypeAnnotation; +exports.isExportAllDeclaration = isExportAllDeclaration; +exports.isExportDeclaration = isExportDeclaration; +exports.isExportDefaultDeclaration = isExportDefaultDeclaration; +exports.isExportDefaultSpecifier = isExportDefaultSpecifier; +exports.isExportNamedDeclaration = isExportNamedDeclaration; +exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier; +exports.isExportSpecifier = isExportSpecifier; +exports.isExpression = isExpression; +exports.isExpressionStatement = isExpressionStatement; +exports.isExpressionWrapper = isExpressionWrapper; +exports.isFile = isFile; +exports.isFlow = isFlow; +exports.isFlowBaseAnnotation = isFlowBaseAnnotation; +exports.isFlowDeclaration = isFlowDeclaration; +exports.isFlowPredicate = isFlowPredicate; +exports.isFlowType = isFlowType; +exports.isFor = isFor; +exports.isForInStatement = isForInStatement; +exports.isForOfStatement = isForOfStatement; +exports.isForStatement = isForStatement; +exports.isForXStatement = isForXStatement; +exports.isFunction = isFunction; +exports.isFunctionDeclaration = isFunctionDeclaration; +exports.isFunctionExpression = isFunctionExpression; +exports.isFunctionParameter = isFunctionParameter; +exports.isFunctionParent = isFunctionParent; +exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; +exports.isFunctionTypeParam = isFunctionTypeParam; +exports.isGenericTypeAnnotation = isGenericTypeAnnotation; +exports.isIdentifier = isIdentifier; +exports.isIfStatement = isIfStatement; +exports.isImmutable = isImmutable; +exports.isImport = isImport; +exports.isImportAttribute = isImportAttribute; +exports.isImportDeclaration = isImportDeclaration; +exports.isImportDefaultSpecifier = isImportDefaultSpecifier; +exports.isImportExpression = isImportExpression; +exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; +exports.isImportOrExportDeclaration = isImportOrExportDeclaration; +exports.isImportSpecifier = isImportSpecifier; +exports.isIndexedAccessType = isIndexedAccessType; +exports.isInferredPredicate = isInferredPredicate; +exports.isInterfaceDeclaration = isInterfaceDeclaration; +exports.isInterfaceExtends = isInterfaceExtends; +exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; +exports.isInterpreterDirective = isInterpreterDirective; +exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; +exports.isJSX = isJSX; +exports.isJSXAttribute = isJSXAttribute; +exports.isJSXClosingElement = isJSXClosingElement; +exports.isJSXClosingFragment = isJSXClosingFragment; +exports.isJSXElement = isJSXElement; +exports.isJSXEmptyExpression = isJSXEmptyExpression; +exports.isJSXExpressionContainer = isJSXExpressionContainer; +exports.isJSXFragment = isJSXFragment; +exports.isJSXIdentifier = isJSXIdentifier; +exports.isJSXMemberExpression = isJSXMemberExpression; +exports.isJSXNamespacedName = isJSXNamespacedName; +exports.isJSXOpeningElement = isJSXOpeningElement; +exports.isJSXOpeningFragment = isJSXOpeningFragment; +exports.isJSXSpreadAttribute = isJSXSpreadAttribute; +exports.isJSXSpreadChild = isJSXSpreadChild; +exports.isJSXText = isJSXText; +exports.isLVal = isLVal; +exports.isLabeledStatement = isLabeledStatement; +exports.isLiteral = isLiteral; +exports.isLogicalExpression = isLogicalExpression; +exports.isLoop = isLoop; +exports.isMemberExpression = isMemberExpression; +exports.isMetaProperty = isMetaProperty; +exports.isMethod = isMethod; +exports.isMiscellaneous = isMiscellaneous; +exports.isMixedTypeAnnotation = isMixedTypeAnnotation; +exports.isModuleDeclaration = isModuleDeclaration; +exports.isModuleExpression = isModuleExpression; +exports.isModuleSpecifier = isModuleSpecifier; +exports.isNewExpression = isNewExpression; +exports.isNoop = isNoop; +exports.isNullLiteral = isNullLiteral; +exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; +exports.isNullableTypeAnnotation = isNullableTypeAnnotation; +exports.isNumberLiteral = isNumberLiteral; +exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; +exports.isNumberTypeAnnotation = isNumberTypeAnnotation; +exports.isNumericLiteral = isNumericLiteral; +exports.isObjectExpression = isObjectExpression; +exports.isObjectMember = isObjectMember; +exports.isObjectMethod = isObjectMethod; +exports.isObjectPattern = isObjectPattern; +exports.isObjectProperty = isObjectProperty; +exports.isObjectTypeAnnotation = isObjectTypeAnnotation; +exports.isObjectTypeCallProperty = isObjectTypeCallProperty; +exports.isObjectTypeIndexer = isObjectTypeIndexer; +exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; +exports.isObjectTypeProperty = isObjectTypeProperty; +exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; +exports.isOpaqueType = isOpaqueType; +exports.isOptionalCallExpression = isOptionalCallExpression; +exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType; +exports.isOptionalMemberExpression = isOptionalMemberExpression; +exports.isParenthesizedExpression = isParenthesizedExpression; +exports.isPattern = isPattern; +exports.isPatternLike = isPatternLike; +exports.isPipelineBareFunction = isPipelineBareFunction; +exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference; +exports.isPipelineTopicExpression = isPipelineTopicExpression; +exports.isPlaceholder = isPlaceholder; +exports.isPrivate = isPrivate; +exports.isPrivateName = isPrivateName; +exports.isProgram = isProgram; +exports.isProperty = isProperty; +exports.isPureish = isPureish; +exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; +exports.isRecordExpression = isRecordExpression; +exports.isRegExpLiteral = isRegExpLiteral; +exports.isRegexLiteral = isRegexLiteral; +exports.isRestElement = isRestElement; +exports.isRestProperty = isRestProperty; +exports.isReturnStatement = isReturnStatement; +exports.isScopable = isScopable; +exports.isSequenceExpression = isSequenceExpression; +exports.isSpreadElement = isSpreadElement; +exports.isSpreadProperty = isSpreadProperty; +exports.isStandardized = isStandardized; +exports.isStatement = isStatement; +exports.isStaticBlock = isStaticBlock; +exports.isStringLiteral = isStringLiteral; +exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; +exports.isStringTypeAnnotation = isStringTypeAnnotation; +exports.isSuper = isSuper; +exports.isSwitchCase = isSwitchCase; +exports.isSwitchStatement = isSwitchStatement; +exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation; +exports.isTSAnyKeyword = isTSAnyKeyword; +exports.isTSArrayType = isTSArrayType; +exports.isTSAsExpression = isTSAsExpression; +exports.isTSBaseType = isTSBaseType; +exports.isTSBigIntKeyword = isTSBigIntKeyword; +exports.isTSBooleanKeyword = isTSBooleanKeyword; +exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration; +exports.isTSConditionalType = isTSConditionalType; +exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration; +exports.isTSConstructorType = isTSConstructorType; +exports.isTSDeclareFunction = isTSDeclareFunction; +exports.isTSDeclareMethod = isTSDeclareMethod; +exports.isTSEntityName = isTSEntityName; +exports.isTSEnumBody = isTSEnumBody; +exports.isTSEnumDeclaration = isTSEnumDeclaration; +exports.isTSEnumMember = isTSEnumMember; +exports.isTSExportAssignment = isTSExportAssignment; +exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments; +exports.isTSExternalModuleReference = isTSExternalModuleReference; +exports.isTSFunctionType = isTSFunctionType; +exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration; +exports.isTSImportType = isTSImportType; +exports.isTSIndexSignature = isTSIndexSignature; +exports.isTSIndexedAccessType = isTSIndexedAccessType; +exports.isTSInferType = isTSInferType; +exports.isTSInstantiationExpression = isTSInstantiationExpression; +exports.isTSInterfaceBody = isTSInterfaceBody; +exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration; +exports.isTSIntersectionType = isTSIntersectionType; +exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword; +exports.isTSLiteralType = isTSLiteralType; +exports.isTSMappedType = isTSMappedType; +exports.isTSMethodSignature = isTSMethodSignature; +exports.isTSModuleBlock = isTSModuleBlock; +exports.isTSModuleDeclaration = isTSModuleDeclaration; +exports.isTSNamedTupleMember = isTSNamedTupleMember; +exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration; +exports.isTSNeverKeyword = isTSNeverKeyword; +exports.isTSNonNullExpression = isTSNonNullExpression; +exports.isTSNullKeyword = isTSNullKeyword; +exports.isTSNumberKeyword = isTSNumberKeyword; +exports.isTSObjectKeyword = isTSObjectKeyword; +exports.isTSOptionalType = isTSOptionalType; +exports.isTSParameterProperty = isTSParameterProperty; +exports.isTSParenthesizedType = isTSParenthesizedType; +exports.isTSPropertySignature = isTSPropertySignature; +exports.isTSQualifiedName = isTSQualifiedName; +exports.isTSRestType = isTSRestType; +exports.isTSSatisfiesExpression = isTSSatisfiesExpression; +exports.isTSStringKeyword = isTSStringKeyword; +exports.isTSSymbolKeyword = isTSSymbolKeyword; +exports.isTSTemplateLiteralType = isTSTemplateLiteralType; +exports.isTSThisType = isTSThisType; +exports.isTSTupleType = isTSTupleType; +exports.isTSType = isTSType; +exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration; +exports.isTSTypeAnnotation = isTSTypeAnnotation; +exports.isTSTypeAssertion = isTSTypeAssertion; +exports.isTSTypeElement = isTSTypeElement; +exports.isTSTypeLiteral = isTSTypeLiteral; +exports.isTSTypeOperator = isTSTypeOperator; +exports.isTSTypeParameter = isTSTypeParameter; +exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration; +exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation; +exports.isTSTypePredicate = isTSTypePredicate; +exports.isTSTypeQuery = isTSTypeQuery; +exports.isTSTypeReference = isTSTypeReference; +exports.isTSUndefinedKeyword = isTSUndefinedKeyword; +exports.isTSUnionType = isTSUnionType; +exports.isTSUnknownKeyword = isTSUnknownKeyword; +exports.isTSVoidKeyword = isTSVoidKeyword; +exports.isTaggedTemplateExpression = isTaggedTemplateExpression; +exports.isTemplateElement = isTemplateElement; +exports.isTemplateLiteral = isTemplateLiteral; +exports.isTerminatorless = isTerminatorless; +exports.isThisExpression = isThisExpression; +exports.isThisTypeAnnotation = isThisTypeAnnotation; +exports.isThrowStatement = isThrowStatement; +exports.isTopicReference = isTopicReference; +exports.isTryStatement = isTryStatement; +exports.isTupleExpression = isTupleExpression; +exports.isTupleTypeAnnotation = isTupleTypeAnnotation; +exports.isTypeAlias = isTypeAlias; +exports.isTypeAnnotation = isTypeAnnotation; +exports.isTypeCastExpression = isTypeCastExpression; +exports.isTypeParameter = isTypeParameter; +exports.isTypeParameterDeclaration = isTypeParameterDeclaration; +exports.isTypeParameterInstantiation = isTypeParameterInstantiation; +exports.isTypeScript = isTypeScript; +exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; +exports.isUnaryExpression = isUnaryExpression; +exports.isUnaryLike = isUnaryLike; +exports.isUnionTypeAnnotation = isUnionTypeAnnotation; +exports.isUpdateExpression = isUpdateExpression; +exports.isUserWhitespacable = isUserWhitespacable; +exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier; +exports.isVariableDeclaration = isVariableDeclaration; +exports.isVariableDeclarator = isVariableDeclarator; +exports.isVariance = isVariance; +exports.isVoidPattern = isVoidPattern; +exports.isVoidTypeAnnotation = isVoidTypeAnnotation; +exports.isWhile = isWhile; +exports.isWhileStatement = isWhileStatement; +exports.isWithStatement = isWithStatement; +exports.isYieldExpression = isYieldExpression; +var _shallowEqual = require("../../utils/shallowEqual.js"); +var _deprecationWarning = require("../../utils/deprecationWarning.js"); +function isArrayExpression(node, opts) { + if (!node) return false; + if (node.type !== "ArrayExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAssignmentExpression(node, opts) { + if (!node) return false; + if (node.type !== "AssignmentExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBinaryExpression(node, opts) { + if (!node) return false; + if (node.type !== "BinaryExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterpreterDirective(node, opts) { + if (!node) return false; + if (node.type !== "InterpreterDirective") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDirective(node, opts) { + if (!node) return false; + if (node.type !== "Directive") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDirectiveLiteral(node, opts) { + if (!node) return false; + if (node.type !== "DirectiveLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlockStatement(node, opts) { + if (!node) return false; + if (node.type !== "BlockStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBreakStatement(node, opts) { + if (!node) return false; + if (node.type !== "BreakStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCallExpression(node, opts) { + if (!node) return false; + if (node.type !== "CallExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCatchClause(node, opts) { + if (!node) return false; + if (node.type !== "CatchClause") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isConditionalExpression(node, opts) { + if (!node) return false; + if (node.type !== "ConditionalExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isContinueStatement(node, opts) { + if (!node) return false; + if (node.type !== "ContinueStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDebuggerStatement(node, opts) { + if (!node) return false; + if (node.type !== "DebuggerStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDoWhileStatement(node, opts) { + if (!node) return false; + if (node.type !== "DoWhileStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEmptyStatement(node, opts) { + if (!node) return false; + if (node.type !== "EmptyStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpressionStatement(node, opts) { + if (!node) return false; + if (node.type !== "ExpressionStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFile(node, opts) { + if (!node) return false; + if (node.type !== "File") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForInStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForInStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "FunctionDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionExpression(node, opts) { + if (!node) return false; + if (node.type !== "FunctionExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "Identifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIfStatement(node, opts) { + if (!node) return false; + if (node.type !== "IfStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLabeledStatement(node, opts) { + if (!node) return false; + if (node.type !== "LabeledStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringLiteral(node, opts) { + if (!node) return false; + if (node.type !== "StringLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumericLiteral(node, opts) { + if (!node) return false; + if (node.type !== "NumericLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullLiteral(node, opts) { + if (!node) return false; + if (node.type !== "NullLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanLiteral(node, opts) { + if (!node) return false; + if (node.type !== "BooleanLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRegExpLiteral(node, opts) { + if (!node) return false; + if (node.type !== "RegExpLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLogicalExpression(node, opts) { + if (!node) return false; + if (node.type !== "LogicalExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "MemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNewExpression(node, opts) { + if (!node) return false; + if (node.type !== "NewExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isProgram(node, opts) { + if (!node) return false; + if (node.type !== "Program") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectExpression(node, opts) { + if (!node) return false; + if (node.type !== "ObjectExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectMethod(node, opts) { + if (!node) return false; + if (node.type !== "ObjectMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRestElement(node, opts) { + if (!node) return false; + if (node.type !== "RestElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isReturnStatement(node, opts) { + if (!node) return false; + if (node.type !== "ReturnStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSequenceExpression(node, opts) { + if (!node) return false; + if (node.type !== "SequenceExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isParenthesizedExpression(node, opts) { + if (!node) return false; + if (node.type !== "ParenthesizedExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSwitchCase(node, opts) { + if (!node) return false; + if (node.type !== "SwitchCase") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSwitchStatement(node, opts) { + if (!node) return false; + if (node.type !== "SwitchStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThisExpression(node, opts) { + if (!node) return false; + if (node.type !== "ThisExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThrowStatement(node, opts) { + if (!node) return false; + if (node.type !== "ThrowStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTryStatement(node, opts) { + if (!node) return false; + if (node.type !== "TryStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnaryExpression(node, opts) { + if (!node) return false; + if (node.type !== "UnaryExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUpdateExpression(node, opts) { + if (!node) return false; + if (node.type !== "UpdateExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariableDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "VariableDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariableDeclarator(node, opts) { + if (!node) return false; + if (node.type !== "VariableDeclarator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWhileStatement(node, opts) { + if (!node) return false; + if (node.type !== "WhileStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWithStatement(node, opts) { + if (!node) return false; + if (node.type !== "WithStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAssignmentPattern(node, opts) { + if (!node) return false; + if (node.type !== "AssignmentPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrayPattern(node, opts) { + if (!node) return false; + if (node.type !== "ArrayPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrowFunctionExpression(node, opts) { + if (!node) return false; + if (node.type !== "ArrowFunctionExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassBody(node, opts) { + if (!node) return false; + if (node.type !== "ClassBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassExpression(node, opts) { + if (!node) return false; + if (node.type !== "ClassExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ClassDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportAllDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportAllDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDefaultDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportDefaultDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportNamedDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ExportNamedDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForOfStatement(node, opts) { + if (!node) return false; + if (node.type !== "ForOfStatement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "ImportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportDefaultSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportDefaultSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportNamespaceSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportNamespaceSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ImportSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportExpression(node, opts) { + if (!node) return false; + if (node.type !== "ImportExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMetaProperty(node, opts) { + if (!node) return false; + if (node.type !== "MetaProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassMethod(node, opts) { + if (!node) return false; + if (node.type !== "ClassMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectPattern(node, opts) { + if (!node) return false; + if (node.type !== "ObjectPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSpreadElement(node, opts) { + if (!node) return false; + if (node.type !== "SpreadElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSuper(node, opts) { + if (!node) return false; + if (node.type !== "Super") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTaggedTemplateExpression(node, opts) { + if (!node) return false; + if (node.type !== "TaggedTemplateExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTemplateElement(node, opts) { + if (!node) return false; + if (node.type !== "TemplateElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTemplateLiteral(node, opts) { + if (!node) return false; + if (node.type !== "TemplateLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isYieldExpression(node, opts) { + if (!node) return false; + if (node.type !== "YieldExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAwaitExpression(node, opts) { + if (!node) return false; + if (node.type !== "AwaitExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImport(node, opts) { + if (!node) return false; + if (node.type !== "Import") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBigIntLiteral(node, opts) { + if (!node) return false; + if (node.type !== "BigIntLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportNamespaceSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportNamespaceSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "OptionalMemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalCallExpression(node, opts) { + if (!node) return false; + if (node.type !== "OptionalCallExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassAccessorProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassAccessorProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassPrivateProperty(node, opts) { + if (!node) return false; + if (node.type !== "ClassPrivateProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassPrivateMethod(node, opts) { + if (!node) return false; + if (node.type !== "ClassPrivateMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPrivateName(node, opts) { + if (!node) return false; + if (node.type !== "PrivateName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStaticBlock(node, opts) { + if (!node) return false; + if (node.type !== "StaticBlock") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportAttribute(node, opts) { + if (!node) return false; + if (node.type !== "ImportAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAnyTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "AnyTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArrayTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ArrayTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "BooleanTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBooleanLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "BooleanLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NullLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClassImplements(node, opts) { + if (!node) return false; + if (node.type !== "ClassImplements") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareClass(node, opts) { + if (!node) return false; + if (node.type !== "DeclareClass") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareFunction(node, opts) { + if (!node) return false; + if (node.type !== "DeclareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareInterface(node, opts) { + if (!node) return false; + if (node.type !== "DeclareInterface") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareModule(node, opts) { + if (!node) return false; + if (node.type !== "DeclareModule") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareModuleExports(node, opts) { + if (!node) return false; + if (node.type !== "DeclareModuleExports") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareTypeAlias(node, opts) { + if (!node) return false; + if (node.type !== "DeclareTypeAlias") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareOpaqueType(node, opts) { + if (!node) return false; + if (node.type !== "DeclareOpaqueType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareVariable(node, opts) { + if (!node) return false; + if (node.type !== "DeclareVariable") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareExportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "DeclareExportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclareExportAllDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "DeclareExportAllDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclaredPredicate(node, opts) { + if (!node) return false; + if (node.type !== "DeclaredPredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExistsTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ExistsTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "FunctionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionTypeParam(node, opts) { + if (!node) return false; + if (node.type !== "FunctionTypeParam") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isGenericTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "GenericTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInferredPredicate(node, opts) { + if (!node) return false; + if (node.type !== "InferredPredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceExtends(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceExtends") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isInterfaceTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "InterfaceTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIntersectionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "IntersectionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMixedTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "MixedTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEmptyTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "EmptyTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNullableTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NullableTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NumberLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "NumberTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeInternalSlot(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeInternalSlot") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeCallProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeCallProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeIndexer(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeIndexer") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectTypeSpreadProperty(node, opts) { + if (!node) return false; + if (node.type !== "ObjectTypeSpreadProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOpaqueType(node, opts) { + if (!node) return false; + if (node.type !== "OpaqueType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isQualifiedTypeIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "QualifiedTypeIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringLiteralTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "StringLiteralTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStringTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "StringTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSymbolTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "SymbolTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isThisTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "ThisTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTupleTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TupleTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeofTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TypeofTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeAlias(node, opts) { + if (!node) return false; + if (node.type !== "TypeAlias") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeCastExpression(node, opts) { + if (!node) return false; + if (node.type !== "TypeCastExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameter(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameter") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameterDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameterDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeParameterInstantiation(node, opts) { + if (!node) return false; + if (node.type !== "TypeParameterInstantiation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnionTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "UnionTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVariance(node, opts) { + if (!node) return false; + if (node.type !== "Variance") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVoidTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "VoidTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "EnumDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBooleanBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumBooleanBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumNumberBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumNumberBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumStringBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumStringBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumSymbolBody(node, opts) { + if (!node) return false; + if (node.type !== "EnumSymbolBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBooleanMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumBooleanMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumNumberMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumNumberMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumStringMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumStringMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumDefaultedMember(node, opts) { + if (!node) return false; + if (node.type !== "EnumDefaultedMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "IndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isOptionalIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "OptionalIndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXAttribute(node, opts) { + if (!node) return false; + if (node.type !== "JSXAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXClosingElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXClosingElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXEmptyExpression(node, opts) { + if (!node) return false; + if (node.type !== "JSXEmptyExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXExpressionContainer(node, opts) { + if (!node) return false; + if (node.type !== "JSXExpressionContainer") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXSpreadChild(node, opts) { + if (!node) return false; + if (node.type !== "JSXSpreadChild") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "JSXIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXMemberExpression(node, opts) { + if (!node) return false; + if (node.type !== "JSXMemberExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXNamespacedName(node, opts) { + if (!node) return false; + if (node.type !== "JSXNamespacedName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXOpeningElement(node, opts) { + if (!node) return false; + if (node.type !== "JSXOpeningElement") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXSpreadAttribute(node, opts) { + if (!node) return false; + if (node.type !== "JSXSpreadAttribute") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXText(node, opts) { + if (!node) return false; + if (node.type !== "JSXText") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXOpeningFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXOpeningFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSXClosingFragment(node, opts) { + if (!node) return false; + if (node.type !== "JSXClosingFragment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNoop(node, opts) { + if (!node) return false; + if (node.type !== "Noop") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPlaceholder(node, opts) { + if (!node) return false; + if (node.type !== "Placeholder") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isV8IntrinsicIdentifier(node, opts) { + if (!node) return false; + if (node.type !== "V8IntrinsicIdentifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isArgumentPlaceholder(node, opts) { + if (!node) return false; + if (node.type !== "ArgumentPlaceholder") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBindExpression(node, opts) { + if (!node) return false; + if (node.type !== "BindExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDecorator(node, opts) { + if (!node) return false; + if (node.type !== "Decorator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDoExpression(node, opts) { + if (!node) return false; + if (node.type !== "DoExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDefaultSpecifier(node, opts) { + if (!node) return false; + if (node.type !== "ExportDefaultSpecifier") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRecordExpression(node, opts) { + if (!node) return false; + if (node.type !== "RecordExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTupleExpression(node, opts) { + if (!node) return false; + if (node.type !== "TupleExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDecimalLiteral(node, opts) { + if (!node) return false; + if (node.type !== "DecimalLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleExpression(node, opts) { + if (!node) return false; + if (node.type !== "ModuleExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTopicReference(node, opts) { + if (!node) return false; + if (node.type !== "TopicReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelineTopicExpression(node, opts) { + if (!node) return false; + if (node.type !== "PipelineTopicExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelineBareFunction(node, opts) { + if (!node) return false; + if (node.type !== "PipelineBareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPipelinePrimaryTopicReference(node, opts) { + if (!node) return false; + if (node.type !== "PipelinePrimaryTopicReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isVoidPattern(node, opts) { + if (!node) return false; + if (node.type !== "VoidPattern") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSParameterProperty(node, opts) { + if (!node) return false; + if (node.type !== "TSParameterProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSDeclareFunction(node, opts) { + if (!node) return false; + if (node.type !== "TSDeclareFunction") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSDeclareMethod(node, opts) { + if (!node) return false; + if (node.type !== "TSDeclareMethod") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSQualifiedName(node, opts) { + if (!node) return false; + if (node.type !== "TSQualifiedName") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSCallSignatureDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSCallSignatureDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConstructSignatureDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSConstructSignatureDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSPropertySignature(node, opts) { + if (!node) return false; + if (node.type !== "TSPropertySignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSMethodSignature(node, opts) { + if (!node) return false; + if (node.type !== "TSMethodSignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIndexSignature(node, opts) { + if (!node) return false; + if (node.type !== "TSIndexSignature") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSAnyKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSAnyKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBooleanKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSBooleanKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBigIntKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSBigIntKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIntrinsicKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSIntrinsicKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNeverKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNeverKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNullKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNullKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNumberKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSNumberKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSObjectKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSObjectKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSStringKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSStringKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSSymbolKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSSymbolKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUndefinedKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSUndefinedKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUnknownKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSUnknownKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSVoidKeyword(node, opts) { + if (!node) return false; + if (node.type !== "TSVoidKeyword") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSThisType(node, opts) { + if (!node) return false; + if (node.type !== "TSThisType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSFunctionType(node, opts) { + if (!node) return false; + if (node.type !== "TSFunctionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConstructorType(node, opts) { + if (!node) return false; + if (node.type !== "TSConstructorType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeReference(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypePredicate(node, opts) { + if (!node) return false; + if (node.type !== "TSTypePredicate") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeQuery(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeQuery") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeLiteral(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSArrayType(node, opts) { + if (!node) return false; + if (node.type !== "TSArrayType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTupleType(node, opts) { + if (!node) return false; + if (node.type !== "TSTupleType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSOptionalType(node, opts) { + if (!node) return false; + if (node.type !== "TSOptionalType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSRestType(node, opts) { + if (!node) return false; + if (node.type !== "TSRestType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNamedTupleMember(node, opts) { + if (!node) return false; + if (node.type !== "TSNamedTupleMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSUnionType(node, opts) { + if (!node) return false; + if (node.type !== "TSUnionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIntersectionType(node, opts) { + if (!node) return false; + if (node.type !== "TSIntersectionType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSConditionalType(node, opts) { + if (!node) return false; + if (node.type !== "TSConditionalType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInferType(node, opts) { + if (!node) return false; + if (node.type !== "TSInferType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSParenthesizedType(node, opts) { + if (!node) return false; + if (node.type !== "TSParenthesizedType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeOperator(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeOperator") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSIndexedAccessType(node, opts) { + if (!node) return false; + if (node.type !== "TSIndexedAccessType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSMappedType(node, opts) { + if (!node) return false; + if (node.type !== "TSMappedType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTemplateLiteralType(node, opts) { + if (!node) return false; + if (node.type !== "TSTemplateLiteralType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSLiteralType(node, opts) { + if (!node) return false; + if (node.type !== "TSLiteralType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExpressionWithTypeArguments(node, opts) { + if (!node) return false; + if (node.type !== "TSExpressionWithTypeArguments") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInterfaceDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSInterfaceDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInterfaceBody(node, opts) { + if (!node) return false; + if (node.type !== "TSInterfaceBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAliasDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAliasDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSInstantiationExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSInstantiationExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSAsExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSAsExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSSatisfiesExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSSatisfiesExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAssertion(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAssertion") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumBody(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumBody") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEnumMember(node, opts) { + if (!node) return false; + if (node.type !== "TSEnumMember") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSModuleDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSModuleDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSModuleBlock(node, opts) { + if (!node) return false; + if (node.type !== "TSModuleBlock") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSImportType(node, opts) { + if (!node) return false; + if (node.type !== "TSImportType") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSImportEqualsDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSImportEqualsDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExternalModuleReference(node, opts) { + if (!node) return false; + if (node.type !== "TSExternalModuleReference") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNonNullExpression(node, opts) { + if (!node) return false; + if (node.type !== "TSNonNullExpression") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSExportAssignment(node, opts) { + if (!node) return false; + if (node.type !== "TSExportAssignment") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSNamespaceExportDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSNamespaceExportDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeAnnotation(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeAnnotation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameterInstantiation(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameterInstantiation") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameterDeclaration(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameterDeclaration") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeParameter(node, opts) { + if (!node) return false; + if (node.type !== "TSTypeParameter") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStandardized(node, opts) { + if (!node) return false; + switch (node.type) { + case "ArrayExpression": + case "AssignmentExpression": + case "BinaryExpression": + case "InterpreterDirective": + case "Directive": + case "DirectiveLiteral": + case "BlockStatement": + case "BreakStatement": + case "CallExpression": + case "CatchClause": + case "ConditionalExpression": + case "ContinueStatement": + case "DebuggerStatement": + case "DoWhileStatement": + case "EmptyStatement": + case "ExpressionStatement": + case "File": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Identifier": + case "IfStatement": + case "LabeledStatement": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "LogicalExpression": + case "MemberExpression": + case "NewExpression": + case "Program": + case "ObjectExpression": + case "ObjectMethod": + case "ObjectProperty": + case "RestElement": + case "ReturnStatement": + case "SequenceExpression": + case "ParenthesizedExpression": + case "SwitchCase": + case "SwitchStatement": + case "ThisExpression": + case "ThrowStatement": + case "TryStatement": + case "UnaryExpression": + case "UpdateExpression": + case "VariableDeclaration": + case "VariableDeclarator": + case "WhileStatement": + case "WithStatement": + case "AssignmentPattern": + case "ArrayPattern": + case "ArrowFunctionExpression": + case "ClassBody": + case "ClassExpression": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ExportSpecifier": + case "ForOfStatement": + case "ImportDeclaration": + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + case "ImportExpression": + case "MetaProperty": + case "ClassMethod": + case "ObjectPattern": + case "SpreadElement": + case "Super": + case "TaggedTemplateExpression": + case "TemplateElement": + case "TemplateLiteral": + case "YieldExpression": + case "AwaitExpression": + case "Import": + case "BigIntLiteral": + case "ExportNamespaceSpecifier": + case "OptionalMemberExpression": + case "OptionalCallExpression": + case "ClassProperty": + case "ClassAccessorProperty": + case "ClassPrivateProperty": + case "ClassPrivateMethod": + case "PrivateName": + case "StaticBlock": + case "ImportAttribute": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Identifier": + case "StringLiteral": + case "BlockStatement": + case "ClassBody": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpression(node, opts) { + if (!node) return false; + switch (node.type) { + case "ArrayExpression": + case "AssignmentExpression": + case "BinaryExpression": + case "CallExpression": + case "ConditionalExpression": + case "FunctionExpression": + case "Identifier": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "LogicalExpression": + case "MemberExpression": + case "NewExpression": + case "ObjectExpression": + case "SequenceExpression": + case "ParenthesizedExpression": + case "ThisExpression": + case "UnaryExpression": + case "UpdateExpression": + case "ArrowFunctionExpression": + case "ClassExpression": + case "ImportExpression": + case "MetaProperty": + case "Super": + case "TaggedTemplateExpression": + case "TemplateLiteral": + case "YieldExpression": + case "AwaitExpression": + case "Import": + case "BigIntLiteral": + case "OptionalMemberExpression": + case "OptionalCallExpression": + case "TypeCastExpression": + case "JSXElement": + case "JSXFragment": + case "BindExpression": + case "DoExpression": + case "RecordExpression": + case "TupleExpression": + case "DecimalLiteral": + case "ModuleExpression": + case "TopicReference": + case "PipelineTopicExpression": + case "PipelineBareFunction": + case "PipelinePrimaryTopicReference": + case "TSInstantiationExpression": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Expression": + case "Identifier": + case "StringLiteral": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBinary(node, opts) { + if (!node) return false; + switch (node.type) { + case "BinaryExpression": + case "LogicalExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isScopable(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "CatchClause": + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Program": + case "ObjectMethod": + case "SwitchStatement": + case "WhileStatement": + case "ArrowFunctionExpression": + case "ClassExpression": + case "ClassDeclaration": + case "ForOfStatement": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlockParent(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "CatchClause": + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "FunctionExpression": + case "Program": + case "ObjectMethod": + case "SwitchStatement": + case "WhileStatement": + case "ArrowFunctionExpression": + case "ForOfStatement": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isBlock(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "Program": + case "TSModuleBlock": + break; + case "Placeholder": + if (node.expectedNode === "BlockStatement") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "BlockStatement": + case "BreakStatement": + case "ContinueStatement": + case "DebuggerStatement": + case "DoWhileStatement": + case "EmptyStatement": + case "ExpressionStatement": + case "ForInStatement": + case "ForStatement": + case "FunctionDeclaration": + case "IfStatement": + case "LabeledStatement": + case "ReturnStatement": + case "SwitchStatement": + case "ThrowStatement": + case "TryStatement": + case "VariableDeclaration": + case "WhileStatement": + case "WithStatement": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ForOfStatement": + case "ImportDeclaration": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + case "EnumDeclaration": + case "TSDeclareFunction": + case "TSInterfaceDeclaration": + case "TSTypeAliasDeclaration": + case "TSEnumDeclaration": + case "TSModuleDeclaration": + case "TSImportEqualsDeclaration": + case "TSExportAssignment": + case "TSNamespaceExportDeclaration": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Statement": + case "Declaration": + case "BlockStatement": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTerminatorless(node, opts) { + if (!node) return false; + switch (node.type) { + case "BreakStatement": + case "ContinueStatement": + case "ReturnStatement": + case "ThrowStatement": + case "YieldExpression": + case "AwaitExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isCompletionStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "BreakStatement": + case "ContinueStatement": + case "ReturnStatement": + case "ThrowStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isConditional(node, opts) { + if (!node) return false; + switch (node.type) { + case "ConditionalExpression": + case "IfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLoop(node, opts) { + if (!node) return false; + switch (node.type) { + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "WhileStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isWhile(node, opts) { + if (!node) return false; + switch (node.type) { + case "DoWhileStatement": + case "WhileStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExpressionWrapper(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExpressionStatement": + case "ParenthesizedExpression": + case "TypeCastExpression": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFor(node, opts) { + if (!node) return false; + switch (node.type) { + case "ForInStatement": + case "ForStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isForXStatement(node, opts) { + if (!node) return false; + switch (node.type) { + case "ForInStatement": + case "ForOfStatement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunction(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "ObjectMethod": + case "ArrowFunctionExpression": + case "ClassMethod": + case "ClassPrivateMethod": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionParent(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "ObjectMethod": + case "ArrowFunctionExpression": + case "ClassMethod": + case "ClassPrivateMethod": + case "StaticBlock": + case "TSModuleBlock": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPureish(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "FunctionExpression": + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "ArrowFunctionExpression": + case "BigIntLiteral": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "FunctionDeclaration": + case "VariableDeclaration": + case "ClassDeclaration": + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ImportDeclaration": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + case "EnumDeclaration": + case "TSDeclareFunction": + case "TSInterfaceDeclaration": + case "TSTypeAliasDeclaration": + case "TSEnumDeclaration": + case "TSModuleDeclaration": + case "TSImportEqualsDeclaration": + break; + case "Placeholder": + if (node.expectedNode === "Declaration") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFunctionParameter(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + break; + case "Placeholder": + if (node.expectedNode === "Identifier") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPatternLike(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "MemberExpression": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Pattern": + case "Identifier": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLVal(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "MemberExpression": + case "RestElement": + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "TSParameterProperty": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + break; + case "Placeholder": + switch (node.expectedNode) { + case "Pattern": + case "Identifier": + break; + default: + return false; + } + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSEntityName(node, opts) { + if (!node) return false; + switch (node.type) { + case "Identifier": + case "TSQualifiedName": + break; + case "Placeholder": + if (node.expectedNode === "Identifier") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isLiteral(node, opts) { + if (!node) return false; + switch (node.type) { + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "RegExpLiteral": + case "TemplateLiteral": + case "BigIntLiteral": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImmutable(node, opts) { + if (!node) return false; + switch (node.type) { + case "StringLiteral": + case "NumericLiteral": + case "NullLiteral": + case "BooleanLiteral": + case "BigIntLiteral": + case "JSXAttribute": + case "JSXClosingElement": + case "JSXElement": + case "JSXExpressionContainer": + case "JSXSpreadChild": + case "JSXOpeningElement": + case "JSXText": + case "JSXFragment": + case "JSXOpeningFragment": + case "JSXClosingFragment": + case "DecimalLiteral": + break; + case "Placeholder": + if (node.expectedNode === "StringLiteral") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUserWhitespacable(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ObjectProperty": + case "ObjectTypeInternalSlot": + case "ObjectTypeCallProperty": + case "ObjectTypeIndexer": + case "ObjectTypeProperty": + case "ObjectTypeSpreadProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMethod(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ClassMethod": + case "ClassPrivateMethod": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isObjectMember(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectMethod": + case "ObjectProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isProperty(node, opts) { + if (!node) return false; + switch (node.type) { + case "ObjectProperty": + case "ClassProperty": + case "ClassAccessorProperty": + case "ClassPrivateProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isUnaryLike(node, opts) { + if (!node) return false; + switch (node.type) { + case "UnaryExpression": + case "SpreadElement": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPattern(node, opts) { + if (!node) return false; + switch (node.type) { + case "AssignmentPattern": + case "ArrayPattern": + case "ObjectPattern": + case "VoidPattern": + break; + case "Placeholder": + if (node.expectedNode === "Pattern") break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isClass(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassExpression": + case "ClassDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isImportOrExportDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + case "ImportDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isExportDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportAllDeclaration": + case "ExportDefaultDeclaration": + case "ExportNamedDeclaration": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleSpecifier(node, opts) { + if (!node) return false; + switch (node.type) { + case "ExportSpecifier": + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isAccessor(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassAccessorProperty": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isPrivate(node, opts) { + if (!node) return false; + switch (node.type) { + case "ClassPrivateProperty": + case "ClassPrivateMethod": + case "PrivateName": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlow(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "ArrayTypeAnnotation": + case "BooleanTypeAnnotation": + case "BooleanLiteralTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "ClassImplements": + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "DeclaredPredicate": + case "ExistsTypeAnnotation": + case "FunctionTypeAnnotation": + case "FunctionTypeParam": + case "GenericTypeAnnotation": + case "InferredPredicate": + case "InterfaceExtends": + case "InterfaceDeclaration": + case "InterfaceTypeAnnotation": + case "IntersectionTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NullableTypeAnnotation": + case "NumberLiteralTypeAnnotation": + case "NumberTypeAnnotation": + case "ObjectTypeAnnotation": + case "ObjectTypeInternalSlot": + case "ObjectTypeCallProperty": + case "ObjectTypeIndexer": + case "ObjectTypeProperty": + case "ObjectTypeSpreadProperty": + case "OpaqueType": + case "QualifiedTypeIdentifier": + case "StringLiteralTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "TupleTypeAnnotation": + case "TypeofTypeAnnotation": + case "TypeAlias": + case "TypeAnnotation": + case "TypeCastExpression": + case "TypeParameter": + case "TypeParameterDeclaration": + case "TypeParameterInstantiation": + case "UnionTypeAnnotation": + case "Variance": + case "VoidTypeAnnotation": + case "EnumDeclaration": + case "EnumBooleanBody": + case "EnumNumberBody": + case "EnumStringBody": + case "EnumSymbolBody": + case "EnumBooleanMember": + case "EnumNumberMember": + case "EnumStringMember": + case "EnumDefaultedMember": + case "IndexedAccessType": + case "OptionalIndexedAccessType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowType(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "ArrayTypeAnnotation": + case "BooleanTypeAnnotation": + case "BooleanLiteralTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "ExistsTypeAnnotation": + case "FunctionTypeAnnotation": + case "GenericTypeAnnotation": + case "InterfaceTypeAnnotation": + case "IntersectionTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NullableTypeAnnotation": + case "NumberLiteralTypeAnnotation": + case "NumberTypeAnnotation": + case "ObjectTypeAnnotation": + case "StringLiteralTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "TupleTypeAnnotation": + case "TypeofTypeAnnotation": + case "UnionTypeAnnotation": + case "VoidTypeAnnotation": + case "IndexedAccessType": + case "OptionalIndexedAccessType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowBaseAnnotation(node, opts) { + if (!node) return false; + switch (node.type) { + case "AnyTypeAnnotation": + case "BooleanTypeAnnotation": + case "NullLiteralTypeAnnotation": + case "MixedTypeAnnotation": + case "EmptyTypeAnnotation": + case "NumberTypeAnnotation": + case "StringTypeAnnotation": + case "SymbolTypeAnnotation": + case "ThisTypeAnnotation": + case "VoidTypeAnnotation": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowDeclaration(node, opts) { + if (!node) return false; + switch (node.type) { + case "DeclareClass": + case "DeclareFunction": + case "DeclareInterface": + case "DeclareModule": + case "DeclareModuleExports": + case "DeclareTypeAlias": + case "DeclareOpaqueType": + case "DeclareVariable": + case "DeclareExportDeclaration": + case "DeclareExportAllDeclaration": + case "InterfaceDeclaration": + case "OpaqueType": + case "TypeAlias": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isFlowPredicate(node, opts) { + if (!node) return false; + switch (node.type) { + case "DeclaredPredicate": + case "InferredPredicate": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumBody(node, opts) { + if (!node) return false; + switch (node.type) { + case "EnumBooleanBody": + case "EnumNumberBody": + case "EnumStringBody": + case "EnumSymbolBody": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isEnumMember(node, opts) { + if (!node) return false; + switch (node.type) { + case "EnumBooleanMember": + case "EnumNumberMember": + case "EnumStringMember": + case "EnumDefaultedMember": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isJSX(node, opts) { + if (!node) return false; + switch (node.type) { + case "JSXAttribute": + case "JSXClosingElement": + case "JSXElement": + case "JSXEmptyExpression": + case "JSXExpressionContainer": + case "JSXSpreadChild": + case "JSXIdentifier": + case "JSXMemberExpression": + case "JSXNamespacedName": + case "JSXOpeningElement": + case "JSXSpreadAttribute": + case "JSXText": + case "JSXFragment": + case "JSXOpeningFragment": + case "JSXClosingFragment": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isMiscellaneous(node, opts) { + if (!node) return false; + switch (node.type) { + case "Noop": + case "Placeholder": + case "V8IntrinsicIdentifier": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTypeScript(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSParameterProperty": + case "TSDeclareFunction": + case "TSDeclareMethod": + case "TSQualifiedName": + case "TSCallSignatureDeclaration": + case "TSConstructSignatureDeclaration": + case "TSPropertySignature": + case "TSMethodSignature": + case "TSIndexSignature": + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSFunctionType": + case "TSConstructorType": + case "TSTypeReference": + case "TSTypePredicate": + case "TSTypeQuery": + case "TSTypeLiteral": + case "TSArrayType": + case "TSTupleType": + case "TSOptionalType": + case "TSRestType": + case "TSNamedTupleMember": + case "TSUnionType": + case "TSIntersectionType": + case "TSConditionalType": + case "TSInferType": + case "TSParenthesizedType": + case "TSTypeOperator": + case "TSIndexedAccessType": + case "TSMappedType": + case "TSTemplateLiteralType": + case "TSLiteralType": + case "TSExpressionWithTypeArguments": + case "TSInterfaceDeclaration": + case "TSInterfaceBody": + case "TSTypeAliasDeclaration": + case "TSInstantiationExpression": + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSEnumBody": + case "TSEnumDeclaration": + case "TSEnumMember": + case "TSModuleDeclaration": + case "TSModuleBlock": + case "TSImportType": + case "TSImportEqualsDeclaration": + case "TSExternalModuleReference": + case "TSNonNullExpression": + case "TSExportAssignment": + case "TSNamespaceExportDeclaration": + case "TSTypeAnnotation": + case "TSTypeParameterInstantiation": + case "TSTypeParameterDeclaration": + case "TSTypeParameter": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSTypeElement(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSCallSignatureDeclaration": + case "TSConstructSignatureDeclaration": + case "TSPropertySignature": + case "TSMethodSignature": + case "TSIndexSignature": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSType(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSFunctionType": + case "TSConstructorType": + case "TSTypeReference": + case "TSTypePredicate": + case "TSTypeQuery": + case "TSTypeLiteral": + case "TSArrayType": + case "TSTupleType": + case "TSOptionalType": + case "TSRestType": + case "TSUnionType": + case "TSIntersectionType": + case "TSConditionalType": + case "TSInferType": + case "TSParenthesizedType": + case "TSTypeOperator": + case "TSIndexedAccessType": + case "TSMappedType": + case "TSTemplateLiteralType": + case "TSLiteralType": + case "TSExpressionWithTypeArguments": + case "TSImportType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isTSBaseType(node, opts) { + if (!node) return false; + switch (node.type) { + case "TSAnyKeyword": + case "TSBooleanKeyword": + case "TSBigIntKeyword": + case "TSIntrinsicKeyword": + case "TSNeverKeyword": + case "TSNullKeyword": + case "TSNumberKeyword": + case "TSObjectKeyword": + case "TSStringKeyword": + case "TSSymbolKeyword": + case "TSUndefinedKeyword": + case "TSUnknownKeyword": + case "TSVoidKeyword": + case "TSThisType": + case "TSTemplateLiteralType": + case "TSLiteralType": + break; + default: + return false; + } + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isNumberLiteral(node, opts) { + (0, _deprecationWarning.default)("isNumberLiteral", "isNumericLiteral"); + if (!node) return false; + if (node.type !== "NumberLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRegexLiteral(node, opts) { + (0, _deprecationWarning.default)("isRegexLiteral", "isRegExpLiteral"); + if (!node) return false; + if (node.type !== "RegexLiteral") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isRestProperty(node, opts) { + (0, _deprecationWarning.default)("isRestProperty", "isRestElement"); + if (!node) return false; + if (node.type !== "RestProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isSpreadProperty(node, opts) { + (0, _deprecationWarning.default)("isSpreadProperty", "isSpreadElement"); + if (!node) return false; + if (node.type !== "SpreadProperty") return false; + return opts == null || (0, _shallowEqual.default)(node, opts); +} +function isModuleDeclaration(node, opts) { + (0, _deprecationWarning.default)("isModuleDeclaration", "isImportOrExportDeclaration"); + return isImportOrExportDeclaration(node, opts); +} + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {"../../utils/shallowEqual.js":1771034509024,"../../utils/deprecationWarning.js":1771034509025}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509024, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = shallowEqual; +function shallowEqual(actual, expected) { + const keys = Object.keys(expected); + for (const key of keys) { + if (actual[key] !== expected[key]) { + return false; + } + } + return true; +} + +//# sourceMappingURL=shallowEqual.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509025, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = deprecationWarning; +const warnings = new Set(); +function deprecationWarning(oldName, newName, prefix = "", cacheKey = oldName) { + if (warnings.has(cacheKey)) return; + warnings.add(cacheKey); + const { + internal, + trace + } = captureShortStackTrace(1, 2); + if (internal) { + return; + } + console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`\n${trace}`); +} +function captureShortStackTrace(skip, length) { + const { + stackTraceLimit, + prepareStackTrace + } = Error; + let stackTrace; + Error.stackTraceLimit = 1 + skip + length; + Error.prepareStackTrace = function (err, stack) { + stackTrace = stack; + }; + new Error().stack; + Error.stackTraceLimit = stackTraceLimit; + Error.prepareStackTrace = prepareStackTrace; + if (!stackTrace) return { + internal: false, + trace: "" + }; + const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length); + return { + internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()), + trace: shortStackTrace.map(frame => ` at ${frame}`).join("\n") + }; +} + +//# sourceMappingURL=deprecationWarning.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509026, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isCompatTag; +function isCompatTag(tagName) { + return !!tagName && /^[a-z]/.test(tagName); +} + +//# sourceMappingURL=isCompatTag.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509027, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = buildChildren; +var _index = require("../../validators/generated/index.js"); +var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild.js"); +function buildChildren(node) { + const elements = []; + for (let i = 0; i < node.children.length; i++) { + let child = node.children[i]; + if ((0, _index.isJSXText)(child)) { + (0, _cleanJSXElementLiteralChild.default)(child, elements); + continue; + } + if ((0, _index.isJSXExpressionContainer)(child)) child = child.expression; + if ((0, _index.isJSXEmptyExpression)(child)) continue; + elements.push(child); + } + return elements; +} + +//# sourceMappingURL=buildChildren.js.map + +}, function(modId) { var map = {"../../validators/generated/index.js":1771034509023,"../../utils/react/cleanJSXElementLiteralChild.js":1771034509028}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509028, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cleanJSXElementLiteralChild; +var _index = require("../../builders/generated/index.js"); +var _index2 = require("../../index.js"); +function cleanJSXElementLiteralChild(child, args) { + const lines = child.value.split(/\r\n|\n|\r/); + let lastNonEmptyLine = 0; + for (let i = 0; i < lines.length; i++) { + if (/[^ \t]/.exec(lines[i])) { + lastNonEmptyLine = i; + } + } + let str = ""; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const isFirstLine = i === 0; + const isLastLine = i === lines.length - 1; + const isLastNonEmptyLine = i === lastNonEmptyLine; + let trimmedLine = line.replace(/\t/g, " "); + if (!isFirstLine) { + trimmedLine = trimmedLine.replace(/^ +/, ""); + } + if (!isLastLine) { + trimmedLine = trimmedLine.replace(/ +$/, ""); + } + if (trimmedLine) { + if (!isLastNonEmptyLine) { + trimmedLine += " "; + } + str += trimmedLine; + } + } + if (str) args.push((0, _index2.inherits)((0, _index.stringLiteral)(str), child)); +} + +//# sourceMappingURL=cleanJSXElementLiteralChild.js.map + +}, function(modId) { var map = {"../../builders/generated/index.js":1771034509029,"../../index.js":1771034509019}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509029, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var _lowercase = require("./lowercase.js"); +Object.keys(_lowercase).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _lowercase[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _lowercase[key]; + } + }); +}); +var _uppercase = require("./uppercase.js"); +Object.keys(_uppercase).forEach(function (key) { + if (key === "default" || key === "__esModule") return; + if (key in exports && exports[key] === _uppercase[key]) return; + Object.defineProperty(exports, key, { + enumerable: true, + get: function () { + return _uppercase[key]; + } + }); +}); + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {"./lowercase.js":1771034509030,"./uppercase.js":1771034509047}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509030, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.anyTypeAnnotation = anyTypeAnnotation; +exports.argumentPlaceholder = argumentPlaceholder; +exports.arrayExpression = arrayExpression; +exports.arrayPattern = arrayPattern; +exports.arrayTypeAnnotation = arrayTypeAnnotation; +exports.arrowFunctionExpression = arrowFunctionExpression; +exports.assignmentExpression = assignmentExpression; +exports.assignmentPattern = assignmentPattern; +exports.awaitExpression = awaitExpression; +exports.bigIntLiteral = bigIntLiteral; +exports.binaryExpression = binaryExpression; +exports.bindExpression = bindExpression; +exports.blockStatement = blockStatement; +exports.booleanLiteral = booleanLiteral; +exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation; +exports.booleanTypeAnnotation = booleanTypeAnnotation; +exports.breakStatement = breakStatement; +exports.callExpression = callExpression; +exports.catchClause = catchClause; +exports.classAccessorProperty = classAccessorProperty; +exports.classBody = classBody; +exports.classDeclaration = classDeclaration; +exports.classExpression = classExpression; +exports.classImplements = classImplements; +exports.classMethod = classMethod; +exports.classPrivateMethod = classPrivateMethod; +exports.classPrivateProperty = classPrivateProperty; +exports.classProperty = classProperty; +exports.conditionalExpression = conditionalExpression; +exports.continueStatement = continueStatement; +exports.debuggerStatement = debuggerStatement; +exports.decimalLiteral = decimalLiteral; +exports.declareClass = declareClass; +exports.declareExportAllDeclaration = declareExportAllDeclaration; +exports.declareExportDeclaration = declareExportDeclaration; +exports.declareFunction = declareFunction; +exports.declareInterface = declareInterface; +exports.declareModule = declareModule; +exports.declareModuleExports = declareModuleExports; +exports.declareOpaqueType = declareOpaqueType; +exports.declareTypeAlias = declareTypeAlias; +exports.declareVariable = declareVariable; +exports.declaredPredicate = declaredPredicate; +exports.decorator = decorator; +exports.directive = directive; +exports.directiveLiteral = directiveLiteral; +exports.doExpression = doExpression; +exports.doWhileStatement = doWhileStatement; +exports.emptyStatement = emptyStatement; +exports.emptyTypeAnnotation = emptyTypeAnnotation; +exports.enumBooleanBody = enumBooleanBody; +exports.enumBooleanMember = enumBooleanMember; +exports.enumDeclaration = enumDeclaration; +exports.enumDefaultedMember = enumDefaultedMember; +exports.enumNumberBody = enumNumberBody; +exports.enumNumberMember = enumNumberMember; +exports.enumStringBody = enumStringBody; +exports.enumStringMember = enumStringMember; +exports.enumSymbolBody = enumSymbolBody; +exports.existsTypeAnnotation = existsTypeAnnotation; +exports.exportAllDeclaration = exportAllDeclaration; +exports.exportDefaultDeclaration = exportDefaultDeclaration; +exports.exportDefaultSpecifier = exportDefaultSpecifier; +exports.exportNamedDeclaration = exportNamedDeclaration; +exports.exportNamespaceSpecifier = exportNamespaceSpecifier; +exports.exportSpecifier = exportSpecifier; +exports.expressionStatement = expressionStatement; +exports.file = file; +exports.forInStatement = forInStatement; +exports.forOfStatement = forOfStatement; +exports.forStatement = forStatement; +exports.functionDeclaration = functionDeclaration; +exports.functionExpression = functionExpression; +exports.functionTypeAnnotation = functionTypeAnnotation; +exports.functionTypeParam = functionTypeParam; +exports.genericTypeAnnotation = genericTypeAnnotation; +exports.identifier = identifier; +exports.ifStatement = ifStatement; +exports.import = _import; +exports.importAttribute = importAttribute; +exports.importDeclaration = importDeclaration; +exports.importDefaultSpecifier = importDefaultSpecifier; +exports.importExpression = importExpression; +exports.importNamespaceSpecifier = importNamespaceSpecifier; +exports.importSpecifier = importSpecifier; +exports.indexedAccessType = indexedAccessType; +exports.inferredPredicate = inferredPredicate; +exports.interfaceDeclaration = interfaceDeclaration; +exports.interfaceExtends = interfaceExtends; +exports.interfaceTypeAnnotation = interfaceTypeAnnotation; +exports.interpreterDirective = interpreterDirective; +exports.intersectionTypeAnnotation = intersectionTypeAnnotation; +exports.jSXAttribute = exports.jsxAttribute = jsxAttribute; +exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement; +exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment; +exports.jSXElement = exports.jsxElement = jsxElement; +exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression; +exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer; +exports.jSXFragment = exports.jsxFragment = jsxFragment; +exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier; +exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression; +exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName; +exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement; +exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment; +exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute; +exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild; +exports.jSXText = exports.jsxText = jsxText; +exports.labeledStatement = labeledStatement; +exports.logicalExpression = logicalExpression; +exports.memberExpression = memberExpression; +exports.metaProperty = metaProperty; +exports.mixedTypeAnnotation = mixedTypeAnnotation; +exports.moduleExpression = moduleExpression; +exports.newExpression = newExpression; +exports.noop = noop; +exports.nullLiteral = nullLiteral; +exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation; +exports.nullableTypeAnnotation = nullableTypeAnnotation; +exports.numberLiteral = NumberLiteral; +exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation; +exports.numberTypeAnnotation = numberTypeAnnotation; +exports.numericLiteral = numericLiteral; +exports.objectExpression = objectExpression; +exports.objectMethod = objectMethod; +exports.objectPattern = objectPattern; +exports.objectProperty = objectProperty; +exports.objectTypeAnnotation = objectTypeAnnotation; +exports.objectTypeCallProperty = objectTypeCallProperty; +exports.objectTypeIndexer = objectTypeIndexer; +exports.objectTypeInternalSlot = objectTypeInternalSlot; +exports.objectTypeProperty = objectTypeProperty; +exports.objectTypeSpreadProperty = objectTypeSpreadProperty; +exports.opaqueType = opaqueType; +exports.optionalCallExpression = optionalCallExpression; +exports.optionalIndexedAccessType = optionalIndexedAccessType; +exports.optionalMemberExpression = optionalMemberExpression; +exports.parenthesizedExpression = parenthesizedExpression; +exports.pipelineBareFunction = pipelineBareFunction; +exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference; +exports.pipelineTopicExpression = pipelineTopicExpression; +exports.placeholder = placeholder; +exports.privateName = privateName; +exports.program = program; +exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier; +exports.recordExpression = recordExpression; +exports.regExpLiteral = regExpLiteral; +exports.regexLiteral = RegexLiteral; +exports.restElement = restElement; +exports.restProperty = RestProperty; +exports.returnStatement = returnStatement; +exports.sequenceExpression = sequenceExpression; +exports.spreadElement = spreadElement; +exports.spreadProperty = SpreadProperty; +exports.staticBlock = staticBlock; +exports.stringLiteral = stringLiteral; +exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation; +exports.stringTypeAnnotation = stringTypeAnnotation; +exports.super = _super; +exports.switchCase = switchCase; +exports.switchStatement = switchStatement; +exports.symbolTypeAnnotation = symbolTypeAnnotation; +exports.taggedTemplateExpression = taggedTemplateExpression; +exports.templateElement = templateElement; +exports.templateLiteral = templateLiteral; +exports.thisExpression = thisExpression; +exports.thisTypeAnnotation = thisTypeAnnotation; +exports.throwStatement = throwStatement; +exports.topicReference = topicReference; +exports.tryStatement = tryStatement; +exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword; +exports.tSArrayType = exports.tsArrayType = tsArrayType; +exports.tSAsExpression = exports.tsAsExpression = tsAsExpression; +exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword; +exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword; +exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration; +exports.tSConditionalType = exports.tsConditionalType = tsConditionalType; +exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration; +exports.tSConstructorType = exports.tsConstructorType = tsConstructorType; +exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction; +exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod; +exports.tSEnumBody = exports.tsEnumBody = tsEnumBody; +exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration; +exports.tSEnumMember = exports.tsEnumMember = tsEnumMember; +exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment; +exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments; +exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference; +exports.tSFunctionType = exports.tsFunctionType = tsFunctionType; +exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration; +exports.tSImportType = exports.tsImportType = tsImportType; +exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature; +exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType; +exports.tSInferType = exports.tsInferType = tsInferType; +exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression; +exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody; +exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration; +exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType; +exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword; +exports.tSLiteralType = exports.tsLiteralType = tsLiteralType; +exports.tSMappedType = exports.tsMappedType = tsMappedType; +exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature; +exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock; +exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration; +exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember; +exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration; +exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword; +exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression; +exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword; +exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword; +exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword; +exports.tSOptionalType = exports.tsOptionalType = tsOptionalType; +exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty; +exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType; +exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature; +exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName; +exports.tSRestType = exports.tsRestType = tsRestType; +exports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression; +exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword; +exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword; +exports.tSTemplateLiteralType = exports.tsTemplateLiteralType = tsTemplateLiteralType; +exports.tSThisType = exports.tsThisType = tsThisType; +exports.tSTupleType = exports.tsTupleType = tsTupleType; +exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration; +exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation; +exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion; +exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral; +exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator; +exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter; +exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration; +exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation; +exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate; +exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery; +exports.tSTypeReference = exports.tsTypeReference = tsTypeReference; +exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword; +exports.tSUnionType = exports.tsUnionType = tsUnionType; +exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword; +exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword; +exports.tupleExpression = tupleExpression; +exports.tupleTypeAnnotation = tupleTypeAnnotation; +exports.typeAlias = typeAlias; +exports.typeAnnotation = typeAnnotation; +exports.typeCastExpression = typeCastExpression; +exports.typeParameter = typeParameter; +exports.typeParameterDeclaration = typeParameterDeclaration; +exports.typeParameterInstantiation = typeParameterInstantiation; +exports.typeofTypeAnnotation = typeofTypeAnnotation; +exports.unaryExpression = unaryExpression; +exports.unionTypeAnnotation = unionTypeAnnotation; +exports.updateExpression = updateExpression; +exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier; +exports.variableDeclaration = variableDeclaration; +exports.variableDeclarator = variableDeclarator; +exports.variance = variance; +exports.voidPattern = voidPattern; +exports.voidTypeAnnotation = voidTypeAnnotation; +exports.whileStatement = whileStatement; +exports.withStatement = withStatement; +exports.yieldExpression = yieldExpression; +var _validate = require("../../validators/validate.js"); +var _deprecationWarning = require("../../utils/deprecationWarning.js"); +var utils = require("../../definitions/utils.js"); +const { + validateInternal: validate +} = _validate; +const { + NODE_FIELDS +} = utils; +function bigIntLiteral(value) { + if (typeof value === "bigint") { + value = value.toString(); + } + const node = { + type: "BigIntLiteral", + value + }; + const defs = NODE_FIELDS.BigIntLiteral; + validate(defs.value, node, "value", value); + return node; +} +function arrayExpression(elements = []) { + const node = { + type: "ArrayExpression", + elements + }; + const defs = NODE_FIELDS.ArrayExpression; + validate(defs.elements, node, "elements", elements, 1); + return node; +} +function assignmentExpression(operator, left, right) { + const node = { + type: "AssignmentExpression", + operator, + left, + right + }; + const defs = NODE_FIELDS.AssignmentExpression; + validate(defs.operator, node, "operator", operator); + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function binaryExpression(operator, left, right) { + const node = { + type: "BinaryExpression", + operator, + left, + right + }; + const defs = NODE_FIELDS.BinaryExpression; + validate(defs.operator, node, "operator", operator); + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function interpreterDirective(value) { + const node = { + type: "InterpreterDirective", + value + }; + const defs = NODE_FIELDS.InterpreterDirective; + validate(defs.value, node, "value", value); + return node; +} +function directive(value) { + const node = { + type: "Directive", + value + }; + const defs = NODE_FIELDS.Directive; + validate(defs.value, node, "value", value, 1); + return node; +} +function directiveLiteral(value) { + const node = { + type: "DirectiveLiteral", + value + }; + const defs = NODE_FIELDS.DirectiveLiteral; + validate(defs.value, node, "value", value); + return node; +} +function blockStatement(body, directives = []) { + const node = { + type: "BlockStatement", + body, + directives + }; + const defs = NODE_FIELDS.BlockStatement; + validate(defs.body, node, "body", body, 1); + validate(defs.directives, node, "directives", directives, 1); + return node; +} +function breakStatement(label = null) { + const node = { + type: "BreakStatement", + label + }; + const defs = NODE_FIELDS.BreakStatement; + validate(defs.label, node, "label", label, 1); + return node; +} +function callExpression(callee, _arguments) { + const node = { + type: "CallExpression", + callee, + arguments: _arguments + }; + const defs = NODE_FIELDS.CallExpression; + validate(defs.callee, node, "callee", callee, 1); + validate(defs.arguments, node, "arguments", _arguments, 1); + return node; +} +function catchClause(param = null, body) { + const node = { + type: "CatchClause", + param, + body + }; + const defs = NODE_FIELDS.CatchClause; + validate(defs.param, node, "param", param, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function conditionalExpression(test, consequent, alternate) { + const node = { + type: "ConditionalExpression", + test, + consequent, + alternate + }; + const defs = NODE_FIELDS.ConditionalExpression; + validate(defs.test, node, "test", test, 1); + validate(defs.consequent, node, "consequent", consequent, 1); + validate(defs.alternate, node, "alternate", alternate, 1); + return node; +} +function continueStatement(label = null) { + const node = { + type: "ContinueStatement", + label + }; + const defs = NODE_FIELDS.ContinueStatement; + validate(defs.label, node, "label", label, 1); + return node; +} +function debuggerStatement() { + return { + type: "DebuggerStatement" + }; +} +function doWhileStatement(test, body) { + const node = { + type: "DoWhileStatement", + test, + body + }; + const defs = NODE_FIELDS.DoWhileStatement; + validate(defs.test, node, "test", test, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function emptyStatement() { + return { + type: "EmptyStatement" + }; +} +function expressionStatement(expression) { + const node = { + type: "ExpressionStatement", + expression + }; + const defs = NODE_FIELDS.ExpressionStatement; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function file(program, comments = null, tokens = null) { + const node = { + type: "File", + program, + comments, + tokens + }; + const defs = NODE_FIELDS.File; + validate(defs.program, node, "program", program, 1); + validate(defs.comments, node, "comments", comments, 1); + validate(defs.tokens, node, "tokens", tokens); + return node; +} +function forInStatement(left, right, body) { + const node = { + type: "ForInStatement", + left, + right, + body + }; + const defs = NODE_FIELDS.ForInStatement; + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function forStatement(init = null, test = null, update = null, body) { + const node = { + type: "ForStatement", + init, + test, + update, + body + }; + const defs = NODE_FIELDS.ForStatement; + validate(defs.init, node, "init", init, 1); + validate(defs.test, node, "test", test, 1); + validate(defs.update, node, "update", update, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function functionDeclaration(id = null, params, body, generator = false, async = false) { + const node = { + type: "FunctionDeclaration", + id, + params, + body, + generator, + async + }; + const defs = NODE_FIELDS.FunctionDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.generator, node, "generator", generator); + validate(defs.async, node, "async", async); + return node; +} +function functionExpression(id = null, params, body, generator = false, async = false) { + const node = { + type: "FunctionExpression", + id, + params, + body, + generator, + async + }; + const defs = NODE_FIELDS.FunctionExpression; + validate(defs.id, node, "id", id, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.generator, node, "generator", generator); + validate(defs.async, node, "async", async); + return node; +} +function identifier(name) { + const node = { + type: "Identifier", + name + }; + const defs = NODE_FIELDS.Identifier; + validate(defs.name, node, "name", name); + return node; +} +function ifStatement(test, consequent, alternate = null) { + const node = { + type: "IfStatement", + test, + consequent, + alternate + }; + const defs = NODE_FIELDS.IfStatement; + validate(defs.test, node, "test", test, 1); + validate(defs.consequent, node, "consequent", consequent, 1); + validate(defs.alternate, node, "alternate", alternate, 1); + return node; +} +function labeledStatement(label, body) { + const node = { + type: "LabeledStatement", + label, + body + }; + const defs = NODE_FIELDS.LabeledStatement; + validate(defs.label, node, "label", label, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function stringLiteral(value) { + const node = { + type: "StringLiteral", + value + }; + const defs = NODE_FIELDS.StringLiteral; + validate(defs.value, node, "value", value); + return node; +} +function numericLiteral(value) { + const node = { + type: "NumericLiteral", + value + }; + const defs = NODE_FIELDS.NumericLiteral; + validate(defs.value, node, "value", value); + return node; +} +function nullLiteral() { + return { + type: "NullLiteral" + }; +} +function booleanLiteral(value) { + const node = { + type: "BooleanLiteral", + value + }; + const defs = NODE_FIELDS.BooleanLiteral; + validate(defs.value, node, "value", value); + return node; +} +function regExpLiteral(pattern, flags = "") { + const node = { + type: "RegExpLiteral", + pattern, + flags + }; + const defs = NODE_FIELDS.RegExpLiteral; + validate(defs.pattern, node, "pattern", pattern); + validate(defs.flags, node, "flags", flags); + return node; +} +function logicalExpression(operator, left, right) { + const node = { + type: "LogicalExpression", + operator, + left, + right + }; + const defs = NODE_FIELDS.LogicalExpression; + validate(defs.operator, node, "operator", operator); + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function memberExpression(object, property, computed = false, optional = null) { + const node = { + type: "MemberExpression", + object, + property, + computed, + optional + }; + const defs = NODE_FIELDS.MemberExpression; + validate(defs.object, node, "object", object, 1); + validate(defs.property, node, "property", property, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.optional, node, "optional", optional); + return node; +} +function newExpression(callee, _arguments) { + const node = { + type: "NewExpression", + callee, + arguments: _arguments + }; + const defs = NODE_FIELDS.NewExpression; + validate(defs.callee, node, "callee", callee, 1); + validate(defs.arguments, node, "arguments", _arguments, 1); + return node; +} +function program(body, directives = [], sourceType = "script", interpreter = null) { + const node = { + type: "Program", + body, + directives, + sourceType, + interpreter + }; + const defs = NODE_FIELDS.Program; + validate(defs.body, node, "body", body, 1); + validate(defs.directives, node, "directives", directives, 1); + validate(defs.sourceType, node, "sourceType", sourceType); + validate(defs.interpreter, node, "interpreter", interpreter, 1); + return node; +} +function objectExpression(properties) { + const node = { + type: "ObjectExpression", + properties + }; + const defs = NODE_FIELDS.ObjectExpression; + validate(defs.properties, node, "properties", properties, 1); + return node; +} +function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) { + const node = { + type: "ObjectMethod", + kind, + key, + params, + body, + computed, + generator, + async + }; + const defs = NODE_FIELDS.ObjectMethod; + validate(defs.kind, node, "kind", kind); + validate(defs.key, node, "key", key, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.generator, node, "generator", generator); + validate(defs.async, node, "async", async); + return node; +} +function objectProperty(key, value, computed = false, shorthand = false, decorators = null) { + const node = { + type: "ObjectProperty", + key, + value, + computed, + shorthand, + decorators + }; + const defs = NODE_FIELDS.ObjectProperty; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.shorthand, node, "shorthand", shorthand); + validate(defs.decorators, node, "decorators", decorators, 1); + return node; +} +function restElement(argument) { + const node = { + type: "RestElement", + argument + }; + const defs = NODE_FIELDS.RestElement; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function returnStatement(argument = null) { + const node = { + type: "ReturnStatement", + argument + }; + const defs = NODE_FIELDS.ReturnStatement; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function sequenceExpression(expressions) { + const node = { + type: "SequenceExpression", + expressions + }; + const defs = NODE_FIELDS.SequenceExpression; + validate(defs.expressions, node, "expressions", expressions, 1); + return node; +} +function parenthesizedExpression(expression) { + const node = { + type: "ParenthesizedExpression", + expression + }; + const defs = NODE_FIELDS.ParenthesizedExpression; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function switchCase(test = null, consequent) { + const node = { + type: "SwitchCase", + test, + consequent + }; + const defs = NODE_FIELDS.SwitchCase; + validate(defs.test, node, "test", test, 1); + validate(defs.consequent, node, "consequent", consequent, 1); + return node; +} +function switchStatement(discriminant, cases) { + const node = { + type: "SwitchStatement", + discriminant, + cases + }; + const defs = NODE_FIELDS.SwitchStatement; + validate(defs.discriminant, node, "discriminant", discriminant, 1); + validate(defs.cases, node, "cases", cases, 1); + return node; +} +function thisExpression() { + return { + type: "ThisExpression" + }; +} +function throwStatement(argument) { + const node = { + type: "ThrowStatement", + argument + }; + const defs = NODE_FIELDS.ThrowStatement; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function tryStatement(block, handler = null, finalizer = null) { + const node = { + type: "TryStatement", + block, + handler, + finalizer + }; + const defs = NODE_FIELDS.TryStatement; + validate(defs.block, node, "block", block, 1); + validate(defs.handler, node, "handler", handler, 1); + validate(defs.finalizer, node, "finalizer", finalizer, 1); + return node; +} +function unaryExpression(operator, argument, prefix = true) { + const node = { + type: "UnaryExpression", + operator, + argument, + prefix + }; + const defs = NODE_FIELDS.UnaryExpression; + validate(defs.operator, node, "operator", operator); + validate(defs.argument, node, "argument", argument, 1); + validate(defs.prefix, node, "prefix", prefix); + return node; +} +function updateExpression(operator, argument, prefix = false) { + const node = { + type: "UpdateExpression", + operator, + argument, + prefix + }; + const defs = NODE_FIELDS.UpdateExpression; + validate(defs.operator, node, "operator", operator); + validate(defs.argument, node, "argument", argument, 1); + validate(defs.prefix, node, "prefix", prefix); + return node; +} +function variableDeclaration(kind, declarations) { + const node = { + type: "VariableDeclaration", + kind, + declarations + }; + const defs = NODE_FIELDS.VariableDeclaration; + validate(defs.kind, node, "kind", kind); + validate(defs.declarations, node, "declarations", declarations, 1); + return node; +} +function variableDeclarator(id, init = null) { + const node = { + type: "VariableDeclarator", + id, + init + }; + const defs = NODE_FIELDS.VariableDeclarator; + validate(defs.id, node, "id", id, 1); + validate(defs.init, node, "init", init, 1); + return node; +} +function whileStatement(test, body) { + const node = { + type: "WhileStatement", + test, + body + }; + const defs = NODE_FIELDS.WhileStatement; + validate(defs.test, node, "test", test, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function withStatement(object, body) { + const node = { + type: "WithStatement", + object, + body + }; + const defs = NODE_FIELDS.WithStatement; + validate(defs.object, node, "object", object, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function assignmentPattern(left, right) { + const node = { + type: "AssignmentPattern", + left, + right + }; + const defs = NODE_FIELDS.AssignmentPattern; + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function arrayPattern(elements) { + const node = { + type: "ArrayPattern", + elements + }; + const defs = NODE_FIELDS.ArrayPattern; + validate(defs.elements, node, "elements", elements, 1); + return node; +} +function arrowFunctionExpression(params, body, async = false) { + const node = { + type: "ArrowFunctionExpression", + params, + body, + async, + expression: null + }; + const defs = NODE_FIELDS.ArrowFunctionExpression; + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.async, node, "async", async); + return node; +} +function classBody(body) { + const node = { + type: "ClassBody", + body + }; + const defs = NODE_FIELDS.ClassBody; + validate(defs.body, node, "body", body, 1); + return node; +} +function classExpression(id = null, superClass = null, body, decorators = null) { + const node = { + type: "ClassExpression", + id, + superClass, + body, + decorators + }; + const defs = NODE_FIELDS.ClassExpression; + validate(defs.id, node, "id", id, 1); + validate(defs.superClass, node, "superClass", superClass, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.decorators, node, "decorators", decorators, 1); + return node; +} +function classDeclaration(id = null, superClass = null, body, decorators = null) { + const node = { + type: "ClassDeclaration", + id, + superClass, + body, + decorators + }; + const defs = NODE_FIELDS.ClassDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.superClass, node, "superClass", superClass, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.decorators, node, "decorators", decorators, 1); + return node; +} +function exportAllDeclaration(source, attributes = null) { + const node = { + type: "ExportAllDeclaration", + source, + attributes + }; + const defs = NODE_FIELDS.ExportAllDeclaration; + validate(defs.source, node, "source", source, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + return node; +} +function exportDefaultDeclaration(declaration) { + const node = { + type: "ExportDefaultDeclaration", + declaration + }; + const defs = NODE_FIELDS.ExportDefaultDeclaration; + validate(defs.declaration, node, "declaration", declaration, 1); + return node; +} +function exportNamedDeclaration(declaration = null, specifiers = [], source = null, attributes = null) { + const node = { + type: "ExportNamedDeclaration", + declaration, + specifiers, + source, + attributes + }; + const defs = NODE_FIELDS.ExportNamedDeclaration; + validate(defs.declaration, node, "declaration", declaration, 1); + validate(defs.specifiers, node, "specifiers", specifiers, 1); + validate(defs.source, node, "source", source, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + return node; +} +function exportSpecifier(local, exported) { + const node = { + type: "ExportSpecifier", + local, + exported + }; + const defs = NODE_FIELDS.ExportSpecifier; + validate(defs.local, node, "local", local, 1); + validate(defs.exported, node, "exported", exported, 1); + return node; +} +function forOfStatement(left, right, body, _await = false) { + const node = { + type: "ForOfStatement", + left, + right, + body, + await: _await + }; + const defs = NODE_FIELDS.ForOfStatement; + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.await, node, "await", _await); + return node; +} +function importDeclaration(specifiers, source, attributes = null) { + const node = { + type: "ImportDeclaration", + specifiers, + source, + attributes + }; + const defs = NODE_FIELDS.ImportDeclaration; + validate(defs.specifiers, node, "specifiers", specifiers, 1); + validate(defs.source, node, "source", source, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + return node; +} +function importDefaultSpecifier(local) { + const node = { + type: "ImportDefaultSpecifier", + local + }; + const defs = NODE_FIELDS.ImportDefaultSpecifier; + validate(defs.local, node, "local", local, 1); + return node; +} +function importNamespaceSpecifier(local) { + const node = { + type: "ImportNamespaceSpecifier", + local + }; + const defs = NODE_FIELDS.ImportNamespaceSpecifier; + validate(defs.local, node, "local", local, 1); + return node; +} +function importSpecifier(local, imported) { + const node = { + type: "ImportSpecifier", + local, + imported + }; + const defs = NODE_FIELDS.ImportSpecifier; + validate(defs.local, node, "local", local, 1); + validate(defs.imported, node, "imported", imported, 1); + return node; +} +function importExpression(source, options = null) { + const node = { + type: "ImportExpression", + source, + options + }; + const defs = NODE_FIELDS.ImportExpression; + validate(defs.source, node, "source", source, 1); + validate(defs.options, node, "options", options, 1); + return node; +} +function metaProperty(meta, property) { + const node = { + type: "MetaProperty", + meta, + property + }; + const defs = NODE_FIELDS.MetaProperty; + validate(defs.meta, node, "meta", meta, 1); + validate(defs.property, node, "property", property, 1); + return node; +} +function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) { + const node = { + type: "ClassMethod", + kind, + key, + params, + body, + computed, + static: _static, + generator, + async + }; + const defs = NODE_FIELDS.ClassMethod; + validate(defs.kind, node, "kind", kind); + validate(defs.key, node, "key", key, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.static, node, "static", _static); + validate(defs.generator, node, "generator", generator); + validate(defs.async, node, "async", async); + return node; +} +function objectPattern(properties) { + const node = { + type: "ObjectPattern", + properties + }; + const defs = NODE_FIELDS.ObjectPattern; + validate(defs.properties, node, "properties", properties, 1); + return node; +} +function spreadElement(argument) { + const node = { + type: "SpreadElement", + argument + }; + const defs = NODE_FIELDS.SpreadElement; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function _super() { + return { + type: "Super" + }; +} +function taggedTemplateExpression(tag, quasi) { + const node = { + type: "TaggedTemplateExpression", + tag, + quasi + }; + const defs = NODE_FIELDS.TaggedTemplateExpression; + validate(defs.tag, node, "tag", tag, 1); + validate(defs.quasi, node, "quasi", quasi, 1); + return node; +} +function templateElement(value, tail = false) { + const node = { + type: "TemplateElement", + value, + tail + }; + const defs = NODE_FIELDS.TemplateElement; + validate(defs.value, node, "value", value); + validate(defs.tail, node, "tail", tail); + return node; +} +function templateLiteral(quasis, expressions) { + const node = { + type: "TemplateLiteral", + quasis, + expressions + }; + const defs = NODE_FIELDS.TemplateLiteral; + validate(defs.quasis, node, "quasis", quasis, 1); + validate(defs.expressions, node, "expressions", expressions, 1); + return node; +} +function yieldExpression(argument = null, delegate = false) { + const node = { + type: "YieldExpression", + argument, + delegate + }; + const defs = NODE_FIELDS.YieldExpression; + validate(defs.argument, node, "argument", argument, 1); + validate(defs.delegate, node, "delegate", delegate); + return node; +} +function awaitExpression(argument) { + const node = { + type: "AwaitExpression", + argument + }; + const defs = NODE_FIELDS.AwaitExpression; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function _import() { + return { + type: "Import" + }; +} +function exportNamespaceSpecifier(exported) { + const node = { + type: "ExportNamespaceSpecifier", + exported + }; + const defs = NODE_FIELDS.ExportNamespaceSpecifier; + validate(defs.exported, node, "exported", exported, 1); + return node; +} +function optionalMemberExpression(object, property, computed = false, optional) { + const node = { + type: "OptionalMemberExpression", + object, + property, + computed, + optional + }; + const defs = NODE_FIELDS.OptionalMemberExpression; + validate(defs.object, node, "object", object, 1); + validate(defs.property, node, "property", property, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.optional, node, "optional", optional); + return node; +} +function optionalCallExpression(callee, _arguments, optional) { + const node = { + type: "OptionalCallExpression", + callee, + arguments: _arguments, + optional + }; + const defs = NODE_FIELDS.OptionalCallExpression; + validate(defs.callee, node, "callee", callee, 1); + validate(defs.arguments, node, "arguments", _arguments, 1); + validate(defs.optional, node, "optional", optional); + return node; +} +function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { + const node = { + type: "ClassProperty", + key, + value, + typeAnnotation, + decorators, + computed, + static: _static + }; + const defs = NODE_FIELDS.ClassProperty; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.decorators, node, "decorators", decorators, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.static, node, "static", _static); + return node; +} +function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { + const node = { + type: "ClassAccessorProperty", + key, + value, + typeAnnotation, + decorators, + computed, + static: _static + }; + const defs = NODE_FIELDS.ClassAccessorProperty; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.decorators, node, "decorators", decorators, 1); + validate(defs.computed, node, "computed", computed); + validate(defs.static, node, "static", _static); + return node; +} +function classPrivateProperty(key, value = null, decorators = null, _static = false) { + const node = { + type: "ClassPrivateProperty", + key, + value, + decorators, + static: _static + }; + const defs = NODE_FIELDS.ClassPrivateProperty; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.decorators, node, "decorators", decorators, 1); + validate(defs.static, node, "static", _static); + return node; +} +function classPrivateMethod(kind = "method", key, params, body, _static = false) { + const node = { + type: "ClassPrivateMethod", + kind, + key, + params, + body, + static: _static + }; + const defs = NODE_FIELDS.ClassPrivateMethod; + validate(defs.kind, node, "kind", kind); + validate(defs.key, node, "key", key, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.static, node, "static", _static); + return node; +} +function privateName(id) { + const node = { + type: "PrivateName", + id + }; + const defs = NODE_FIELDS.PrivateName; + validate(defs.id, node, "id", id, 1); + return node; +} +function staticBlock(body) { + const node = { + type: "StaticBlock", + body + }; + const defs = NODE_FIELDS.StaticBlock; + validate(defs.body, node, "body", body, 1); + return node; +} +function importAttribute(key, value) { + const node = { + type: "ImportAttribute", + key, + value + }; + const defs = NODE_FIELDS.ImportAttribute; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + return node; +} +function anyTypeAnnotation() { + return { + type: "AnyTypeAnnotation" + }; +} +function arrayTypeAnnotation(elementType) { + const node = { + type: "ArrayTypeAnnotation", + elementType + }; + const defs = NODE_FIELDS.ArrayTypeAnnotation; + validate(defs.elementType, node, "elementType", elementType, 1); + return node; +} +function booleanTypeAnnotation() { + return { + type: "BooleanTypeAnnotation" + }; +} +function booleanLiteralTypeAnnotation(value) { + const node = { + type: "BooleanLiteralTypeAnnotation", + value + }; + const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation; + validate(defs.value, node, "value", value); + return node; +} +function nullLiteralTypeAnnotation() { + return { + type: "NullLiteralTypeAnnotation" + }; +} +function classImplements(id, typeParameters = null) { + const node = { + type: "ClassImplements", + id, + typeParameters + }; + const defs = NODE_FIELDS.ClassImplements; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function declareClass(id, typeParameters = null, _extends = null, body) { + const node = { + type: "DeclareClass", + id, + typeParameters, + extends: _extends, + body + }; + const defs = NODE_FIELDS.DeclareClass; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.extends, node, "extends", _extends, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function declareFunction(id) { + const node = { + type: "DeclareFunction", + id + }; + const defs = NODE_FIELDS.DeclareFunction; + validate(defs.id, node, "id", id, 1); + return node; +} +function declareInterface(id, typeParameters = null, _extends = null, body) { + const node = { + type: "DeclareInterface", + id, + typeParameters, + extends: _extends, + body + }; + const defs = NODE_FIELDS.DeclareInterface; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.extends, node, "extends", _extends, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function declareModule(id, body, kind = null) { + const node = { + type: "DeclareModule", + id, + body, + kind + }; + const defs = NODE_FIELDS.DeclareModule; + validate(defs.id, node, "id", id, 1); + validate(defs.body, node, "body", body, 1); + validate(defs.kind, node, "kind", kind); + return node; +} +function declareModuleExports(typeAnnotation) { + const node = { + type: "DeclareModuleExports", + typeAnnotation + }; + const defs = NODE_FIELDS.DeclareModuleExports; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function declareTypeAlias(id, typeParameters = null, right) { + const node = { + type: "DeclareTypeAlias", + id, + typeParameters, + right + }; + const defs = NODE_FIELDS.DeclareTypeAlias; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function declareOpaqueType(id, typeParameters = null, supertype = null) { + const node = { + type: "DeclareOpaqueType", + id, + typeParameters, + supertype + }; + const defs = NODE_FIELDS.DeclareOpaqueType; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.supertype, node, "supertype", supertype, 1); + return node; +} +function declareVariable(id) { + const node = { + type: "DeclareVariable", + id + }; + const defs = NODE_FIELDS.DeclareVariable; + validate(defs.id, node, "id", id, 1); + return node; +} +function declareExportDeclaration(declaration = null, specifiers = null, source = null, attributes = null) { + const node = { + type: "DeclareExportDeclaration", + declaration, + specifiers, + source, + attributes + }; + const defs = NODE_FIELDS.DeclareExportDeclaration; + validate(defs.declaration, node, "declaration", declaration, 1); + validate(defs.specifiers, node, "specifiers", specifiers, 1); + validate(defs.source, node, "source", source, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + return node; +} +function declareExportAllDeclaration(source, attributes = null) { + const node = { + type: "DeclareExportAllDeclaration", + source, + attributes + }; + const defs = NODE_FIELDS.DeclareExportAllDeclaration; + validate(defs.source, node, "source", source, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + return node; +} +function declaredPredicate(value) { + const node = { + type: "DeclaredPredicate", + value + }; + const defs = NODE_FIELDS.DeclaredPredicate; + validate(defs.value, node, "value", value, 1); + return node; +} +function existsTypeAnnotation() { + return { + type: "ExistsTypeAnnotation" + }; +} +function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) { + const node = { + type: "FunctionTypeAnnotation", + typeParameters, + params, + rest, + returnType + }; + const defs = NODE_FIELDS.FunctionTypeAnnotation; + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.rest, node, "rest", rest, 1); + validate(defs.returnType, node, "returnType", returnType, 1); + return node; +} +function functionTypeParam(name = null, typeAnnotation) { + const node = { + type: "FunctionTypeParam", + name, + typeAnnotation + }; + const defs = NODE_FIELDS.FunctionTypeParam; + validate(defs.name, node, "name", name, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function genericTypeAnnotation(id, typeParameters = null) { + const node = { + type: "GenericTypeAnnotation", + id, + typeParameters + }; + const defs = NODE_FIELDS.GenericTypeAnnotation; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function inferredPredicate() { + return { + type: "InferredPredicate" + }; +} +function interfaceExtends(id, typeParameters = null) { + const node = { + type: "InterfaceExtends", + id, + typeParameters + }; + const defs = NODE_FIELDS.InterfaceExtends; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function interfaceDeclaration(id, typeParameters = null, _extends = null, body) { + const node = { + type: "InterfaceDeclaration", + id, + typeParameters, + extends: _extends, + body + }; + const defs = NODE_FIELDS.InterfaceDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.extends, node, "extends", _extends, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function interfaceTypeAnnotation(_extends = null, body) { + const node = { + type: "InterfaceTypeAnnotation", + extends: _extends, + body + }; + const defs = NODE_FIELDS.InterfaceTypeAnnotation; + validate(defs.extends, node, "extends", _extends, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function intersectionTypeAnnotation(types) { + const node = { + type: "IntersectionTypeAnnotation", + types + }; + const defs = NODE_FIELDS.IntersectionTypeAnnotation; + validate(defs.types, node, "types", types, 1); + return node; +} +function mixedTypeAnnotation() { + return { + type: "MixedTypeAnnotation" + }; +} +function emptyTypeAnnotation() { + return { + type: "EmptyTypeAnnotation" + }; +} +function nullableTypeAnnotation(typeAnnotation) { + const node = { + type: "NullableTypeAnnotation", + typeAnnotation + }; + const defs = NODE_FIELDS.NullableTypeAnnotation; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function numberLiteralTypeAnnotation(value) { + const node = { + type: "NumberLiteralTypeAnnotation", + value + }; + const defs = NODE_FIELDS.NumberLiteralTypeAnnotation; + validate(defs.value, node, "value", value); + return node; +} +function numberTypeAnnotation() { + return { + type: "NumberTypeAnnotation" + }; +} +function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) { + const node = { + type: "ObjectTypeAnnotation", + properties, + indexers, + callProperties, + internalSlots, + exact + }; + const defs = NODE_FIELDS.ObjectTypeAnnotation; + validate(defs.properties, node, "properties", properties, 1); + validate(defs.indexers, node, "indexers", indexers, 1); + validate(defs.callProperties, node, "callProperties", callProperties, 1); + validate(defs.internalSlots, node, "internalSlots", internalSlots, 1); + validate(defs.exact, node, "exact", exact); + return node; +} +function objectTypeInternalSlot(id, value, optional, _static, method) { + const node = { + type: "ObjectTypeInternalSlot", + id, + value, + optional, + static: _static, + method + }; + const defs = NODE_FIELDS.ObjectTypeInternalSlot; + validate(defs.id, node, "id", id, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.optional, node, "optional", optional); + validate(defs.static, node, "static", _static); + validate(defs.method, node, "method", method); + return node; +} +function objectTypeCallProperty(value) { + const node = { + type: "ObjectTypeCallProperty", + value, + static: null + }; + const defs = NODE_FIELDS.ObjectTypeCallProperty; + validate(defs.value, node, "value", value, 1); + return node; +} +function objectTypeIndexer(id = null, key, value, variance = null) { + const node = { + type: "ObjectTypeIndexer", + id, + key, + value, + variance, + static: null + }; + const defs = NODE_FIELDS.ObjectTypeIndexer; + validate(defs.id, node, "id", id, 1); + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.variance, node, "variance", variance, 1); + return node; +} +function objectTypeProperty(key, value, variance = null) { + const node = { + type: "ObjectTypeProperty", + key, + value, + variance, + kind: null, + method: null, + optional: null, + proto: null, + static: null + }; + const defs = NODE_FIELDS.ObjectTypeProperty; + validate(defs.key, node, "key", key, 1); + validate(defs.value, node, "value", value, 1); + validate(defs.variance, node, "variance", variance, 1); + return node; +} +function objectTypeSpreadProperty(argument) { + const node = { + type: "ObjectTypeSpreadProperty", + argument + }; + const defs = NODE_FIELDS.ObjectTypeSpreadProperty; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function opaqueType(id, typeParameters = null, supertype = null, impltype) { + const node = { + type: "OpaqueType", + id, + typeParameters, + supertype, + impltype + }; + const defs = NODE_FIELDS.OpaqueType; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.supertype, node, "supertype", supertype, 1); + validate(defs.impltype, node, "impltype", impltype, 1); + return node; +} +function qualifiedTypeIdentifier(id, qualification) { + const node = { + type: "QualifiedTypeIdentifier", + id, + qualification + }; + const defs = NODE_FIELDS.QualifiedTypeIdentifier; + validate(defs.id, node, "id", id, 1); + validate(defs.qualification, node, "qualification", qualification, 1); + return node; +} +function stringLiteralTypeAnnotation(value) { + const node = { + type: "StringLiteralTypeAnnotation", + value + }; + const defs = NODE_FIELDS.StringLiteralTypeAnnotation; + validate(defs.value, node, "value", value); + return node; +} +function stringTypeAnnotation() { + return { + type: "StringTypeAnnotation" + }; +} +function symbolTypeAnnotation() { + return { + type: "SymbolTypeAnnotation" + }; +} +function thisTypeAnnotation() { + return { + type: "ThisTypeAnnotation" + }; +} +function tupleTypeAnnotation(types) { + const node = { + type: "TupleTypeAnnotation", + types + }; + const defs = NODE_FIELDS.TupleTypeAnnotation; + validate(defs.types, node, "types", types, 1); + return node; +} +function typeofTypeAnnotation(argument) { + const node = { + type: "TypeofTypeAnnotation", + argument + }; + const defs = NODE_FIELDS.TypeofTypeAnnotation; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function typeAlias(id, typeParameters = null, right) { + const node = { + type: "TypeAlias", + id, + typeParameters, + right + }; + const defs = NODE_FIELDS.TypeAlias; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function typeAnnotation(typeAnnotation) { + const node = { + type: "TypeAnnotation", + typeAnnotation + }; + const defs = NODE_FIELDS.TypeAnnotation; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function typeCastExpression(expression, typeAnnotation) { + const node = { + type: "TypeCastExpression", + expression, + typeAnnotation + }; + const defs = NODE_FIELDS.TypeCastExpression; + validate(defs.expression, node, "expression", expression, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function typeParameter(bound = null, _default = null, variance = null) { + const node = { + type: "TypeParameter", + bound, + default: _default, + variance, + name: null + }; + const defs = NODE_FIELDS.TypeParameter; + validate(defs.bound, node, "bound", bound, 1); + validate(defs.default, node, "default", _default, 1); + validate(defs.variance, node, "variance", variance, 1); + return node; +} +function typeParameterDeclaration(params) { + const node = { + type: "TypeParameterDeclaration", + params + }; + const defs = NODE_FIELDS.TypeParameterDeclaration; + validate(defs.params, node, "params", params, 1); + return node; +} +function typeParameterInstantiation(params) { + const node = { + type: "TypeParameterInstantiation", + params + }; + const defs = NODE_FIELDS.TypeParameterInstantiation; + validate(defs.params, node, "params", params, 1); + return node; +} +function unionTypeAnnotation(types) { + const node = { + type: "UnionTypeAnnotation", + types + }; + const defs = NODE_FIELDS.UnionTypeAnnotation; + validate(defs.types, node, "types", types, 1); + return node; +} +function variance(kind) { + const node = { + type: "Variance", + kind + }; + const defs = NODE_FIELDS.Variance; + validate(defs.kind, node, "kind", kind); + return node; +} +function voidTypeAnnotation() { + return { + type: "VoidTypeAnnotation" + }; +} +function enumDeclaration(id, body) { + const node = { + type: "EnumDeclaration", + id, + body + }; + const defs = NODE_FIELDS.EnumDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function enumBooleanBody(members) { + const node = { + type: "EnumBooleanBody", + members, + explicitType: null, + hasUnknownMembers: null + }; + const defs = NODE_FIELDS.EnumBooleanBody; + validate(defs.members, node, "members", members, 1); + return node; +} +function enumNumberBody(members) { + const node = { + type: "EnumNumberBody", + members, + explicitType: null, + hasUnknownMembers: null + }; + const defs = NODE_FIELDS.EnumNumberBody; + validate(defs.members, node, "members", members, 1); + return node; +} +function enumStringBody(members) { + const node = { + type: "EnumStringBody", + members, + explicitType: null, + hasUnknownMembers: null + }; + const defs = NODE_FIELDS.EnumStringBody; + validate(defs.members, node, "members", members, 1); + return node; +} +function enumSymbolBody(members) { + const node = { + type: "EnumSymbolBody", + members, + hasUnknownMembers: null + }; + const defs = NODE_FIELDS.EnumSymbolBody; + validate(defs.members, node, "members", members, 1); + return node; +} +function enumBooleanMember(id) { + const node = { + type: "EnumBooleanMember", + id, + init: null + }; + const defs = NODE_FIELDS.EnumBooleanMember; + validate(defs.id, node, "id", id, 1); + return node; +} +function enumNumberMember(id, init) { + const node = { + type: "EnumNumberMember", + id, + init + }; + const defs = NODE_FIELDS.EnumNumberMember; + validate(defs.id, node, "id", id, 1); + validate(defs.init, node, "init", init, 1); + return node; +} +function enumStringMember(id, init) { + const node = { + type: "EnumStringMember", + id, + init + }; + const defs = NODE_FIELDS.EnumStringMember; + validate(defs.id, node, "id", id, 1); + validate(defs.init, node, "init", init, 1); + return node; +} +function enumDefaultedMember(id) { + const node = { + type: "EnumDefaultedMember", + id + }; + const defs = NODE_FIELDS.EnumDefaultedMember; + validate(defs.id, node, "id", id, 1); + return node; +} +function indexedAccessType(objectType, indexType) { + const node = { + type: "IndexedAccessType", + objectType, + indexType + }; + const defs = NODE_FIELDS.IndexedAccessType; + validate(defs.objectType, node, "objectType", objectType, 1); + validate(defs.indexType, node, "indexType", indexType, 1); + return node; +} +function optionalIndexedAccessType(objectType, indexType) { + const node = { + type: "OptionalIndexedAccessType", + objectType, + indexType, + optional: null + }; + const defs = NODE_FIELDS.OptionalIndexedAccessType; + validate(defs.objectType, node, "objectType", objectType, 1); + validate(defs.indexType, node, "indexType", indexType, 1); + return node; +} +function jsxAttribute(name, value = null) { + const node = { + type: "JSXAttribute", + name, + value + }; + const defs = NODE_FIELDS.JSXAttribute; + validate(defs.name, node, "name", name, 1); + validate(defs.value, node, "value", value, 1); + return node; +} +function jsxClosingElement(name) { + const node = { + type: "JSXClosingElement", + name + }; + const defs = NODE_FIELDS.JSXClosingElement; + validate(defs.name, node, "name", name, 1); + return node; +} +function jsxElement(openingElement, closingElement = null, children, selfClosing = null) { + const node = { + type: "JSXElement", + openingElement, + closingElement, + children, + selfClosing + }; + const defs = NODE_FIELDS.JSXElement; + validate(defs.openingElement, node, "openingElement", openingElement, 1); + validate(defs.closingElement, node, "closingElement", closingElement, 1); + validate(defs.children, node, "children", children, 1); + validate(defs.selfClosing, node, "selfClosing", selfClosing); + return node; +} +function jsxEmptyExpression() { + return { + type: "JSXEmptyExpression" + }; +} +function jsxExpressionContainer(expression) { + const node = { + type: "JSXExpressionContainer", + expression + }; + const defs = NODE_FIELDS.JSXExpressionContainer; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function jsxSpreadChild(expression) { + const node = { + type: "JSXSpreadChild", + expression + }; + const defs = NODE_FIELDS.JSXSpreadChild; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function jsxIdentifier(name) { + const node = { + type: "JSXIdentifier", + name + }; + const defs = NODE_FIELDS.JSXIdentifier; + validate(defs.name, node, "name", name); + return node; +} +function jsxMemberExpression(object, property) { + const node = { + type: "JSXMemberExpression", + object, + property + }; + const defs = NODE_FIELDS.JSXMemberExpression; + validate(defs.object, node, "object", object, 1); + validate(defs.property, node, "property", property, 1); + return node; +} +function jsxNamespacedName(namespace, name) { + const node = { + type: "JSXNamespacedName", + namespace, + name + }; + const defs = NODE_FIELDS.JSXNamespacedName; + validate(defs.namespace, node, "namespace", namespace, 1); + validate(defs.name, node, "name", name, 1); + return node; +} +function jsxOpeningElement(name, attributes, selfClosing = false) { + const node = { + type: "JSXOpeningElement", + name, + attributes, + selfClosing + }; + const defs = NODE_FIELDS.JSXOpeningElement; + validate(defs.name, node, "name", name, 1); + validate(defs.attributes, node, "attributes", attributes, 1); + validate(defs.selfClosing, node, "selfClosing", selfClosing); + return node; +} +function jsxSpreadAttribute(argument) { + const node = { + type: "JSXSpreadAttribute", + argument + }; + const defs = NODE_FIELDS.JSXSpreadAttribute; + validate(defs.argument, node, "argument", argument, 1); + return node; +} +function jsxText(value) { + const node = { + type: "JSXText", + value + }; + const defs = NODE_FIELDS.JSXText; + validate(defs.value, node, "value", value); + return node; +} +function jsxFragment(openingFragment, closingFragment, children) { + const node = { + type: "JSXFragment", + openingFragment, + closingFragment, + children + }; + const defs = NODE_FIELDS.JSXFragment; + validate(defs.openingFragment, node, "openingFragment", openingFragment, 1); + validate(defs.closingFragment, node, "closingFragment", closingFragment, 1); + validate(defs.children, node, "children", children, 1); + return node; +} +function jsxOpeningFragment() { + return { + type: "JSXOpeningFragment" + }; +} +function jsxClosingFragment() { + return { + type: "JSXClosingFragment" + }; +} +function noop() { + return { + type: "Noop" + }; +} +function placeholder(expectedNode, name) { + const node = { + type: "Placeholder", + expectedNode, + name + }; + const defs = NODE_FIELDS.Placeholder; + validate(defs.expectedNode, node, "expectedNode", expectedNode); + validate(defs.name, node, "name", name, 1); + return node; +} +function v8IntrinsicIdentifier(name) { + const node = { + type: "V8IntrinsicIdentifier", + name + }; + const defs = NODE_FIELDS.V8IntrinsicIdentifier; + validate(defs.name, node, "name", name); + return node; +} +function argumentPlaceholder() { + return { + type: "ArgumentPlaceholder" + }; +} +function bindExpression(object, callee) { + const node = { + type: "BindExpression", + object, + callee + }; + const defs = NODE_FIELDS.BindExpression; + validate(defs.object, node, "object", object, 1); + validate(defs.callee, node, "callee", callee, 1); + return node; +} +function decorator(expression) { + const node = { + type: "Decorator", + expression + }; + const defs = NODE_FIELDS.Decorator; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function doExpression(body, async = false) { + const node = { + type: "DoExpression", + body, + async + }; + const defs = NODE_FIELDS.DoExpression; + validate(defs.body, node, "body", body, 1); + validate(defs.async, node, "async", async); + return node; +} +function exportDefaultSpecifier(exported) { + const node = { + type: "ExportDefaultSpecifier", + exported + }; + const defs = NODE_FIELDS.ExportDefaultSpecifier; + validate(defs.exported, node, "exported", exported, 1); + return node; +} +function recordExpression(properties) { + const node = { + type: "RecordExpression", + properties + }; + const defs = NODE_FIELDS.RecordExpression; + validate(defs.properties, node, "properties", properties, 1); + return node; +} +function tupleExpression(elements = []) { + const node = { + type: "TupleExpression", + elements + }; + const defs = NODE_FIELDS.TupleExpression; + validate(defs.elements, node, "elements", elements, 1); + return node; +} +function decimalLiteral(value) { + const node = { + type: "DecimalLiteral", + value + }; + const defs = NODE_FIELDS.DecimalLiteral; + validate(defs.value, node, "value", value); + return node; +} +function moduleExpression(body) { + const node = { + type: "ModuleExpression", + body + }; + const defs = NODE_FIELDS.ModuleExpression; + validate(defs.body, node, "body", body, 1); + return node; +} +function topicReference() { + return { + type: "TopicReference" + }; +} +function pipelineTopicExpression(expression) { + const node = { + type: "PipelineTopicExpression", + expression + }; + const defs = NODE_FIELDS.PipelineTopicExpression; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function pipelineBareFunction(callee) { + const node = { + type: "PipelineBareFunction", + callee + }; + const defs = NODE_FIELDS.PipelineBareFunction; + validate(defs.callee, node, "callee", callee, 1); + return node; +} +function pipelinePrimaryTopicReference() { + return { + type: "PipelinePrimaryTopicReference" + }; +} +function voidPattern() { + return { + type: "VoidPattern" + }; +} +function tsParameterProperty(parameter) { + const node = { + type: "TSParameterProperty", + parameter + }; + const defs = NODE_FIELDS.TSParameterProperty; + validate(defs.parameter, node, "parameter", parameter, 1); + return node; +} +function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) { + const node = { + type: "TSDeclareFunction", + id, + typeParameters, + params, + returnType + }; + const defs = NODE_FIELDS.TSDeclareFunction; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.returnType, node, "returnType", returnType, 1); + return node; +} +function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) { + const node = { + type: "TSDeclareMethod", + decorators, + key, + typeParameters, + params, + returnType + }; + const defs = NODE_FIELDS.TSDeclareMethod; + validate(defs.decorators, node, "decorators", decorators, 1); + validate(defs.key, node, "key", key, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.params, node, "params", params, 1); + validate(defs.returnType, node, "returnType", returnType, 1); + return node; +} +function tsQualifiedName(left, right) { + const node = { + type: "TSQualifiedName", + left, + right + }; + const defs = NODE_FIELDS.TSQualifiedName; + validate(defs.left, node, "left", left, 1); + validate(defs.right, node, "right", right, 1); + return node; +} +function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { + const node = { + type: "TSCallSignatureDeclaration", + typeParameters, + parameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSCallSignatureDeclaration; + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { + const node = { + type: "TSConstructSignatureDeclaration", + typeParameters, + parameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSConstructSignatureDeclaration; + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsPropertySignature(key, typeAnnotation = null) { + const node = { + type: "TSPropertySignature", + key, + typeAnnotation + }; + const defs = NODE_FIELDS.TSPropertySignature; + validate(defs.key, node, "key", key, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) { + const node = { + type: "TSMethodSignature", + key, + typeParameters, + parameters, + typeAnnotation, + kind: null + }; + const defs = NODE_FIELDS.TSMethodSignature; + validate(defs.key, node, "key", key, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsIndexSignature(parameters, typeAnnotation = null) { + const node = { + type: "TSIndexSignature", + parameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSIndexSignature; + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsAnyKeyword() { + return { + type: "TSAnyKeyword" + }; +} +function tsBooleanKeyword() { + return { + type: "TSBooleanKeyword" + }; +} +function tsBigIntKeyword() { + return { + type: "TSBigIntKeyword" + }; +} +function tsIntrinsicKeyword() { + return { + type: "TSIntrinsicKeyword" + }; +} +function tsNeverKeyword() { + return { + type: "TSNeverKeyword" + }; +} +function tsNullKeyword() { + return { + type: "TSNullKeyword" + }; +} +function tsNumberKeyword() { + return { + type: "TSNumberKeyword" + }; +} +function tsObjectKeyword() { + return { + type: "TSObjectKeyword" + }; +} +function tsStringKeyword() { + return { + type: "TSStringKeyword" + }; +} +function tsSymbolKeyword() { + return { + type: "TSSymbolKeyword" + }; +} +function tsUndefinedKeyword() { + return { + type: "TSUndefinedKeyword" + }; +} +function tsUnknownKeyword() { + return { + type: "TSUnknownKeyword" + }; +} +function tsVoidKeyword() { + return { + type: "TSVoidKeyword" + }; +} +function tsThisType() { + return { + type: "TSThisType" + }; +} +function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) { + const node = { + type: "TSFunctionType", + typeParameters, + parameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSFunctionType; + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) { + const node = { + type: "TSConstructorType", + typeParameters, + parameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSConstructorType; + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.parameters, node, "parameters", parameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsTypeReference(typeName, typeParameters = null) { + const node = { + type: "TSTypeReference", + typeName, + typeParameters + }; + const defs = NODE_FIELDS.TSTypeReference; + validate(defs.typeName, node, "typeName", typeName, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) { + const node = { + type: "TSTypePredicate", + parameterName, + typeAnnotation, + asserts + }; + const defs = NODE_FIELDS.TSTypePredicate; + validate(defs.parameterName, node, "parameterName", parameterName, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.asserts, node, "asserts", asserts); + return node; +} +function tsTypeQuery(exprName, typeParameters = null) { + const node = { + type: "TSTypeQuery", + exprName, + typeParameters + }; + const defs = NODE_FIELDS.TSTypeQuery; + validate(defs.exprName, node, "exprName", exprName, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function tsTypeLiteral(members) { + const node = { + type: "TSTypeLiteral", + members + }; + const defs = NODE_FIELDS.TSTypeLiteral; + validate(defs.members, node, "members", members, 1); + return node; +} +function tsArrayType(elementType) { + const node = { + type: "TSArrayType", + elementType + }; + const defs = NODE_FIELDS.TSArrayType; + validate(defs.elementType, node, "elementType", elementType, 1); + return node; +} +function tsTupleType(elementTypes) { + const node = { + type: "TSTupleType", + elementTypes + }; + const defs = NODE_FIELDS.TSTupleType; + validate(defs.elementTypes, node, "elementTypes", elementTypes, 1); + return node; +} +function tsOptionalType(typeAnnotation) { + const node = { + type: "TSOptionalType", + typeAnnotation + }; + const defs = NODE_FIELDS.TSOptionalType; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsRestType(typeAnnotation) { + const node = { + type: "TSRestType", + typeAnnotation + }; + const defs = NODE_FIELDS.TSRestType; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsNamedTupleMember(label, elementType, optional = false) { + const node = { + type: "TSNamedTupleMember", + label, + elementType, + optional + }; + const defs = NODE_FIELDS.TSNamedTupleMember; + validate(defs.label, node, "label", label, 1); + validate(defs.elementType, node, "elementType", elementType, 1); + validate(defs.optional, node, "optional", optional); + return node; +} +function tsUnionType(types) { + const node = { + type: "TSUnionType", + types + }; + const defs = NODE_FIELDS.TSUnionType; + validate(defs.types, node, "types", types, 1); + return node; +} +function tsIntersectionType(types) { + const node = { + type: "TSIntersectionType", + types + }; + const defs = NODE_FIELDS.TSIntersectionType; + validate(defs.types, node, "types", types, 1); + return node; +} +function tsConditionalType(checkType, extendsType, trueType, falseType) { + const node = { + type: "TSConditionalType", + checkType, + extendsType, + trueType, + falseType + }; + const defs = NODE_FIELDS.TSConditionalType; + validate(defs.checkType, node, "checkType", checkType, 1); + validate(defs.extendsType, node, "extendsType", extendsType, 1); + validate(defs.trueType, node, "trueType", trueType, 1); + validate(defs.falseType, node, "falseType", falseType, 1); + return node; +} +function tsInferType(typeParameter) { + const node = { + type: "TSInferType", + typeParameter + }; + const defs = NODE_FIELDS.TSInferType; + validate(defs.typeParameter, node, "typeParameter", typeParameter, 1); + return node; +} +function tsParenthesizedType(typeAnnotation) { + const node = { + type: "TSParenthesizedType", + typeAnnotation + }; + const defs = NODE_FIELDS.TSParenthesizedType; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsTypeOperator(typeAnnotation, operator = "keyof") { + const node = { + type: "TSTypeOperator", + typeAnnotation, + operator + }; + const defs = NODE_FIELDS.TSTypeOperator; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.operator, node, "operator", operator); + return node; +} +function tsIndexedAccessType(objectType, indexType) { + const node = { + type: "TSIndexedAccessType", + objectType, + indexType + }; + const defs = NODE_FIELDS.TSIndexedAccessType; + validate(defs.objectType, node, "objectType", objectType, 1); + validate(defs.indexType, node, "indexType", indexType, 1); + return node; +} +function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) { + const node = { + type: "TSMappedType", + typeParameter, + typeAnnotation, + nameType + }; + const defs = NODE_FIELDS.TSMappedType; + validate(defs.typeParameter, node, "typeParameter", typeParameter, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.nameType, node, "nameType", nameType, 1); + return node; +} +function tsTemplateLiteralType(quasis, types) { + const node = { + type: "TSTemplateLiteralType", + quasis, + types + }; + const defs = NODE_FIELDS.TSTemplateLiteralType; + validate(defs.quasis, node, "quasis", quasis, 1); + validate(defs.types, node, "types", types, 1); + return node; +} +function tsLiteralType(literal) { + const node = { + type: "TSLiteralType", + literal + }; + const defs = NODE_FIELDS.TSLiteralType; + validate(defs.literal, node, "literal", literal, 1); + return node; +} +function tsExpressionWithTypeArguments(expression, typeParameters = null) { + const node = { + type: "TSExpressionWithTypeArguments", + expression, + typeParameters + }; + const defs = NODE_FIELDS.TSExpressionWithTypeArguments; + validate(defs.expression, node, "expression", expression, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) { + const node = { + type: "TSInterfaceDeclaration", + id, + typeParameters, + extends: _extends, + body + }; + const defs = NODE_FIELDS.TSInterfaceDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.extends, node, "extends", _extends, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function tsInterfaceBody(body) { + const node = { + type: "TSInterfaceBody", + body + }; + const defs = NODE_FIELDS.TSInterfaceBody; + validate(defs.body, node, "body", body, 1); + return node; +} +function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) { + const node = { + type: "TSTypeAliasDeclaration", + id, + typeParameters, + typeAnnotation + }; + const defs = NODE_FIELDS.TSTypeAliasDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsInstantiationExpression(expression, typeParameters = null) { + const node = { + type: "TSInstantiationExpression", + expression, + typeParameters + }; + const defs = NODE_FIELDS.TSInstantiationExpression; + validate(defs.expression, node, "expression", expression, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function tsAsExpression(expression, typeAnnotation) { + const node = { + type: "TSAsExpression", + expression, + typeAnnotation + }; + const defs = NODE_FIELDS.TSAsExpression; + validate(defs.expression, node, "expression", expression, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsSatisfiesExpression(expression, typeAnnotation) { + const node = { + type: "TSSatisfiesExpression", + expression, + typeAnnotation + }; + const defs = NODE_FIELDS.TSSatisfiesExpression; + validate(defs.expression, node, "expression", expression, 1); + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsTypeAssertion(typeAnnotation, expression) { + const node = { + type: "TSTypeAssertion", + typeAnnotation, + expression + }; + const defs = NODE_FIELDS.TSTypeAssertion; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function tsEnumBody(members) { + const node = { + type: "TSEnumBody", + members + }; + const defs = NODE_FIELDS.TSEnumBody; + validate(defs.members, node, "members", members, 1); + return node; +} +function tsEnumDeclaration(id, members) { + const node = { + type: "TSEnumDeclaration", + id, + members + }; + const defs = NODE_FIELDS.TSEnumDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.members, node, "members", members, 1); + return node; +} +function tsEnumMember(id, initializer = null) { + const node = { + type: "TSEnumMember", + id, + initializer + }; + const defs = NODE_FIELDS.TSEnumMember; + validate(defs.id, node, "id", id, 1); + validate(defs.initializer, node, "initializer", initializer, 1); + return node; +} +function tsModuleDeclaration(id, body) { + const node = { + type: "TSModuleDeclaration", + id, + body, + kind: null + }; + const defs = NODE_FIELDS.TSModuleDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.body, node, "body", body, 1); + return node; +} +function tsModuleBlock(body) { + const node = { + type: "TSModuleBlock", + body + }; + const defs = NODE_FIELDS.TSModuleBlock; + validate(defs.body, node, "body", body, 1); + return node; +} +function tsImportType(argument, qualifier = null, typeParameters = null) { + const node = { + type: "TSImportType", + argument, + qualifier, + typeParameters + }; + const defs = NODE_FIELDS.TSImportType; + validate(defs.argument, node, "argument", argument, 1); + validate(defs.qualifier, node, "qualifier", qualifier, 1); + validate(defs.typeParameters, node, "typeParameters", typeParameters, 1); + return node; +} +function tsImportEqualsDeclaration(id, moduleReference) { + const node = { + type: "TSImportEqualsDeclaration", + id, + moduleReference, + isExport: null + }; + const defs = NODE_FIELDS.TSImportEqualsDeclaration; + validate(defs.id, node, "id", id, 1); + validate(defs.moduleReference, node, "moduleReference", moduleReference, 1); + return node; +} +function tsExternalModuleReference(expression) { + const node = { + type: "TSExternalModuleReference", + expression + }; + const defs = NODE_FIELDS.TSExternalModuleReference; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function tsNonNullExpression(expression) { + const node = { + type: "TSNonNullExpression", + expression + }; + const defs = NODE_FIELDS.TSNonNullExpression; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function tsExportAssignment(expression) { + const node = { + type: "TSExportAssignment", + expression + }; + const defs = NODE_FIELDS.TSExportAssignment; + validate(defs.expression, node, "expression", expression, 1); + return node; +} +function tsNamespaceExportDeclaration(id) { + const node = { + type: "TSNamespaceExportDeclaration", + id + }; + const defs = NODE_FIELDS.TSNamespaceExportDeclaration; + validate(defs.id, node, "id", id, 1); + return node; +} +function tsTypeAnnotation(typeAnnotation) { + const node = { + type: "TSTypeAnnotation", + typeAnnotation + }; + const defs = NODE_FIELDS.TSTypeAnnotation; + validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1); + return node; +} +function tsTypeParameterInstantiation(params) { + const node = { + type: "TSTypeParameterInstantiation", + params + }; + const defs = NODE_FIELDS.TSTypeParameterInstantiation; + validate(defs.params, node, "params", params, 1); + return node; +} +function tsTypeParameterDeclaration(params) { + const node = { + type: "TSTypeParameterDeclaration", + params + }; + const defs = NODE_FIELDS.TSTypeParameterDeclaration; + validate(defs.params, node, "params", params, 1); + return node; +} +function tsTypeParameter(constraint = null, _default = null, name) { + const node = { + type: "TSTypeParameter", + constraint, + default: _default, + name + }; + const defs = NODE_FIELDS.TSTypeParameter; + validate(defs.constraint, node, "constraint", constraint, 1); + validate(defs.default, node, "default", _default, 1); + validate(defs.name, node, "name", name); + return node; +} +function NumberLiteral(value) { + (0, _deprecationWarning.default)("NumberLiteral", "NumericLiteral", "The node type "); + return numericLiteral(value); +} +function RegexLiteral(pattern, flags = "") { + (0, _deprecationWarning.default)("RegexLiteral", "RegExpLiteral", "The node type "); + return regExpLiteral(pattern, flags); +} +function RestProperty(argument) { + (0, _deprecationWarning.default)("RestProperty", "RestElement", "The node type "); + return restElement(argument); +} +function SpreadProperty(argument) { + (0, _deprecationWarning.default)("SpreadProperty", "SpreadElement", "The node type "); + return spreadElement(argument); +} + +//# sourceMappingURL=lowercase.js.map + +}, function(modId) { var map = {"../../validators/validate.js":1771034509031,"../../utils/deprecationWarning.js":1771034509025,"../../definitions/utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509031, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = validate; +exports.validateChild = validateChild; +exports.validateField = validateField; +exports.validateInternal = validateInternal; +var _index = require("../definitions/index.js"); +function validate(node, key, val) { + if (!node) return; + const fields = _index.NODE_FIELDS[node.type]; + if (!fields) return; + const field = fields[key]; + validateField(node, key, val, field); + validateChild(node, key, val); +} +function validateInternal(field, node, key, val, maybeNode) { + if (!(field != null && field.validate)) return; + if (field.optional && val == null) return; + field.validate(node, key, val); + if (maybeNode) { + var _NODE_PARENT_VALIDATI; + const type = val.type; + if (type == null) return; + (_NODE_PARENT_VALIDATI = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI.call(_index.NODE_PARENT_VALIDATIONS, node, key, val); + } +} +function validateField(node, key, val, field) { + if (!(field != null && field.validate)) return; + if (field.optional && val == null) return; + field.validate(node, key, val); +} +function validateChild(node, key, val) { + var _NODE_PARENT_VALIDATI2; + const type = val == null ? void 0 : val.type; + if (type == null) return; + (_NODE_PARENT_VALIDATI2 = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI2.call(_index.NODE_PARENT_VALIDATIONS, node, key, val); +} + +//# sourceMappingURL=validate.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509032, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "ALIAS_KEYS", { + enumerable: true, + get: function () { + return _utils.ALIAS_KEYS; + } +}); +Object.defineProperty(exports, "BUILDER_KEYS", { + enumerable: true, + get: function () { + return _utils.BUILDER_KEYS; + } +}); +Object.defineProperty(exports, "DEPRECATED_ALIASES", { + enumerable: true, + get: function () { + return _deprecatedAliases.DEPRECATED_ALIASES; + } +}); +Object.defineProperty(exports, "DEPRECATED_KEYS", { + enumerable: true, + get: function () { + return _utils.DEPRECATED_KEYS; + } +}); +Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", { + enumerable: true, + get: function () { + return _utils.FLIPPED_ALIAS_KEYS; + } +}); +Object.defineProperty(exports, "NODE_FIELDS", { + enumerable: true, + get: function () { + return _utils.NODE_FIELDS; + } +}); +Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", { + enumerable: true, + get: function () { + return _utils.NODE_PARENT_VALIDATIONS; + } +}); +Object.defineProperty(exports, "NODE_UNION_SHAPES__PRIVATE", { + enumerable: true, + get: function () { + return _utils.NODE_UNION_SHAPES__PRIVATE; + } +}); +Object.defineProperty(exports, "PLACEHOLDERS", { + enumerable: true, + get: function () { + return _placeholders.PLACEHOLDERS; + } +}); +Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", { + enumerable: true, + get: function () { + return _placeholders.PLACEHOLDERS_ALIAS; + } +}); +Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", { + enumerable: true, + get: function () { + return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS; + } +}); +exports.TYPES = void 0; +Object.defineProperty(exports, "VISITOR_KEYS", { + enumerable: true, + get: function () { + return _utils.VISITOR_KEYS; + } +}); +require("./core.js"); +require("./flow.js"); +require("./jsx.js"); +require("./misc.js"); +require("./experimental.js"); +require("./typescript.js"); +var _utils = require("./utils.js"); +var _placeholders = require("./placeholders.js"); +var _deprecatedAliases = require("./deprecated-aliases.js"); +Object.keys(_deprecatedAliases.DEPRECATED_ALIASES).forEach(deprecatedAlias => { + _utils.FLIPPED_ALIAS_KEYS[deprecatedAlias] = _utils.FLIPPED_ALIAS_KEYS[_deprecatedAliases.DEPRECATED_ALIASES[deprecatedAlias]]; +}); +for (const { + types, + set +} of _utils.allExpandedTypes) { + for (const type of types) { + const aliases = _utils.FLIPPED_ALIAS_KEYS[type]; + if (aliases) { + aliases.forEach(set.add, set); + } else { + set.add(type); + } + } +} +const TYPES = exports.TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS)); + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {"./core.js":1771034509033,"./flow.js":1771034509040,"./jsx.js":1771034509041,"./misc.js":1771034509042,"./experimental.js":1771034509044,"./typescript.js":1771034509045,"./utils.js":1771034509039,"./placeholders.js":1771034509043,"./deprecated-aliases.js":1771034509046}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509033, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.patternLikeCommon = exports.importAttributes = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyUnionShapeCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0; +var _is = require("../validators/is.js"); +var _isValidIdentifier = require("../validators/isValidIdentifier.js"); +var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); +var _helperStringParser = require("@babel/helper-string-parser"); +var _index = require("../constants/index.js"); +var _utils = require("./utils.js"); +const classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({ + unionShape: { + discriminator: "computed", + shapes: [{ + name: "computed", + value: [true], + properties: { + key: { + validate: (0, _utils.assertNodeType)("Expression") + } + } + }, { + name: "nonComputed", + value: [false], + properties: { + key: { + validate: allowPrivateName ? (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") : (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral") + } + } + }] + } +}); +exports.classMethodOrPropertyUnionShapeCommon = classMethodOrPropertyUnionShapeCommon; +const defineType = (0, _utils.defineAliasedType)("Standardized"); +defineType("ArrayExpression", { + fields: { + elements: { + validate: (0, _utils.arrayOf)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement")), + default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined + } + }, + visitor: ["elements"], + aliases: ["Expression"] +}); +defineType("AssignmentExpression", { + fields: { + operator: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("string") : Object.assign(function () { + const identifier = (0, _utils.assertOneOf)(..._index.ASSIGNMENT_OPERATORS); + const pattern = (0, _utils.assertOneOf)("="); + return function (node, key, val) { + const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier; + validator(node, key, val); + }; + }(), { + oneOf: _index.ASSIGNMENT_OPERATORS + }) + }, + left: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal", "OptionalMemberExpression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + builder: ["operator", "left", "right"], + visitor: ["left", "right"], + aliases: ["Expression"] +}); +defineType("BinaryExpression", { + builder: ["operator", "left", "right"], + fields: { + operator: { + validate: (0, _utils.assertOneOf)(..._index.BINARY_OPERATORS) + }, + left: { + validate: function () { + const expression = (0, _utils.assertNodeType)("Expression"); + const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName"); + const validator = Object.assign(function (node, key, val) { + const validator = node.operator === "in" ? inOp : expression; + validator(node, key, val); + }, { + oneOfNodeTypes: ["Expression", "PrivateName"] + }); + return validator; + }() + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + visitor: ["left", "right"], + aliases: ["Binary", "Expression"] +}); +defineType("InterpreterDirective", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + } +}); +defineType("Directive", { + visitor: ["value"], + fields: { + value: { + validate: (0, _utils.assertNodeType)("DirectiveLiteral") + } + } +}); +defineType("DirectiveLiteral", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + } +}); +defineType("BlockStatement", { + builder: ["body", "directives"], + visitor: ["directives", "body"], + fields: { + directives: { + validate: (0, _utils.arrayOfType)("Directive"), + default: [] + }, + body: (0, _utils.validateArrayOfType)("Statement") + }, + aliases: ["Scopable", "BlockParent", "Block", "Statement"] +}); +defineType("BreakStatement", { + visitor: ["label"], + fields: { + label: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + } + }, + aliases: ["Statement", "Terminatorless", "CompletionStatement"] +}); +defineType("CallExpression", { + visitor: ["callee", "typeParameters", "typeArguments", "arguments"], + builder: ["callee", "arguments"], + aliases: ["Expression"], + fields: Object.assign({ + callee: { + validate: (0, _utils.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier") + }, + arguments: (0, _utils.validateArrayOfType)("Expression", "SpreadElement", "ArgumentPlaceholder"), + typeArguments: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), + optional: true + } + }, process.env.BABEL_TYPES_8_BREAKING ? {} : { + optional: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), + optional: true + } + }) +}); +defineType("CatchClause", { + visitor: ["param", "body"], + fields: { + param: { + validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + } + }, + aliases: ["Scopable", "BlockParent"] +}); +defineType("ConditionalExpression", { + visitor: ["test", "consequent", "alternate"], + fields: { + test: { + validate: (0, _utils.assertNodeType)("Expression") + }, + consequent: { + validate: (0, _utils.assertNodeType)("Expression") + }, + alternate: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + aliases: ["Expression", "Conditional"] +}); +defineType("ContinueStatement", { + visitor: ["label"], + fields: { + label: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + } + }, + aliases: ["Statement", "Terminatorless", "CompletionStatement"] +}); +defineType("DebuggerStatement", { + aliases: ["Statement"] +}); +defineType("DoWhileStatement", { + builder: ["test", "body"], + visitor: ["body", "test"], + fields: { + test: { + validate: (0, _utils.assertNodeType)("Expression") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + }, + aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"] +}); +defineType("EmptyStatement", { + aliases: ["Statement"] +}); +defineType("ExpressionStatement", { + visitor: ["expression"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + aliases: ["Statement", "ExpressionWrapper"] +}); +defineType("File", { + builder: ["program", "comments", "tokens"], + visitor: ["program"], + fields: { + program: { + validate: (0, _utils.assertNodeType)("Program") + }, + comments: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, { + each: { + oneOfNodeTypes: ["CommentBlock", "CommentLine"] + } + }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")), + optional: true + }, + tokens: { + validate: (0, _utils.assertEach)(Object.assign(() => {}, { + type: "any" + })), + optional: true + } + } +}); +defineType("ForInStatement", { + visitor: ["left", "right", "body"], + aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], + fields: { + left: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +defineType("ForStatement", { + visitor: ["init", "test", "update", "body"], + aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"], + fields: { + init: { + validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"), + optional: true + }, + test: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + update: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +const functionCommon = () => ({ + params: (0, _utils.validateArrayOfType)("FunctionParameter"), + generator: { + default: false + }, + async: { + default: false + } +}); +exports.functionCommon = functionCommon; +const functionTypeAnnotationCommon = () => ({ + returnType: { + validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), + optional: true + } +}); +exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; +const functionDeclarationCommon = () => Object.assign({}, functionCommon(), { + declare: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + id: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + } +}); +exports.functionDeclarationCommon = functionDeclarationCommon; +defineType("FunctionDeclaration", { + builder: ["id", "params", "body", "generator", "async"], + visitor: ["id", "typeParameters", "params", "predicate", "returnType", "body"], + fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), { + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + }, + predicate: { + validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), + optional: true + } + }), + aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"], + validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () { + const identifier = (0, _utils.assertNodeType)("Identifier"); + return function (parent, key, node) { + if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { + identifier(node, "id", node.id); + } + }; + }() +}); +defineType("FunctionExpression", { + inherits: "FunctionDeclaration", + aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], + fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { + id: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + }, + predicate: { + validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), + optional: true + } + }) +}); +const patternLikeCommon = () => ({ + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), + optional: true + }, + optional: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } +}); +exports.patternLikeCommon = patternLikeCommon; +defineType("Identifier", { + builder: ["name"], + visitor: ["typeAnnotation", "decorators"], + aliases: ["Expression", "FunctionParameter", "PatternLike", "LVal", "TSEntityName"], + fields: Object.assign({}, patternLikeCommon(), { + name: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { + if (!(0, _isValidIdentifier.default)(val, false)) { + throw new TypeError(`"${val}" is not a valid identifier name`); + } + }, { + type: "string" + })) : (0, _utils.assertValueType)("string") + } + }), + validate: process.env.BABEL_TYPES_8_BREAKING ? function (parent, key, node) { + const match = /\.(\w+)$/.exec(key.toString()); + if (!match) return; + const [, parentKey] = match; + const nonComp = { + computed: false + }; + if (parentKey === "property") { + if ((0, _is.default)("MemberExpression", parent, nonComp)) return; + if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return; + } else if (parentKey === "key") { + if ((0, _is.default)("Property", parent, nonComp)) return; + if ((0, _is.default)("Method", parent, nonComp)) return; + } else if (parentKey === "exported") { + if ((0, _is.default)("ExportSpecifier", parent)) return; + } else if (parentKey === "imported") { + if ((0, _is.default)("ImportSpecifier", parent, { + imported: node + })) return; + } else if (parentKey === "meta") { + if ((0, _is.default)("MetaProperty", parent, { + meta: node + })) return; + } + if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") { + throw new TypeError(`"${node.name}" is not a valid identifier`); + } + } : undefined +}); +defineType("IfStatement", { + visitor: ["test", "consequent", "alternate"], + aliases: ["Statement", "Conditional"], + fields: { + test: { + validate: (0, _utils.assertNodeType)("Expression") + }, + consequent: { + validate: (0, _utils.assertNodeType)("Statement") + }, + alternate: { + optional: true, + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +defineType("LabeledStatement", { + visitor: ["label", "body"], + aliases: ["Statement"], + fields: { + label: { + validate: (0, _utils.assertNodeType)("Identifier") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +defineType("StringLiteral", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + }, + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +defineType("NumericLiteral", { + builder: ["value"], + deprecatedAlias: "NumberLiteral", + fields: { + value: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("number"), Object.assign(function (node, key, val) { + if (1 / val < 0 || !Number.isFinite(val)) { + const error = new Error("NumericLiterals must be non-negative finite numbers. " + `You can use t.valueToNode(${val}) instead.`); + } + }, { + type: "number" + })) + } + }, + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +defineType("NullLiteral", { + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +defineType("BooleanLiteral", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("boolean") + } + }, + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +defineType("RegExpLiteral", { + builder: ["pattern", "flags"], + deprecatedAlias: "RegexLiteral", + aliases: ["Expression", "Pureish", "Literal"], + fields: { + pattern: { + validate: (0, _utils.assertValueType)("string") + }, + flags: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { + const invalid = /[^dgimsuvy]/.exec(val); + if (invalid) { + throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`); + } + }, { + type: "string" + })) : (0, _utils.assertValueType)("string"), + default: "" + } + } +}); +defineType("LogicalExpression", { + builder: ["operator", "left", "right"], + visitor: ["left", "right"], + aliases: ["Binary", "Expression"], + fields: { + operator: { + validate: (0, _utils.assertOneOf)(..._index.LOGICAL_OPERATORS) + }, + left: { + validate: (0, _utils.assertNodeType)("Expression") + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("MemberExpression", { + builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])], + visitor: ["object", "property"], + aliases: ["Expression", "LVal", "PatternLike"], + unionShape: { + discriminator: "computed", + shapes: [{ + name: "computed", + value: [true], + properties: { + property: { + validate: (0, _utils.assertNodeType)("Expression") + } + } + }, { + name: "nonComputed", + value: [false], + properties: { + property: { + validate: (0, _utils.assertNodeType)("Identifier", "PrivateName") + } + } + }] + }, + fields: Object.assign({ + object: { + validate: (0, _utils.assertNodeType)("Expression", "Super") + }, + property: { + validate: function () { + const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); + const computed = (0, _utils.assertNodeType)("Expression"); + const validator = function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }; + validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"]; + return validator; + }() + }, + computed: { + default: false + } + }, !process.env.BABEL_TYPES_8_BREAKING ? { + optional: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + } + } : {}) +}); +defineType("NewExpression", { + inherits: "CallExpression" +}); +defineType("Program", { + visitor: ["directives", "body"], + builder: ["body", "directives", "sourceType", "interpreter"], + fields: { + sourceType: { + validate: (0, _utils.assertOneOf)("script", "module"), + default: "script" + }, + interpreter: { + validate: (0, _utils.assertNodeType)("InterpreterDirective"), + default: null, + optional: true + }, + directives: { + validate: (0, _utils.arrayOfType)("Directive"), + default: [] + }, + body: (0, _utils.validateArrayOfType)("Statement") + }, + aliases: ["Scopable", "BlockParent", "Block"] +}); +defineType("ObjectExpression", { + visitor: ["properties"], + aliases: ["Expression"], + fields: { + properties: (0, _utils.validateArrayOfType)("ObjectMethod", "ObjectProperty", "SpreadElement") + } +}); +defineType("ObjectMethod", Object.assign({ + builder: ["kind", "key", "params", "body", "computed", "generator", "async"], + visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"] +}, classMethodOrPropertyUnionShapeCommon(), { + fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { + kind: Object.assign({ + validate: (0, _utils.assertOneOf)("method", "get", "set") + }, !process.env.BABEL_TYPES_8_BREAKING ? { + default: "method" + } : {}), + computed: { + default: false + }, + key: { + validate: function () { + const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"); + const computed = (0, _utils.assertNodeType)("Expression"); + const validator = function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }; + validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"]; + return validator; + }() + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + } + }), + aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"] +})); +defineType("ObjectProperty", { + builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])], + unionShape: { + discriminator: "computed", + shapes: [{ + name: "computed", + value: [true], + properties: { + key: { + validate: (0, _utils.assertNodeType)("Expression") + } + } + }, { + name: "nonComputed", + value: [false], + properties: { + key: { + validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName") + } + } + }] + }, + fields: { + computed: { + default: false + }, + key: { + validate: function () { + const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"); + const computed = (0, _utils.assertNodeType)("Expression"); + const validator = Object.assign(function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }, { + oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"] + }); + return validator; + }() + }, + value: { + validate: (0, _utils.assertNodeType)("Expression", "PatternLike") + }, + shorthand: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, shorthand) { + if (!shorthand) return; + if (node.computed) { + throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true"); + } + if (!(0, _is.default)("Identifier", node.key)) { + throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier"); + } + }, { + type: "boolean" + })) : (0, _utils.assertValueType)("boolean"), + default: false + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } + }, + visitor: ["decorators", "key", "value"], + aliases: ["UserWhitespacable", "Property", "ObjectMember"], + validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () { + const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion"); + const expression = (0, _utils.assertNodeType)("Expression"); + return function (parent, key, node) { + const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression; + validator(node, "value", node.value); + }; + }() +}); +defineType("RestElement", { + visitor: ["argument", "typeAnnotation"], + builder: ["argument"], + aliases: ["FunctionParameter", "PatternLike", "LVal"], + deprecatedAlias: "RestProperty", + fields: Object.assign({}, patternLikeCommon(), { + argument: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression", "RestElement", "AssignmentPattern") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") + } + }), + validate: process.env.BABEL_TYPES_8_BREAKING ? function (parent, key) { + const match = /(\w+)\[(\d+)\]/.exec(key.toString()); + if (!match) throw new Error("Internal Babel error: malformed key."); + const [, listKey, index] = match; + if (parent[listKey].length > +index + 1) { + throw new TypeError(`RestElement must be last element of ${listKey}`); + } + } : undefined +}); +defineType("ReturnStatement", { + visitor: ["argument"], + aliases: ["Statement", "Terminatorless", "CompletionStatement"], + fields: { + argument: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + } + } +}); +defineType("SequenceExpression", { + visitor: ["expressions"], + fields: { + expressions: (0, _utils.validateArrayOfType)("Expression") + }, + aliases: ["Expression"] +}); +defineType("ParenthesizedExpression", { + visitor: ["expression"], + aliases: ["Expression", "ExpressionWrapper"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("SwitchCase", { + visitor: ["test", "consequent"], + fields: { + test: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + consequent: (0, _utils.validateArrayOfType)("Statement") + } +}); +defineType("SwitchStatement", { + visitor: ["discriminant", "cases"], + aliases: ["Statement", "BlockParent", "Scopable"], + fields: { + discriminant: { + validate: (0, _utils.assertNodeType)("Expression") + }, + cases: (0, _utils.validateArrayOfType)("SwitchCase") + } +}); +defineType("ThisExpression", { + aliases: ["Expression"] +}); +defineType("ThrowStatement", { + visitor: ["argument"], + aliases: ["Statement", "Terminatorless", "CompletionStatement"], + fields: { + argument: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("TryStatement", { + visitor: ["block", "handler", "finalizer"], + aliases: ["Statement"], + fields: { + block: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) { + if (!node.handler && !node.finalizer) { + throw new TypeError("TryStatement expects either a handler or finalizer, or both"); + } + }, { + oneOfNodeTypes: ["BlockStatement"] + })) : (0, _utils.assertNodeType)("BlockStatement") + }, + handler: { + optional: true, + validate: (0, _utils.assertNodeType)("CatchClause") + }, + finalizer: { + optional: true, + validate: (0, _utils.assertNodeType)("BlockStatement") + } + } +}); +defineType("UnaryExpression", { + builder: ["operator", "argument", "prefix"], + fields: { + prefix: { + default: true + }, + argument: { + validate: (0, _utils.assertNodeType)("Expression") + }, + operator: { + validate: (0, _utils.assertOneOf)(..._index.UNARY_OPERATORS) + } + }, + visitor: ["argument"], + aliases: ["UnaryLike", "Expression"] +}); +defineType("UpdateExpression", { + builder: ["operator", "argument", "prefix"], + fields: { + prefix: { + default: false + }, + argument: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression") + }, + operator: { + validate: (0, _utils.assertOneOf)(..._index.UPDATE_OPERATORS) + } + }, + visitor: ["argument"], + aliases: ["Expression"] +}); +defineType("VariableDeclaration", { + builder: ["kind", "declarations"], + visitor: ["declarations"], + aliases: ["Statement", "Declaration"], + fields: { + declare: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + kind: { + validate: (0, _utils.assertOneOf)("var", "let", "const", "using", "await using") + }, + declarations: (0, _utils.validateArrayOfType)("VariableDeclarator") + }, + validate: process.env.BABEL_TYPES_8_BREAKING ? (() => { + const withoutInit = (0, _utils.assertNodeType)("Identifier", "Placeholder"); + const constOrLetOrVar = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "Placeholder"); + const usingOrAwaitUsing = (0, _utils.assertNodeType)("Identifier", "VoidPattern", "Placeholder"); + return function (parent, key, node) { + const { + kind, + declarations + } = node; + const parentIsForX = (0, _is.default)("ForXStatement", parent, { + left: node + }); + if (parentIsForX) { + if (declarations.length !== 1) { + throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`); + } + } + for (const decl of declarations) { + if (kind === "const" || kind === "let" || kind === "var") { + if (!parentIsForX && !decl.init) { + withoutInit(decl, "id", decl.id); + } else { + constOrLetOrVar(decl, "id", decl.id); + } + } else { + usingOrAwaitUsing(decl, "id", decl.id); + } + } + }; + })() : undefined +}); +defineType("VariableDeclarator", { + visitor: ["id", "init"], + fields: { + id: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal", "VoidPattern") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "VoidPattern") + }, + definite: { + optional: true, + validate: (0, _utils.assertValueType)("boolean") + }, + init: { + optional: true, + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("WhileStatement", { + visitor: ["test", "body"], + aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"], + fields: { + test: { + validate: (0, _utils.assertNodeType)("Expression") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +defineType("WithStatement", { + visitor: ["object", "body"], + aliases: ["Statement"], + fields: { + object: { + validate: (0, _utils.assertNodeType)("Expression") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + } + } +}); +defineType("AssignmentPattern", { + visitor: ["left", "right", "decorators"], + builder: ["left", "right"], + aliases: ["FunctionParameter", "Pattern", "PatternLike", "LVal"], + fields: Object.assign({}, patternLikeCommon(), { + left: { + validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } + }) +}); +defineType("ArrayPattern", { + visitor: ["elements", "typeAnnotation"], + builder: ["elements"], + aliases: ["FunctionParameter", "Pattern", "PatternLike", "LVal"], + fields: Object.assign({}, patternLikeCommon(), { + elements: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike"))) + } + }) +}); +defineType("ArrowFunctionExpression", { + builder: ["params", "body", "async"], + visitor: ["typeParameters", "params", "predicate", "returnType", "body"], + aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], + fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { + expression: { + validate: (0, _utils.assertValueType)("boolean") + }, + body: { + validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") + }, + predicate: { + validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), + optional: true + } + }) +}); +defineType("ClassBody", { + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock") + } +}); +defineType("ClassExpression", { + builder: ["id", "superClass", "body", "decorators"], + visitor: ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "mixins", "implements", "body"], + aliases: ["Scopable", "Class", "Expression"], + fields: { + id: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("ClassBody") + }, + superClass: { + optional: true, + validate: (0, _utils.assertNodeType)("Expression") + }, + ["superTypeParameters"]: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), + optional: true + }, + implements: { + validate: (0, _utils.arrayOfType)("TSExpressionWithTypeArguments", "ClassImplements"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + mixins: { + validate: (0, _utils.assertNodeType)("InterfaceExtends"), + optional: true + } + } +}); +defineType("ClassDeclaration", { + inherits: "ClassExpression", + aliases: ["Scopable", "Class", "Statement", "Declaration"], + fields: { + id: { + validate: (0, _utils.assertNodeType)("Identifier"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), + optional: true + }, + body: { + validate: (0, _utils.assertNodeType)("ClassBody") + }, + superClass: { + optional: true, + validate: (0, _utils.assertNodeType)("Expression") + }, + ["superTypeParameters"]: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), + optional: true + }, + implements: { + validate: (0, _utils.arrayOfType)("TSExpressionWithTypeArguments", "ClassImplements"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + mixins: { + validate: (0, _utils.assertNodeType)("InterfaceExtends"), + optional: true + }, + declare: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + abstract: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + } + }, + validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () { + const identifier = (0, _utils.assertNodeType)("Identifier"); + return function (parent, key, node) { + if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { + identifier(node, "id", node.id); + } + }; + }() +}); +const importAttributes = exports.importAttributes = { + attributes: { + optional: true, + validate: (0, _utils.arrayOfType)("ImportAttribute") + } +}; +importAttributes.assertions = { + deprecated: true, + optional: true, + validate: (0, _utils.arrayOfType)("ImportAttribute") +}; +defineType("ExportAllDeclaration", { + builder: ["source", "attributes"], + visitor: ["source", "attributes", "assertions"], + aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"], + fields: Object.assign({ + source: { + validate: (0, _utils.assertNodeType)("StringLiteral") + }, + exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) + }, importAttributes) +}); +defineType("ExportDefaultDeclaration", { + visitor: ["declaration"], + aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"], + fields: { + declaration: (0, _utils.validateType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression"), + exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value")) + } +}); +defineType("ExportNamedDeclaration", { + builder: ["declaration", "specifiers", "source", "attributes"], + visitor: ["declaration", "specifiers", "source", "attributes", "assertions"], + aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"], + fields: Object.assign({ + declaration: { + optional: true, + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) { + if (val && node.specifiers.length) { + throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration"); + } + if (val && node.source) { + throw new TypeError("Cannot export a declaration from a source"); + } + }, { + oneOfNodeTypes: ["Declaration"] + })) : (0, _utils.assertNodeType)("Declaration") + } + }, importAttributes, { + specifiers: { + default: [], + validate: (0, _utils.arrayOf)(function () { + const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"); + const sourceless = (0, _utils.assertNodeType)("ExportSpecifier"); + if (!process.env.BABEL_TYPES_8_BREAKING) return sourced; + return Object.assign(function (node, key, val) { + const validator = node.source ? sourced : sourceless; + validator(node, key, val); + }, { + oneOfNodeTypes: ["ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"] + }); + }()) + }, + source: { + validate: (0, _utils.assertNodeType)("StringLiteral"), + optional: true + }, + exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) + }) +}); +defineType("ExportSpecifier", { + visitor: ["local", "exported"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: (0, _utils.assertNodeType)("Identifier") + }, + exported: { + validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") + }, + exportKind: { + validate: (0, _utils.assertOneOf)("type", "value"), + optional: true + } + } +}); +defineType("ForOfStatement", { + visitor: ["left", "right", "body"], + builder: ["left", "right", "body", "await"], + aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], + fields: { + left: { + validate: function () { + if (!process.env.BABEL_TYPES_8_BREAKING) { + return (0, _utils.assertNodeType)("VariableDeclaration", "LVal"); + } + const declaration = (0, _utils.assertNodeType)("VariableDeclaration"); + const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression"); + return Object.assign(function (node, key, val) { + if ((0, _is.default)("VariableDeclaration", val)) { + declaration(node, key, val); + } else { + lval(node, key, val); + } + }, { + oneOfNodeTypes: ["VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression"] + }); + }() + }, + right: { + validate: (0, _utils.assertNodeType)("Expression") + }, + body: { + validate: (0, _utils.assertNodeType)("Statement") + }, + await: { + default: false + } + } +}); +defineType("ImportDeclaration", { + builder: ["specifiers", "source", "attributes"], + visitor: ["specifiers", "source", "attributes", "assertions"], + aliases: ["Statement", "Declaration", "ImportOrExportDeclaration"], + fields: Object.assign({}, importAttributes, { + module: { + optional: true, + validate: (0, _utils.assertValueType)("boolean") + }, + phase: { + default: null, + validate: (0, _utils.assertOneOf)("source", "defer") + }, + specifiers: (0, _utils.validateArrayOfType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"), + source: { + validate: (0, _utils.assertNodeType)("StringLiteral") + }, + importKind: { + validate: (0, _utils.assertOneOf)("type", "typeof", "value"), + optional: true + } + }) +}); +defineType("ImportDefaultSpecifier", { + visitor: ["local"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +defineType("ImportNamespaceSpecifier", { + visitor: ["local"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +defineType("ImportSpecifier", { + visitor: ["imported", "local"], + builder: ["local", "imported"], + aliases: ["ModuleSpecifier"], + fields: { + local: { + validate: (0, _utils.assertNodeType)("Identifier") + }, + imported: { + validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") + }, + importKind: { + validate: (0, _utils.assertOneOf)("type", "typeof", "value"), + optional: true + } + } +}); +defineType("ImportExpression", { + visitor: ["source", "options"], + aliases: ["Expression"], + fields: { + phase: { + default: null, + validate: (0, _utils.assertOneOf)("source", "defer") + }, + source: { + validate: (0, _utils.assertNodeType)("Expression") + }, + options: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + } + } +}); +defineType("MetaProperty", { + visitor: ["meta", "property"], + aliases: ["Expression"], + fields: { + meta: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) { + let property; + switch (val.name) { + case "function": + property = "sent"; + break; + case "new": + property = "target"; + break; + case "import": + property = "meta"; + break; + } + if (!(0, _is.default)("Identifier", node.property, { + name: property + })) { + throw new TypeError("Unrecognised MetaProperty"); + } + }, { + oneOfNodeTypes: ["Identifier"] + })) : (0, _utils.assertNodeType)("Identifier") + }, + property: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +const classMethodOrPropertyCommon = () => ({ + abstract: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + accessibility: { + validate: (0, _utils.assertOneOf)("public", "private", "protected"), + optional: true + }, + static: { + default: false + }, + override: { + default: false + }, + computed: { + default: false + }, + optional: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + key: { + validate: (0, _utils.chain)(function () { + const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"); + const computed = (0, _utils.assertNodeType)("Expression"); + return function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }; + }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression")) + } +}); +exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; +const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), { + params: (0, _utils.validateArrayOfType)("FunctionParameter", "TSParameterProperty"), + kind: { + validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"), + default: "method" + }, + access: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } +}); +exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; +defineType("ClassMethod", Object.assign({ + aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], + builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"], + visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"] +}, classMethodOrPropertyUnionShapeCommon(), { + fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), { + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + } + }) +})); +defineType("ObjectPattern", { + visitor: ["decorators", "properties", "typeAnnotation"], + builder: ["properties"], + aliases: ["FunctionParameter", "Pattern", "PatternLike", "LVal"], + fields: Object.assign({}, patternLikeCommon(), { + properties: (0, _utils.validateArrayOfType)("RestElement", "ObjectProperty") + }) +}); +defineType("SpreadElement", { + visitor: ["argument"], + aliases: ["UnaryLike"], + deprecatedAlias: "SpreadProperty", + fields: { + argument: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("Super", { + aliases: ["Expression"] +}); +defineType("TaggedTemplateExpression", { + visitor: ["tag", "typeParameters", "quasi"], + builder: ["tag", "quasi"], + aliases: ["Expression"], + fields: { + tag: { + validate: (0, _utils.assertNodeType)("Expression") + }, + quasi: { + validate: (0, _utils.assertNodeType)("TemplateLiteral") + }, + ["typeParameters"]: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), + optional: true + } + } +}); +defineType("TemplateElement", { + builder: ["value", "tail"], + fields: { + value: { + validate: (0, _utils.chain)((0, _utils.assertShape)({ + raw: { + validate: (0, _utils.assertValueType)("string") + }, + cooked: { + validate: (0, _utils.assertValueType)("string"), + optional: true + } + }), function templateElementCookedValidator(node) { + const raw = node.value.raw; + let unterminatedCalled = false; + const error = () => { + throw new Error("Internal @babel/types error."); + }; + const { + str, + firstInvalidLoc + } = (0, _helperStringParser.readStringContents)("template", raw, 0, 0, 0, { + unterminated() { + unterminatedCalled = true; + }, + strictNumericEscape: error, + invalidEscapeSequence: error, + numericSeparatorInEscapeSequence: error, + unexpectedNumericSeparator: error, + invalidDigit: error, + invalidCodePoint: error + }); + if (!unterminatedCalled) throw new Error("Invalid raw"); + node.value.cooked = firstInvalidLoc ? null : str; + }) + }, + tail: { + default: false + } + } +}); +defineType("TemplateLiteral", { + visitor: ["quasis", "expressions"], + aliases: ["Expression", "Literal"], + fields: { + quasis: (0, _utils.validateArrayOfType)("TemplateElement"), + expressions: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) { + if (node.quasis.length !== val.length + 1) { + throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); + } + }) + } + } +}); +defineType("YieldExpression", { + builder: ["argument", "delegate"], + visitor: ["argument"], + aliases: ["Expression", "Terminatorless"], + fields: { + delegate: { + validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { + if (val && !node.argument) { + throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument"); + } + }, { + type: "boolean" + })) : (0, _utils.assertValueType)("boolean"), + default: false + }, + argument: { + optional: true, + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("AwaitExpression", { + builder: ["argument"], + visitor: ["argument"], + aliases: ["Expression", "Terminatorless"], + fields: { + argument: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("Import", { + aliases: ["Expression"] +}); +defineType("BigIntLiteral", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + }, + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +defineType("ExportNamespaceSpecifier", { + visitor: ["exported"], + aliases: ["ModuleSpecifier"], + fields: { + exported: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +defineType("OptionalMemberExpression", { + builder: ["object", "property", "computed", "optional"], + visitor: ["object", "property"], + aliases: ["Expression"], + fields: { + object: { + validate: (0, _utils.assertNodeType)("Expression") + }, + property: { + validate: function () { + const normal = (0, _utils.assertNodeType)("Identifier"); + const computed = (0, _utils.assertNodeType)("Expression"); + const validator = Object.assign(function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }, { + oneOfNodeTypes: ["Expression", "Identifier"] + }); + return validator; + }() + }, + computed: { + default: false + }, + optional: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) + } + } +}); +defineType("OptionalCallExpression", { + visitor: ["callee", "typeParameters", "typeArguments", "arguments"], + builder: ["callee", "arguments", "optional"], + aliases: ["Expression"], + fields: Object.assign({ + callee: { + validate: (0, _utils.assertNodeType)("Expression") + }, + arguments: (0, _utils.validateArrayOfType)("Expression", "SpreadElement", "ArgumentPlaceholder"), + optional: { + validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) + }, + typeArguments: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), + optional: true + } + }, { + typeParameters: { + validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), + optional: true + } + }) +}); +defineType("ClassProperty", Object.assign({ + visitor: ["decorators", "variance", "key", "typeAnnotation", "value"], + builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], + aliases: ["Property"] +}, classMethodOrPropertyUnionShapeCommon(), { + fields: Object.assign({}, classMethodOrPropertyCommon(), { + value: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + definite: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + readonly: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + declare: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + variance: { + validate: (0, _utils.assertNodeType)("Variance"), + optional: true + } + }) +})); +defineType("ClassAccessorProperty", Object.assign({ + visitor: ["decorators", "key", "typeAnnotation", "value"], + builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], + aliases: ["Property", "Accessor"] +}, classMethodOrPropertyUnionShapeCommon(true), { + fields: Object.assign({}, classMethodOrPropertyCommon(), { + key: { + validate: (0, _utils.chain)(function () { + const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"); + const computed = (0, _utils.assertNodeType)("Expression"); + return function (node, key, val) { + const validator = node.computed ? computed : normal; + validator(node, key, val); + }; + }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName")) + }, + value: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + definite: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + readonly: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + declare: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + variance: { + validate: (0, _utils.assertNodeType)("Variance"), + optional: true + } + }) +})); +defineType("ClassPrivateProperty", { + visitor: ["decorators", "variance", "key", "typeAnnotation", "value"], + builder: ["key", "value", "decorators", "static"], + aliases: ["Property", "Private"], + fields: { + key: { + validate: (0, _utils.assertNodeType)("PrivateName") + }, + value: { + validate: (0, _utils.assertNodeType)("Expression"), + optional: true + }, + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + }, + static: { + validate: (0, _utils.assertValueType)("boolean"), + default: false + }, + readonly: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + optional: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + definite: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + variance: { + validate: (0, _utils.assertNodeType)("Variance"), + optional: true + } + } +}); +defineType("ClassPrivateMethod", { + builder: ["kind", "key", "params", "body", "static"], + visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"], + aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"], + fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), { + kind: { + validate: (0, _utils.assertOneOf)("get", "set", "method"), + default: "method" + }, + key: { + validate: (0, _utils.assertNodeType)("PrivateName") + }, + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + } + }) +}); +defineType("PrivateName", { + visitor: ["id"], + aliases: ["Private"], + fields: { + id: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +defineType("StaticBlock", { + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("Statement") + }, + aliases: ["Scopable", "BlockParent", "FunctionParent"] +}); +defineType("ImportAttribute", { + visitor: ["key", "value"], + fields: { + key: { + validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") + }, + value: { + validate: (0, _utils.assertNodeType)("StringLiteral") + } + } +}); + +//# sourceMappingURL=core.js.map + +}, function(modId) { var map = {"../validators/is.js":1771034509034,"../validators/isValidIdentifier.js":1771034509037,"../constants/index.js":1771034509038,"./utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509034, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = is; +var _shallowEqual = require("../utils/shallowEqual.js"); +var _isType = require("./isType.js"); +var _isPlaceholderType = require("./isPlaceholderType.js"); +var _index = require("../definitions/index.js"); +function is(type, node, opts) { + if (!node) return false; + const matches = (0, _isType.default)(node.type, type); + if (!matches) { + if (!opts && node.type === "Placeholder" && type in _index.FLIPPED_ALIAS_KEYS) { + return (0, _isPlaceholderType.default)(node.expectedNode, type); + } + return false; + } + if (opts === undefined) { + return true; + } else { + return (0, _shallowEqual.default)(node, opts); + } +} + +//# sourceMappingURL=is.js.map + +}, function(modId) { var map = {"../utils/shallowEqual.js":1771034509024,"./isType.js":1771034509035,"./isPlaceholderType.js":1771034509036,"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509035, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isType; +var _index = require("../definitions/index.js"); +function isType(nodeType, targetType) { + if (nodeType === targetType) return true; + if (nodeType == null) return false; + if (_index.ALIAS_KEYS[targetType]) return false; + const aliases = _index.FLIPPED_ALIAS_KEYS[targetType]; + if (aliases != null && aliases.includes(nodeType)) return true; + return false; +} + +//# sourceMappingURL=isType.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509036, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isPlaceholderType; +var _index = require("../definitions/index.js"); +function isPlaceholderType(placeholderType, targetType) { + if (placeholderType === targetType) return true; + const aliases = _index.PLACEHOLDERS_ALIAS[placeholderType]; + if (aliases != null && aliases.includes(targetType)) return true; + return false; +} + +//# sourceMappingURL=isPlaceholderType.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509037, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isValidIdentifier; +var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); +function isValidIdentifier(name, reserved = true) { + if (typeof name !== "string") return false; + if (reserved) { + if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) { + return false; + } + } + return (0, _helperValidatorIdentifier.isIdentifierName)(name); +} + +//# sourceMappingURL=isValidIdentifier.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509038, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0; +const STATEMENT_OR_BLOCK_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"]; +const FLATTENABLE_KEYS = exports.FLATTENABLE_KEYS = ["body", "expressions"]; +const FOR_INIT_KEYS = exports.FOR_INIT_KEYS = ["left", "init"]; +const COMMENT_KEYS = exports.COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"]; +const LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = ["||", "&&", "??"]; +const UPDATE_OPERATORS = exports.UPDATE_OPERATORS = ["++", "--"]; +const BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="]; +const EQUALITY_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="]; +const COMPARISON_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"]; +const BOOLEAN_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS]; +const NUMBER_BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"]; +const BINARY_OPERATORS = exports.BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"]; +const ASSIGNMENT_OPERATORS = exports.ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")]; +const BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = ["delete", "!"]; +const NUMBER_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = ["+", "-", "~"]; +const STRING_UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = ["typeof"]; +const UNARY_OPERATORS = exports.UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS]; +const INHERIT_KEYS = exports.INHERIT_KEYS = { + optional: ["typeAnnotation", "typeParameters", "returnType"], + force: ["start", "loc", "end"] +}; +exports.BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); +exports.NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding"); + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509039, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.allExpandedTypes = exports.VISITOR_KEYS = exports.NODE_UNION_SHAPES__PRIVATE = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0; +exports.arrayOf = arrayOf; +exports.arrayOfType = arrayOfType; +exports.assertEach = assertEach; +exports.assertNodeOrValueType = assertNodeOrValueType; +exports.assertNodeType = assertNodeType; +exports.assertOneOf = assertOneOf; +exports.assertOptionalChainStart = assertOptionalChainStart; +exports.assertShape = assertShape; +exports.assertValueType = assertValueType; +exports.chain = chain; +exports.default = defineType; +exports.defineAliasedType = defineAliasedType; +exports.validate = validate; +exports.validateArrayOfType = validateArrayOfType; +exports.validateOptional = validateOptional; +exports.validateOptionalType = validateOptionalType; +exports.validateType = validateType; +var _is = require("../validators/is.js"); +var _validate = require("../validators/validate.js"); +const VISITOR_KEYS = exports.VISITOR_KEYS = {}; +const ALIAS_KEYS = exports.ALIAS_KEYS = {}; +const FLIPPED_ALIAS_KEYS = exports.FLIPPED_ALIAS_KEYS = {}; +const NODE_FIELDS = exports.NODE_FIELDS = {}; +const BUILDER_KEYS = exports.BUILDER_KEYS = {}; +const DEPRECATED_KEYS = exports.DEPRECATED_KEYS = {}; +const NODE_PARENT_VALIDATIONS = exports.NODE_PARENT_VALIDATIONS = {}; +const NODE_UNION_SHAPES__PRIVATE = exports.NODE_UNION_SHAPES__PRIVATE = {}; +function getType(val) { + if (Array.isArray(val)) { + return "array"; + } else if (val === null) { + return "null"; + } else { + return typeof val; + } +} +function validate(validate) { + return { + validate + }; +} +function validateType(...typeNames) { + return validate(assertNodeType(...typeNames)); +} +function validateOptional(validate) { + return { + validate, + optional: true + }; +} +function validateOptionalType(...typeNames) { + return { + validate: assertNodeType(...typeNames), + optional: true + }; +} +function arrayOf(elementType) { + return chain(assertValueType("array"), assertEach(elementType)); +} +function arrayOfType(...typeNames) { + return arrayOf(assertNodeType(...typeNames)); +} +function validateArrayOfType(...typeNames) { + return validate(arrayOfType(...typeNames)); +} +function assertEach(callback) { + const childValidator = process.env.BABEL_TYPES_8_BREAKING ? _validate.validateChild : () => {}; + function validator(node, key, val) { + if (!Array.isArray(val)) return; + let i = 0; + const subKey = { + toString() { + return `${key}[${i}]`; + } + }; + for (; i < val.length; i++) { + const v = val[i]; + callback(node, subKey, v); + childValidator(node, subKey, v); + } + } + validator.each = callback; + return validator; +} +function assertOneOf(...values) { + function validate(node, key, val) { + if (!values.includes(val)) { + throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`); + } + } + validate.oneOf = values; + return validate; +} +const allExpandedTypes = exports.allExpandedTypes = []; +function assertNodeType(...types) { + const expandedTypes = new Set(); + allExpandedTypes.push({ + types, + set: expandedTypes + }); + function validate(node, key, val) { + const valType = val == null ? void 0 : val.type; + if (valType != null) { + if (expandedTypes.has(valType)) { + (0, _validate.validateChild)(node, key, val); + return; + } + if (valType === "Placeholder") { + for (const type of types) { + if ((0, _is.default)(type, val)) { + (0, _validate.validateChild)(node, key, val); + return; + } + } + } + } + throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(valType)}`); + } + validate.oneOfNodeTypes = types; + return validate; +} +function assertNodeOrValueType(...types) { + function validate(node, key, val) { + const primitiveType = getType(val); + for (const type of types) { + if (primitiveType === type || (0, _is.default)(type, val)) { + (0, _validate.validateChild)(node, key, val); + return; + } + } + throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); + } + validate.oneOfNodeOrValueTypes = types; + return validate; +} +function assertValueType(type) { + function validate(node, key, val) { + if (getType(val) === type) { + return; + } + throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`); + } + validate.type = type; + return validate; +} +function assertShape(shape) { + const keys = Object.keys(shape); + function validate(node, key, val) { + const errors = []; + for (const property of keys) { + try { + (0, _validate.validateField)(node, property, val[property], shape[property]); + } catch (error) { + if (error instanceof TypeError) { + errors.push(error.message); + continue; + } + throw error; + } + } + if (errors.length) { + throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`); + } + } + validate.shapeOf = shape; + return validate; +} +function assertOptionalChainStart() { + function validate(node) { + var _current; + let current = node; + while (node) { + const { + type + } = current; + if (type === "OptionalCallExpression") { + if (current.optional) return; + current = current.callee; + continue; + } + if (type === "OptionalMemberExpression") { + if (current.optional) return; + current = current.object; + continue; + } + break; + } + throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`); + } + return validate; +} +function chain(...fns) { + function validate(...args) { + for (const fn of fns) { + fn(...args); + } + } + validate.chainOf = fns; + if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) { + throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`); + } + return validate; +} +const validTypeOpts = new Set(["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate", "unionShape"]); +const validFieldKeys = new Set(["default", "optional", "deprecated", "validate"]); +const store = {}; +function defineAliasedType(...aliases) { + return (type, opts = {}) => { + let defined = opts.aliases; + if (!defined) { + var _store$opts$inherits$; + if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice(); + defined != null ? defined : defined = []; + opts.aliases = defined; + } + const additional = aliases.filter(a => !defined.includes(a)); + defined.unshift(...additional); + defineType(type, opts); + }; +} +function defineType(type, opts = {}) { + const inherits = opts.inherits && store[opts.inherits] || {}; + let fields = opts.fields; + if (!fields) { + fields = {}; + if (inherits.fields) { + const keys = Object.getOwnPropertyNames(inherits.fields); + for (const key of keys) { + const field = inherits.fields[key]; + const def = field.default; + if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") { + throw new Error("field defaults can only be primitives or empty arrays currently"); + } + fields[key] = { + default: Array.isArray(def) ? [] : def, + optional: field.optional, + deprecated: field.deprecated, + validate: field.validate + }; + } + } + } + const visitor = opts.visitor || inherits.visitor || []; + const aliases = opts.aliases || inherits.aliases || []; + const builder = opts.builder || inherits.builder || opts.visitor || []; + for (const k of Object.keys(opts)) { + if (!validTypeOpts.has(k)) { + throw new Error(`Unknown type option "${k}" on ${type}`); + } + } + if (opts.deprecatedAlias) { + DEPRECATED_KEYS[opts.deprecatedAlias] = type; + } + for (const key of visitor.concat(builder)) { + fields[key] = fields[key] || {}; + } + for (const key of Object.keys(fields)) { + const field = fields[key]; + if (field.default !== undefined && !builder.includes(key)) { + field.optional = true; + } + if (field.default === undefined) { + field.default = null; + } else if (!field.validate && field.default != null) { + field.validate = assertValueType(getType(field.default)); + } + for (const k of Object.keys(field)) { + if (!validFieldKeys.has(k)) { + throw new Error(`Unknown field key "${k}" on ${type}.${key}`); + } + } + } + VISITOR_KEYS[type] = opts.visitor = visitor; + BUILDER_KEYS[type] = opts.builder = builder; + NODE_FIELDS[type] = opts.fields = fields; + ALIAS_KEYS[type] = opts.aliases = aliases; + aliases.forEach(alias => { + FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || []; + FLIPPED_ALIAS_KEYS[alias].push(type); + }); + if (opts.validate) { + NODE_PARENT_VALIDATIONS[type] = opts.validate; + } + if (opts.unionShape) { + NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape; + } + store[type] = opts; +} + +//# sourceMappingURL=utils.js.map + +}, function(modId) { var map = {"../validators/is.js":1771034509034,"../validators/validate.js":1771034509031}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509040, function(require, module, exports) { + + +var _core = require("./core.js"); +var _utils = require("./utils.js"); +const defineType = (0, _utils.defineAliasedType)("Flow"); +const defineInterfaceishType = name => { + const isDeclareClass = name === "DeclareClass"; + defineType(name, { + builder: ["id", "typeParameters", "extends", "body"], + visitor: ["id", "typeParameters", "extends", ...(isDeclareClass ? ["mixins", "implements"] : []), "body"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: Object.assign({ + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")) + }, isDeclareClass ? { + mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), + implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")) + } : {}, { + body: (0, _utils.validateType)("ObjectTypeAnnotation") + }) + }); +}; +defineType("AnyTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("ArrayTypeAnnotation", { + visitor: ["elementType"], + aliases: ["FlowType"], + fields: { + elementType: (0, _utils.validateType)("FlowType") + } +}); +defineType("BooleanTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("BooleanLiteralTypeAnnotation", { + builder: ["value"], + aliases: ["FlowType"], + fields: { + value: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("NullLiteralTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("ClassImplements", { + visitor: ["id", "typeParameters"], + fields: { + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") + } +}); +defineInterfaceishType("DeclareClass"); +defineType("DeclareFunction", { + builder: ["id"], + visitor: ["id", "predicate"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier"), + predicate: (0, _utils.validateOptionalType)("DeclaredPredicate") + } +}); +defineInterfaceishType("DeclareInterface"); +defineType("DeclareModule", { + builder: ["id", "body", "kind"], + visitor: ["id", "body"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier", "StringLiteral"), + body: (0, _utils.validateType)("BlockStatement"), + kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES")) + } +}); +defineType("DeclareModuleExports", { + visitor: ["typeAnnotation"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + typeAnnotation: (0, _utils.validateType)("TypeAnnotation") + } +}); +defineType("DeclareTypeAlias", { + visitor: ["id", "typeParameters", "right"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + right: (0, _utils.validateType)("FlowType") + } +}); +defineType("DeclareOpaqueType", { + visitor: ["id", "typeParameters", "supertype"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + supertype: (0, _utils.validateOptionalType)("FlowType"), + impltype: (0, _utils.validateOptionalType)("FlowType") + } +}); +defineType("DeclareVariable", { + visitor: ["id"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier") + } +}); +defineType("DeclareExportDeclaration", { + visitor: ["declaration", "specifiers", "source", "attributes"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: Object.assign({ + declaration: (0, _utils.validateOptionalType)("Flow"), + specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ExportSpecifier", "ExportNamespaceSpecifier")), + source: (0, _utils.validateOptionalType)("StringLiteral"), + default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) + }, _core.importAttributes) +}); +defineType("DeclareExportAllDeclaration", { + visitor: ["source", "attributes"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: Object.assign({ + source: (0, _utils.validateType)("StringLiteral"), + exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) + }, _core.importAttributes) +}); +defineType("DeclaredPredicate", { + visitor: ["value"], + aliases: ["FlowPredicate"], + fields: { + value: (0, _utils.validateType)("Flow") + } +}); +defineType("ExistsTypeAnnotation", { + aliases: ["FlowType"] +}); +defineType("FunctionTypeAnnotation", { + builder: ["typeParameters", "params", "rest", "returnType"], + visitor: ["typeParameters", "this", "params", "rest", "returnType"], + aliases: ["FlowType"], + fields: { + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + params: (0, _utils.validateArrayOfType)("FunctionTypeParam"), + rest: (0, _utils.validateOptionalType)("FunctionTypeParam"), + this: (0, _utils.validateOptionalType)("FunctionTypeParam"), + returnType: (0, _utils.validateType)("FlowType") + } +}); +defineType("FunctionTypeParam", { + visitor: ["name", "typeAnnotation"], + fields: { + name: (0, _utils.validateOptionalType)("Identifier"), + typeAnnotation: (0, _utils.validateType)("FlowType"), + optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("GenericTypeAnnotation", { + visitor: ["id", "typeParameters"], + aliases: ["FlowType"], + fields: { + id: (0, _utils.validateType)("Identifier", "QualifiedTypeIdentifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") + } +}); +defineType("InferredPredicate", { + aliases: ["FlowPredicate"] +}); +defineType("InterfaceExtends", { + visitor: ["id", "typeParameters"], + fields: { + id: (0, _utils.validateType)("Identifier", "QualifiedTypeIdentifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") + } +}); +defineInterfaceishType("InterfaceDeclaration"); +defineType("InterfaceTypeAnnotation", { + visitor: ["extends", "body"], + aliases: ["FlowType"], + fields: { + extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), + body: (0, _utils.validateType)("ObjectTypeAnnotation") + } +}); +defineType("IntersectionTypeAnnotation", { + visitor: ["types"], + aliases: ["FlowType"], + fields: { + types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) + } +}); +defineType("MixedTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("EmptyTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("NullableTypeAnnotation", { + visitor: ["typeAnnotation"], + aliases: ["FlowType"], + fields: { + typeAnnotation: (0, _utils.validateType)("FlowType") + } +}); +defineType("NumberLiteralTypeAnnotation", { + builder: ["value"], + aliases: ["FlowType"], + fields: { + value: (0, _utils.validate)((0, _utils.assertValueType)("number")) + } +}); +defineType("NumberTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("ObjectTypeAnnotation", { + visitor: ["properties", "indexers", "callProperties", "internalSlots"], + aliases: ["FlowType"], + builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"], + fields: { + properties: (0, _utils.validate)((0, _utils.arrayOfType)("ObjectTypeProperty", "ObjectTypeSpreadProperty")), + indexers: { + validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"), + optional: true, + default: [] + }, + callProperties: { + validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"), + optional: true, + default: [] + }, + internalSlots: { + validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"), + optional: true, + default: [] + }, + exact: { + validate: (0, _utils.assertValueType)("boolean"), + default: false + }, + inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("ObjectTypeInternalSlot", { + visitor: ["id", "value"], + builder: ["id", "value", "optional", "static", "method"], + aliases: ["UserWhitespacable"], + fields: { + id: (0, _utils.validateType)("Identifier"), + value: (0, _utils.validateType)("FlowType"), + optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("ObjectTypeCallProperty", { + visitor: ["value"], + aliases: ["UserWhitespacable"], + fields: { + value: (0, _utils.validateType)("FlowType"), + static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("ObjectTypeIndexer", { + visitor: ["variance", "id", "key", "value"], + builder: ["id", "key", "value", "variance"], + aliases: ["UserWhitespacable"], + fields: { + id: (0, _utils.validateOptionalType)("Identifier"), + key: (0, _utils.validateType)("FlowType"), + value: (0, _utils.validateType)("FlowType"), + static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + variance: (0, _utils.validateOptionalType)("Variance") + } +}); +defineType("ObjectTypeProperty", { + visitor: ["key", "value", "variance"], + aliases: ["UserWhitespacable"], + fields: { + key: (0, _utils.validateType)("Identifier", "StringLiteral"), + value: (0, _utils.validateType)("FlowType"), + kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")), + static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + variance: (0, _utils.validateOptionalType)("Variance"), + method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("ObjectTypeSpreadProperty", { + visitor: ["argument"], + aliases: ["UserWhitespacable"], + fields: { + argument: (0, _utils.validateType)("FlowType") + } +}); +defineType("OpaqueType", { + visitor: ["id", "typeParameters", "supertype", "impltype"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + supertype: (0, _utils.validateOptionalType)("FlowType"), + impltype: (0, _utils.validateType)("FlowType") + } +}); +defineType("QualifiedTypeIdentifier", { + visitor: ["qualification", "id"], + builder: ["id", "qualification"], + fields: { + id: (0, _utils.validateType)("Identifier"), + qualification: (0, _utils.validateType)("Identifier", "QualifiedTypeIdentifier") + } +}); +defineType("StringLiteralTypeAnnotation", { + builder: ["value"], + aliases: ["FlowType"], + fields: { + value: (0, _utils.validate)((0, _utils.assertValueType)("string")) + } +}); +defineType("StringTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("SymbolTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("ThisTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("TupleTypeAnnotation", { + visitor: ["types"], + aliases: ["FlowType"], + fields: { + types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) + } +}); +defineType("TypeofTypeAnnotation", { + visitor: ["argument"], + aliases: ["FlowType"], + fields: { + argument: (0, _utils.validateType)("FlowType") + } +}); +defineType("TypeAlias", { + visitor: ["id", "typeParameters", "right"], + aliases: ["FlowDeclaration", "Statement", "Declaration"], + fields: { + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), + right: (0, _utils.validateType)("FlowType") + } +}); +defineType("TypeAnnotation", { + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("FlowType") + } +}); +defineType("TypeCastExpression", { + visitor: ["expression", "typeAnnotation"], + aliases: ["ExpressionWrapper", "Expression"], + fields: { + expression: (0, _utils.validateType)("Expression"), + typeAnnotation: (0, _utils.validateType)("TypeAnnotation") + } +}); +defineType("TypeParameter", { + visitor: ["bound", "default", "variance"], + fields: { + name: (0, _utils.validate)((0, _utils.assertValueType)("string")), + bound: (0, _utils.validateOptionalType)("TypeAnnotation"), + default: (0, _utils.validateOptionalType)("FlowType"), + variance: (0, _utils.validateOptionalType)("Variance") + } +}); +defineType("TypeParameterDeclaration", { + visitor: ["params"], + fields: { + params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter")) + } +}); +defineType("TypeParameterInstantiation", { + visitor: ["params"], + fields: { + params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) + } +}); +defineType("UnionTypeAnnotation", { + visitor: ["types"], + aliases: ["FlowType"], + fields: { + types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) + } +}); +defineType("Variance", { + builder: ["kind"], + fields: { + kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus")) + } +}); +defineType("VoidTypeAnnotation", { + aliases: ["FlowType", "FlowBaseAnnotation"] +}); +defineType("EnumDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "body"], + fields: { + id: (0, _utils.validateType)("Identifier"), + body: (0, _utils.validateType)("EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody") + } +}); +defineType("EnumBooleanBody", { + aliases: ["EnumBody"], + visitor: ["members"], + fields: { + explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + members: (0, _utils.validateArrayOfType)("EnumBooleanMember"), + hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("EnumNumberBody", { + aliases: ["EnumBody"], + visitor: ["members"], + fields: { + explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + members: (0, _utils.validateArrayOfType)("EnumNumberMember"), + hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("EnumStringBody", { + aliases: ["EnumBody"], + visitor: ["members"], + fields: { + explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), + members: (0, _utils.validateArrayOfType)("EnumStringMember", "EnumDefaultedMember"), + hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("EnumSymbolBody", { + aliases: ["EnumBody"], + visitor: ["members"], + fields: { + members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"), + hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); +defineType("EnumBooleanMember", { + aliases: ["EnumMember"], + builder: ["id"], + visitor: ["id", "init"], + fields: { + id: (0, _utils.validateType)("Identifier"), + init: (0, _utils.validateType)("BooleanLiteral") + } +}); +defineType("EnumNumberMember", { + aliases: ["EnumMember"], + visitor: ["id", "init"], + fields: { + id: (0, _utils.validateType)("Identifier"), + init: (0, _utils.validateType)("NumericLiteral") + } +}); +defineType("EnumStringMember", { + aliases: ["EnumMember"], + visitor: ["id", "init"], + fields: { + id: (0, _utils.validateType)("Identifier"), + init: (0, _utils.validateType)("StringLiteral") + } +}); +defineType("EnumDefaultedMember", { + aliases: ["EnumMember"], + visitor: ["id"], + fields: { + id: (0, _utils.validateType)("Identifier") + } +}); +defineType("IndexedAccessType", { + visitor: ["objectType", "indexType"], + aliases: ["FlowType"], + fields: { + objectType: (0, _utils.validateType)("FlowType"), + indexType: (0, _utils.validateType)("FlowType") + } +}); +defineType("OptionalIndexedAccessType", { + visitor: ["objectType", "indexType"], + aliases: ["FlowType"], + fields: { + objectType: (0, _utils.validateType)("FlowType"), + indexType: (0, _utils.validateType)("FlowType"), + optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) + } +}); + +//# sourceMappingURL=flow.js.map + +}, function(modId) { var map = {"./core.js":1771034509033,"./utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509041, function(require, module, exports) { + + +var _utils = require("./utils.js"); +const defineType = (0, _utils.defineAliasedType)("JSX"); +defineType("JSXAttribute", { + visitor: ["name", "value"], + aliases: ["Immutable"], + fields: { + name: { + validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName") + }, + value: { + optional: true, + validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer") + } + } +}); +defineType("JSXClosingElement", { + visitor: ["name"], + aliases: ["Immutable"], + fields: { + name: { + validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") + } + } +}); +defineType("JSXElement", { + builder: ["openingElement", "closingElement", "children", "selfClosing"], + visitor: ["openingElement", "children", "closingElement"], + aliases: ["Immutable", "Expression"], + fields: Object.assign({ + openingElement: { + validate: (0, _utils.assertNodeType)("JSXOpeningElement") + }, + closingElement: { + optional: true, + validate: (0, _utils.assertNodeType)("JSXClosingElement") + }, + children: (0, _utils.validateArrayOfType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment") + }, { + selfClosing: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + } + }) +}); +defineType("JSXEmptyExpression", {}); +defineType("JSXExpressionContainer", { + visitor: ["expression"], + aliases: ["Immutable"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression") + } + } +}); +defineType("JSXSpreadChild", { + visitor: ["expression"], + aliases: ["Immutable"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("JSXIdentifier", { + builder: ["name"], + fields: { + name: { + validate: (0, _utils.assertValueType)("string") + } + } +}); +defineType("JSXMemberExpression", { + visitor: ["object", "property"], + fields: { + object: { + validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier") + }, + property: { + validate: (0, _utils.assertNodeType)("JSXIdentifier") + } + } +}); +defineType("JSXNamespacedName", { + visitor: ["namespace", "name"], + fields: { + namespace: { + validate: (0, _utils.assertNodeType)("JSXIdentifier") + }, + name: { + validate: (0, _utils.assertNodeType)("JSXIdentifier") + } + } +}); +defineType("JSXOpeningElement", { + builder: ["name", "attributes", "selfClosing"], + visitor: ["name", "typeParameters", "typeArguments", "attributes"], + aliases: ["Immutable"], + fields: Object.assign({ + name: { + validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") + }, + selfClosing: { + default: false + }, + attributes: (0, _utils.validateArrayOfType)("JSXAttribute", "JSXSpreadAttribute"), + typeArguments: { + validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), + optional: true + } + }, { + typeParameters: { + validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), + optional: true + } + }) +}); +defineType("JSXSpreadAttribute", { + visitor: ["argument"], + fields: { + argument: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +defineType("JSXText", { + aliases: ["Immutable"], + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + } +}); +defineType("JSXFragment", { + builder: ["openingFragment", "closingFragment", "children"], + visitor: ["openingFragment", "children", "closingFragment"], + aliases: ["Immutable", "Expression"], + fields: { + openingFragment: { + validate: (0, _utils.assertNodeType)("JSXOpeningFragment") + }, + closingFragment: { + validate: (0, _utils.assertNodeType)("JSXClosingFragment") + }, + children: (0, _utils.validateArrayOfType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment") + } +}); +defineType("JSXOpeningFragment", { + aliases: ["Immutable"] +}); +defineType("JSXClosingFragment", { + aliases: ["Immutable"] +}); + +//# sourceMappingURL=jsx.js.map + +}, function(modId) { var map = {"./utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509042, function(require, module, exports) { + + +var _utils = require("./utils.js"); +var _placeholders = require("./placeholders.js"); +var _core = require("./core.js"); +const defineType = (0, _utils.defineAliasedType)("Miscellaneous"); +defineType("Noop", { + visitor: [] +}); +defineType("Placeholder", { + visitor: [], + builder: ["expectedNode", "name"], + fields: Object.assign({ + name: { + validate: (0, _utils.assertNodeType)("Identifier") + }, + expectedNode: { + validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS) + } + }, (0, _core.patternLikeCommon)()) +}); +defineType("V8IntrinsicIdentifier", { + builder: ["name"], + fields: { + name: { + validate: (0, _utils.assertValueType)("string") + } + } +}); + +//# sourceMappingURL=misc.js.map + +}, function(modId) { var map = {"./utils.js":1771034509039,"./placeholders.js":1771034509043,"./core.js":1771034509033}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509043, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0; +var _utils = require("./utils.js"); +const PLACEHOLDERS = exports.PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; +const PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS_ALIAS = { + Declaration: ["Statement"], + Pattern: ["PatternLike", "LVal"] +}; +for (const type of PLACEHOLDERS) { + const alias = _utils.ALIAS_KEYS[type]; + if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias; +} +const PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_FLIPPED_ALIAS = {}; +Object.keys(PLACEHOLDERS_ALIAS).forEach(type => { + PLACEHOLDERS_ALIAS[type].forEach(alias => { + if (!hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) { + PLACEHOLDERS_FLIPPED_ALIAS[alias] = []; + } + PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type); + }); +}); + +//# sourceMappingURL=placeholders.js.map + +}, function(modId) { var map = {"./utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509044, function(require, module, exports) { + + +var _utils = require("./utils.js"); +(0, _utils.default)("ArgumentPlaceholder", {}); +(0, _utils.default)("BindExpression", { + visitor: ["object", "callee"], + aliases: ["Expression"], + fields: !process.env.BABEL_TYPES_8_BREAKING ? { + object: { + validate: Object.assign(() => {}, { + oneOfNodeTypes: ["Expression"] + }) + }, + callee: { + validate: Object.assign(() => {}, { + oneOfNodeTypes: ["Expression"] + }) + } + } : { + object: { + validate: (0, _utils.assertNodeType)("Expression") + }, + callee: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +(0, _utils.default)("Decorator", { + visitor: ["expression"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression") + } + } +}); +(0, _utils.default)("DoExpression", { + visitor: ["body"], + builder: ["body", "async"], + aliases: ["Expression"], + fields: { + body: { + validate: (0, _utils.assertNodeType)("BlockStatement") + }, + async: { + validate: (0, _utils.assertValueType)("boolean"), + default: false + } + } +}); +(0, _utils.default)("ExportDefaultSpecifier", { + visitor: ["exported"], + aliases: ["ModuleSpecifier"], + fields: { + exported: { + validate: (0, _utils.assertNodeType)("Identifier") + } + } +}); +(0, _utils.default)("RecordExpression", { + visitor: ["properties"], + aliases: ["Expression"], + fields: { + properties: (0, _utils.validateArrayOfType)("ObjectProperty", "SpreadElement") + } +}); +(0, _utils.default)("TupleExpression", { + fields: { + elements: { + validate: (0, _utils.arrayOfType)("Expression", "SpreadElement"), + default: [] + } + }, + visitor: ["elements"], + aliases: ["Expression"] +}); +(0, _utils.default)("DecimalLiteral", { + builder: ["value"], + fields: { + value: { + validate: (0, _utils.assertValueType)("string") + } + }, + aliases: ["Expression", "Pureish", "Literal", "Immutable"] +}); +(0, _utils.default)("ModuleExpression", { + visitor: ["body"], + fields: { + body: { + validate: (0, _utils.assertNodeType)("Program") + } + }, + aliases: ["Expression"] +}); +(0, _utils.default)("TopicReference", { + aliases: ["Expression"] +}); +(0, _utils.default)("PipelineTopicExpression", { + builder: ["expression"], + visitor: ["expression"], + fields: { + expression: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + aliases: ["Expression"] +}); +(0, _utils.default)("PipelineBareFunction", { + builder: ["callee"], + visitor: ["callee"], + fields: { + callee: { + validate: (0, _utils.assertNodeType)("Expression") + } + }, + aliases: ["Expression"] +}); +(0, _utils.default)("PipelinePrimaryTopicReference", { + aliases: ["Expression"] +}); +(0, _utils.default)("VoidPattern", { + aliases: ["Pattern", "PatternLike", "FunctionParameter"] +}); + +//# sourceMappingURL=experimental.js.map + +}, function(modId) { var map = {"./utils.js":1771034509039}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509045, function(require, module, exports) { + + +var _utils = require("./utils.js"); +var _core = require("./core.js"); +var _is = require("../validators/is.js"); +const defineType = (0, _utils.defineAliasedType)("TypeScript"); +const bool = (0, _utils.assertValueType)("boolean"); +const tSFunctionTypeAnnotationCommon = () => ({ + returnType: { + validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"), + optional: true + }, + typeParameters: { + validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"), + optional: true + } +}); +defineType("TSParameterProperty", { + aliases: ["LVal"], + visitor: ["parameter"], + fields: { + accessibility: { + validate: (0, _utils.assertOneOf)("public", "private", "protected"), + optional: true + }, + readonly: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + parameter: { + validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern") + }, + override: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + decorators: { + validate: (0, _utils.arrayOfType)("Decorator"), + optional: true + } + } +}); +defineType("TSDeclareFunction", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "params", "returnType"], + fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon()) +}); +defineType("TSDeclareMethod", Object.assign({ + visitor: ["decorators", "key", "typeParameters", "params", "returnType"] +}, (0, _core.classMethodOrPropertyUnionShapeCommon)(), { + fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon()) +})); +defineType("TSQualifiedName", { + aliases: ["TSEntityName"], + visitor: ["left", "right"], + fields: { + left: (0, _utils.validateType)("TSEntityName"), + right: (0, _utils.validateType)("Identifier") + } +}); +const signatureDeclarationCommon = () => ({ + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + ["parameters"]: (0, _utils.validateArrayOfType)("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"), + ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation") +}); +const callConstructSignatureDeclaration = { + aliases: ["TSTypeElement"], + visitor: ["typeParameters", "parameters", "typeAnnotation"], + fields: signatureDeclarationCommon() +}; +defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration); +defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration); +const namedTypeElementCommon = () => ({ + key: (0, _utils.validateType)("Expression"), + computed: { + default: false + }, + optional: (0, _utils.validateOptional)(bool) +}); +defineType("TSPropertySignature", { + aliases: ["TSTypeElement"], + visitor: ["key", "typeAnnotation"], + fields: Object.assign({}, namedTypeElementCommon(), { + readonly: (0, _utils.validateOptional)(bool), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), + kind: { + optional: true, + validate: (0, _utils.assertOneOf)("get", "set") + } + }) +}); +defineType("TSMethodSignature", { + aliases: ["TSTypeElement"], + visitor: ["key", "typeParameters", "parameters", "typeAnnotation"], + fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), { + kind: { + validate: (0, _utils.assertOneOf)("method", "get", "set") + } + }) +}); +defineType("TSIndexSignature", { + aliases: ["TSTypeElement"], + visitor: ["parameters", "typeAnnotation"], + fields: { + readonly: (0, _utils.validateOptional)(bool), + static: (0, _utils.validateOptional)(bool), + parameters: (0, _utils.validateArrayOfType)("Identifier"), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") + } +}); +const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"]; +for (const type of tsKeywordTypes) { + defineType(type, { + aliases: ["TSType", "TSBaseType"], + visitor: [], + fields: {} + }); +} +defineType("TSThisType", { + aliases: ["TSType", "TSBaseType"], + visitor: [], + fields: {} +}); +const fnOrCtrBase = { + aliases: ["TSType"], + visitor: ["typeParameters", "parameters", "typeAnnotation"] +}; +defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, { + fields: signatureDeclarationCommon() +})); +defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, { + fields: Object.assign({}, signatureDeclarationCommon(), { + abstract: (0, _utils.validateOptional)(bool) + }) +})); +defineType("TSTypeReference", { + aliases: ["TSType"], + visitor: ["typeName", "typeParameters"], + fields: { + typeName: (0, _utils.validateType)("TSEntityName"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSTypePredicate", { + aliases: ["TSType"], + visitor: ["parameterName", "typeAnnotation"], + builder: ["parameterName", "typeAnnotation", "asserts"], + fields: { + parameterName: (0, _utils.validateType)("Identifier", "TSThisType"), + typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), + asserts: (0, _utils.validateOptional)(bool) + } +}); +defineType("TSTypeQuery", { + aliases: ["TSType"], + visitor: ["exprName", "typeParameters"], + fields: { + exprName: (0, _utils.validateType)("TSEntityName", "TSImportType"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSTypeLiteral", { + aliases: ["TSType"], + visitor: ["members"], + fields: { + members: (0, _utils.validateArrayOfType)("TSTypeElement") + } +}); +defineType("TSArrayType", { + aliases: ["TSType"], + visitor: ["elementType"], + fields: { + elementType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSTupleType", { + aliases: ["TSType"], + visitor: ["elementTypes"], + fields: { + elementTypes: (0, _utils.validateArrayOfType)("TSType", "TSNamedTupleMember") + } +}); +defineType("TSOptionalType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSRestType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSNamedTupleMember", { + visitor: ["label", "elementType"], + builder: ["label", "elementType", "optional"], + fields: { + label: (0, _utils.validateType)("Identifier"), + optional: { + validate: bool, + default: false + }, + elementType: (0, _utils.validateType)("TSType") + } +}); +const unionOrIntersection = { + aliases: ["TSType"], + visitor: ["types"], + fields: { + types: (0, _utils.validateArrayOfType)("TSType") + } +}; +defineType("TSUnionType", unionOrIntersection); +defineType("TSIntersectionType", unionOrIntersection); +defineType("TSConditionalType", { + aliases: ["TSType"], + visitor: ["checkType", "extendsType", "trueType", "falseType"], + fields: { + checkType: (0, _utils.validateType)("TSType"), + extendsType: (0, _utils.validateType)("TSType"), + trueType: (0, _utils.validateType)("TSType"), + falseType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSInferType", { + aliases: ["TSType"], + visitor: ["typeParameter"], + fields: { + typeParameter: (0, _utils.validateType)("TSTypeParameter") + } +}); +defineType("TSParenthesizedType", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSTypeOperator", { + aliases: ["TSType"], + visitor: ["typeAnnotation"], + builder: ["typeAnnotation", "operator"], + fields: { + operator: { + validate: (0, _utils.assertValueType)("string"), + default: "keyof" + }, + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSIndexedAccessType", { + aliases: ["TSType"], + visitor: ["objectType", "indexType"], + fields: { + objectType: (0, _utils.validateType)("TSType"), + indexType: (0, _utils.validateType)("TSType") + } +}); +defineType("TSMappedType", { + aliases: ["TSType"], + visitor: ["typeParameter", "nameType", "typeAnnotation"], + builder: ["typeParameter", "typeAnnotation", "nameType"], + fields: Object.assign({}, { + typeParameter: (0, _utils.validateType)("TSTypeParameter") + }, { + readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), + optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), + typeAnnotation: (0, _utils.validateOptionalType)("TSType"), + nameType: (0, _utils.validateOptionalType)("TSType") + }) +}); +defineType("TSTemplateLiteralType", { + aliases: ["TSType", "TSBaseType"], + visitor: ["quasis", "types"], + fields: { + quasis: (0, _utils.validateArrayOfType)("TemplateElement"), + types: { + validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")), function (node, key, val) { + if (node.quasis.length !== val.length + 1) { + throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of types.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); + } + }) + } + } +}); +defineType("TSLiteralType", { + aliases: ["TSType", "TSBaseType"], + visitor: ["literal"], + fields: { + literal: { + validate: function () { + const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"); + const unaryOperator = (0, _utils.assertOneOf)("-"); + const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral"); + const validator = function validator(parent, key, node) { + if ((0, _is.default)("UnaryExpression", node)) { + unaryOperator(node, "operator", node.operator); + unaryExpression(node, "argument", node.argument); + } else { + literal(parent, key, node); + } + }; + validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"]; + return validator; + }() + } + } +}); +defineType("TSExpressionWithTypeArguments", { + aliases: ["TSType"], + visitor: ["expression", "typeParameters"], + fields: { + expression: (0, _utils.validateType)("TSEntityName"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +defineType("TSInterfaceDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "extends", "body"], + fields: { + declare: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")), + body: (0, _utils.validateType)("TSInterfaceBody") + } +}); +defineType("TSInterfaceBody", { + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("TSTypeElement") + } +}); +defineType("TSTypeAliasDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "typeParameters", "typeAnnotation"], + fields: { + declare: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), + typeAnnotation: (0, _utils.validateType)("TSType") + } +}); +defineType("TSInstantiationExpression", { + aliases: ["Expression"], + visitor: ["expression", "typeParameters"], + fields: { + expression: (0, _utils.validateType)("Expression"), + ["typeParameters"]: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + } +}); +const TSTypeExpression = { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["expression", "typeAnnotation"], + fields: { + expression: (0, _utils.validateType)("Expression"), + typeAnnotation: (0, _utils.validateType)("TSType") + } +}; +defineType("TSAsExpression", TSTypeExpression); +defineType("TSSatisfiesExpression", TSTypeExpression); +defineType("TSTypeAssertion", { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["typeAnnotation", "expression"], + fields: { + typeAnnotation: (0, _utils.validateType)("TSType"), + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSEnumBody", { + visitor: ["members"], + fields: { + members: (0, _utils.validateArrayOfType)("TSEnumMember") + } +}); +defineType("TSEnumDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "members"], + fields: { + declare: (0, _utils.validateOptional)(bool), + const: (0, _utils.validateOptional)(bool), + id: (0, _utils.validateType)("Identifier"), + members: (0, _utils.validateArrayOfType)("TSEnumMember"), + initializer: (0, _utils.validateOptionalType)("Expression"), + body: (0, _utils.validateOptionalType)("TSEnumBody") + } +}); +defineType("TSEnumMember", { + visitor: ["id", "initializer"], + fields: { + id: (0, _utils.validateType)("Identifier", "StringLiteral"), + initializer: (0, _utils.validateOptionalType)("Expression") + } +}); +defineType("TSModuleDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "body"], + fields: Object.assign({ + kind: { + validate: (0, _utils.assertOneOf)("global", "module", "namespace") + }, + declare: (0, _utils.validateOptional)(bool) + }, { + global: (0, _utils.validateOptional)(bool) + }, { + id: (0, _utils.validateType)("Identifier", "StringLiteral"), + body: (0, _utils.validateType)("TSModuleBlock", "TSModuleDeclaration") + }) +}); +defineType("TSModuleBlock", { + aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"], + visitor: ["body"], + fields: { + body: (0, _utils.validateArrayOfType)("Statement") + } +}); +defineType("TSImportType", { + aliases: ["TSType"], + builder: ["argument", "qualifier", "typeParameters"], + visitor: ["argument", "options", "qualifier", "typeParameters"], + fields: Object.assign({}, { + argument: (0, _utils.validateType)("StringLiteral") + }, { + qualifier: (0, _utils.validateOptionalType)("TSEntityName") + }, { + typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") + }, { + options: { + validate: (0, _utils.assertNodeType)("ObjectExpression"), + optional: true + } + }) +}); +defineType("TSImportEqualsDeclaration", { + aliases: ["Statement", "Declaration"], + visitor: ["id", "moduleReference"], + fields: Object.assign({}, { + isExport: (0, _utils.validate)(bool) + }, { + id: (0, _utils.validateType)("Identifier"), + moduleReference: (0, _utils.validateType)("TSEntityName", "TSExternalModuleReference"), + importKind: { + validate: (0, _utils.assertOneOf)("type", "value"), + optional: true + } + }) +}); +defineType("TSExternalModuleReference", { + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("StringLiteral") + } +}); +defineType("TSNonNullExpression", { + aliases: ["Expression", "LVal", "PatternLike"], + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSExportAssignment", { + aliases: ["Statement"], + visitor: ["expression"], + fields: { + expression: (0, _utils.validateType)("Expression") + } +}); +defineType("TSNamespaceExportDeclaration", { + aliases: ["Statement"], + visitor: ["id"], + fields: { + id: (0, _utils.validateType)("Identifier") + } +}); +defineType("TSTypeAnnotation", { + visitor: ["typeAnnotation"], + fields: { + typeAnnotation: { + validate: (0, _utils.assertNodeType)("TSType") + } + } +}); +defineType("TSTypeParameterInstantiation", { + visitor: ["params"], + fields: { + params: (0, _utils.validateArrayOfType)("TSType") + } +}); +defineType("TSTypeParameterDeclaration", { + visitor: ["params"], + fields: { + params: (0, _utils.validateArrayOfType)("TSTypeParameter") + } +}); +defineType("TSTypeParameter", { + builder: ["constraint", "default", "name"], + visitor: ["constraint", "default"], + fields: { + name: { + validate: (0, _utils.assertValueType)("string") + }, + in: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + out: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + const: { + validate: (0, _utils.assertValueType)("boolean"), + optional: true + }, + constraint: { + validate: (0, _utils.assertNodeType)("TSType"), + optional: true + }, + default: { + validate: (0, _utils.assertNodeType)("TSType"), + optional: true + } + } +}); + +//# sourceMappingURL=typescript.js.map + +}, function(modId) { var map = {"./utils.js":1771034509039,"./core.js":1771034509033,"../validators/is.js":1771034509034}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509046, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.DEPRECATED_ALIASES = void 0; +const DEPRECATED_ALIASES = exports.DEPRECATED_ALIASES = { + ModuleDeclaration: "ImportOrExportDeclaration" +}; + +//# sourceMappingURL=deprecated-aliases.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509047, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.JSXIdentifier = exports.JSXFragment = exports.JSXExpressionContainer = exports.JSXEmptyExpression = exports.JSXElement = exports.JSXClosingFragment = exports.JSXClosingElement = exports.JSXAttribute = exports.IntersectionTypeAnnotation = exports.InterpreterDirective = exports.InterfaceTypeAnnotation = exports.InterfaceExtends = exports.InterfaceDeclaration = exports.InferredPredicate = exports.IndexedAccessType = exports.ImportSpecifier = exports.ImportNamespaceSpecifier = exports.ImportExpression = exports.ImportDefaultSpecifier = exports.ImportDeclaration = exports.ImportAttribute = exports.Import = exports.IfStatement = exports.Identifier = exports.GenericTypeAnnotation = exports.FunctionTypeParam = exports.FunctionTypeAnnotation = exports.FunctionExpression = exports.FunctionDeclaration = exports.ForStatement = exports.ForOfStatement = exports.ForInStatement = exports.File = exports.ExpressionStatement = exports.ExportSpecifier = exports.ExportNamespaceSpecifier = exports.ExportNamedDeclaration = exports.ExportDefaultSpecifier = exports.ExportDefaultDeclaration = exports.ExportAllDeclaration = exports.ExistsTypeAnnotation = exports.EnumSymbolBody = exports.EnumStringMember = exports.EnumStringBody = exports.EnumNumberMember = exports.EnumNumberBody = exports.EnumDefaultedMember = exports.EnumDeclaration = exports.EnumBooleanMember = exports.EnumBooleanBody = exports.EmptyTypeAnnotation = exports.EmptyStatement = exports.DoWhileStatement = exports.DoExpression = exports.DirectiveLiteral = exports.Directive = exports.Decorator = exports.DeclaredPredicate = exports.DeclareVariable = exports.DeclareTypeAlias = exports.DeclareOpaqueType = exports.DeclareModuleExports = exports.DeclareModule = exports.DeclareInterface = exports.DeclareFunction = exports.DeclareExportDeclaration = exports.DeclareExportAllDeclaration = exports.DeclareClass = exports.DecimalLiteral = exports.DebuggerStatement = exports.ContinueStatement = exports.ConditionalExpression = exports.ClassProperty = exports.ClassPrivateProperty = exports.ClassPrivateMethod = exports.ClassMethod = exports.ClassImplements = exports.ClassExpression = exports.ClassDeclaration = exports.ClassBody = exports.ClassAccessorProperty = exports.CatchClause = exports.CallExpression = exports.BreakStatement = exports.BooleanTypeAnnotation = exports.BooleanLiteralTypeAnnotation = exports.BooleanLiteral = exports.BlockStatement = exports.BindExpression = exports.BinaryExpression = exports.BigIntLiteral = exports.AwaitExpression = exports.AssignmentPattern = exports.AssignmentExpression = exports.ArrowFunctionExpression = exports.ArrayTypeAnnotation = exports.ArrayPattern = exports.ArrayExpression = exports.ArgumentPlaceholder = exports.AnyTypeAnnotation = void 0; +exports.TSNumberKeyword = exports.TSNullKeyword = exports.TSNonNullExpression = exports.TSNeverKeyword = exports.TSNamespaceExportDeclaration = exports.TSNamedTupleMember = exports.TSModuleDeclaration = exports.TSModuleBlock = exports.TSMethodSignature = exports.TSMappedType = exports.TSLiteralType = exports.TSIntrinsicKeyword = exports.TSIntersectionType = exports.TSInterfaceDeclaration = exports.TSInterfaceBody = exports.TSInstantiationExpression = exports.TSInferType = exports.TSIndexedAccessType = exports.TSIndexSignature = exports.TSImportType = exports.TSImportEqualsDeclaration = exports.TSFunctionType = exports.TSExternalModuleReference = exports.TSExpressionWithTypeArguments = exports.TSExportAssignment = exports.TSEnumMember = exports.TSEnumDeclaration = exports.TSEnumBody = exports.TSDeclareMethod = exports.TSDeclareFunction = exports.TSConstructorType = exports.TSConstructSignatureDeclaration = exports.TSConditionalType = exports.TSCallSignatureDeclaration = exports.TSBooleanKeyword = exports.TSBigIntKeyword = exports.TSAsExpression = exports.TSArrayType = exports.TSAnyKeyword = exports.SymbolTypeAnnotation = exports.SwitchStatement = exports.SwitchCase = exports.Super = exports.StringTypeAnnotation = exports.StringLiteralTypeAnnotation = exports.StringLiteral = exports.StaticBlock = exports.SpreadProperty = exports.SpreadElement = exports.SequenceExpression = exports.ReturnStatement = exports.RestProperty = exports.RestElement = exports.RegexLiteral = exports.RegExpLiteral = exports.RecordExpression = exports.QualifiedTypeIdentifier = exports.Program = exports.PrivateName = exports.Placeholder = exports.PipelineTopicExpression = exports.PipelinePrimaryTopicReference = exports.PipelineBareFunction = exports.ParenthesizedExpression = exports.OptionalMemberExpression = exports.OptionalIndexedAccessType = exports.OptionalCallExpression = exports.OpaqueType = exports.ObjectTypeSpreadProperty = exports.ObjectTypeProperty = exports.ObjectTypeInternalSlot = exports.ObjectTypeIndexer = exports.ObjectTypeCallProperty = exports.ObjectTypeAnnotation = exports.ObjectProperty = exports.ObjectPattern = exports.ObjectMethod = exports.ObjectExpression = exports.NumericLiteral = exports.NumberTypeAnnotation = exports.NumberLiteralTypeAnnotation = exports.NumberLiteral = exports.NullableTypeAnnotation = exports.NullLiteralTypeAnnotation = exports.NullLiteral = exports.Noop = exports.NewExpression = exports.ModuleExpression = exports.MixedTypeAnnotation = exports.MetaProperty = exports.MemberExpression = exports.LogicalExpression = exports.LabeledStatement = exports.JSXText = exports.JSXSpreadChild = exports.JSXSpreadAttribute = exports.JSXOpeningFragment = exports.JSXOpeningElement = exports.JSXNamespacedName = exports.JSXMemberExpression = void 0; +exports.YieldExpression = exports.WithStatement = exports.WhileStatement = exports.VoidTypeAnnotation = exports.VoidPattern = exports.Variance = exports.VariableDeclarator = exports.VariableDeclaration = exports.V8IntrinsicIdentifier = exports.UpdateExpression = exports.UnionTypeAnnotation = exports.UnaryExpression = exports.TypeofTypeAnnotation = exports.TypeParameterInstantiation = exports.TypeParameterDeclaration = exports.TypeParameter = exports.TypeCastExpression = exports.TypeAnnotation = exports.TypeAlias = exports.TupleTypeAnnotation = exports.TupleExpression = exports.TryStatement = exports.TopicReference = exports.ThrowStatement = exports.ThisTypeAnnotation = exports.ThisExpression = exports.TemplateLiteral = exports.TemplateElement = exports.TaggedTemplateExpression = exports.TSVoidKeyword = exports.TSUnknownKeyword = exports.TSUnionType = exports.TSUndefinedKeyword = exports.TSTypeReference = exports.TSTypeQuery = exports.TSTypePredicate = exports.TSTypeParameterInstantiation = exports.TSTypeParameterDeclaration = exports.TSTypeParameter = exports.TSTypeOperator = exports.TSTypeLiteral = exports.TSTypeAssertion = exports.TSTypeAnnotation = exports.TSTypeAliasDeclaration = exports.TSTupleType = exports.TSThisType = exports.TSTemplateLiteralType = exports.TSSymbolKeyword = exports.TSStringKeyword = exports.TSSatisfiesExpression = exports.TSRestType = exports.TSQualifiedName = exports.TSPropertySignature = exports.TSParenthesizedType = exports.TSParameterProperty = exports.TSOptionalType = exports.TSObjectKeyword = void 0; +var b = require("./lowercase.js"); +var _deprecationWarning = require("../../utils/deprecationWarning.js"); +function alias(lowercase) { + return b[lowercase]; +} +const ArrayExpression = exports.ArrayExpression = alias("arrayExpression"), + AssignmentExpression = exports.AssignmentExpression = alias("assignmentExpression"), + BinaryExpression = exports.BinaryExpression = alias("binaryExpression"), + InterpreterDirective = exports.InterpreterDirective = alias("interpreterDirective"), + Directive = exports.Directive = alias("directive"), + DirectiveLiteral = exports.DirectiveLiteral = alias("directiveLiteral"), + BlockStatement = exports.BlockStatement = alias("blockStatement"), + BreakStatement = exports.BreakStatement = alias("breakStatement"), + CallExpression = exports.CallExpression = alias("callExpression"), + CatchClause = exports.CatchClause = alias("catchClause"), + ConditionalExpression = exports.ConditionalExpression = alias("conditionalExpression"), + ContinueStatement = exports.ContinueStatement = alias("continueStatement"), + DebuggerStatement = exports.DebuggerStatement = alias("debuggerStatement"), + DoWhileStatement = exports.DoWhileStatement = alias("doWhileStatement"), + EmptyStatement = exports.EmptyStatement = alias("emptyStatement"), + ExpressionStatement = exports.ExpressionStatement = alias("expressionStatement"), + File = exports.File = alias("file"), + ForInStatement = exports.ForInStatement = alias("forInStatement"), + ForStatement = exports.ForStatement = alias("forStatement"), + FunctionDeclaration = exports.FunctionDeclaration = alias("functionDeclaration"), + FunctionExpression = exports.FunctionExpression = alias("functionExpression"), + Identifier = exports.Identifier = alias("identifier"), + IfStatement = exports.IfStatement = alias("ifStatement"), + LabeledStatement = exports.LabeledStatement = alias("labeledStatement"), + StringLiteral = exports.StringLiteral = alias("stringLiteral"), + NumericLiteral = exports.NumericLiteral = alias("numericLiteral"), + NullLiteral = exports.NullLiteral = alias("nullLiteral"), + BooleanLiteral = exports.BooleanLiteral = alias("booleanLiteral"), + RegExpLiteral = exports.RegExpLiteral = alias("regExpLiteral"), + LogicalExpression = exports.LogicalExpression = alias("logicalExpression"), + MemberExpression = exports.MemberExpression = alias("memberExpression"), + NewExpression = exports.NewExpression = alias("newExpression"), + Program = exports.Program = alias("program"), + ObjectExpression = exports.ObjectExpression = alias("objectExpression"), + ObjectMethod = exports.ObjectMethod = alias("objectMethod"), + ObjectProperty = exports.ObjectProperty = alias("objectProperty"), + RestElement = exports.RestElement = alias("restElement"), + ReturnStatement = exports.ReturnStatement = alias("returnStatement"), + SequenceExpression = exports.SequenceExpression = alias("sequenceExpression"), + ParenthesizedExpression = exports.ParenthesizedExpression = alias("parenthesizedExpression"), + SwitchCase = exports.SwitchCase = alias("switchCase"), + SwitchStatement = exports.SwitchStatement = alias("switchStatement"), + ThisExpression = exports.ThisExpression = alias("thisExpression"), + ThrowStatement = exports.ThrowStatement = alias("throwStatement"), + TryStatement = exports.TryStatement = alias("tryStatement"), + UnaryExpression = exports.UnaryExpression = alias("unaryExpression"), + UpdateExpression = exports.UpdateExpression = alias("updateExpression"), + VariableDeclaration = exports.VariableDeclaration = alias("variableDeclaration"), + VariableDeclarator = exports.VariableDeclarator = alias("variableDeclarator"), + WhileStatement = exports.WhileStatement = alias("whileStatement"), + WithStatement = exports.WithStatement = alias("withStatement"), + AssignmentPattern = exports.AssignmentPattern = alias("assignmentPattern"), + ArrayPattern = exports.ArrayPattern = alias("arrayPattern"), + ArrowFunctionExpression = exports.ArrowFunctionExpression = alias("arrowFunctionExpression"), + ClassBody = exports.ClassBody = alias("classBody"), + ClassExpression = exports.ClassExpression = alias("classExpression"), + ClassDeclaration = exports.ClassDeclaration = alias("classDeclaration"), + ExportAllDeclaration = exports.ExportAllDeclaration = alias("exportAllDeclaration"), + ExportDefaultDeclaration = exports.ExportDefaultDeclaration = alias("exportDefaultDeclaration"), + ExportNamedDeclaration = exports.ExportNamedDeclaration = alias("exportNamedDeclaration"), + ExportSpecifier = exports.ExportSpecifier = alias("exportSpecifier"), + ForOfStatement = exports.ForOfStatement = alias("forOfStatement"), + ImportDeclaration = exports.ImportDeclaration = alias("importDeclaration"), + ImportDefaultSpecifier = exports.ImportDefaultSpecifier = alias("importDefaultSpecifier"), + ImportNamespaceSpecifier = exports.ImportNamespaceSpecifier = alias("importNamespaceSpecifier"), + ImportSpecifier = exports.ImportSpecifier = alias("importSpecifier"), + ImportExpression = exports.ImportExpression = alias("importExpression"), + MetaProperty = exports.MetaProperty = alias("metaProperty"), + ClassMethod = exports.ClassMethod = alias("classMethod"), + ObjectPattern = exports.ObjectPattern = alias("objectPattern"), + SpreadElement = exports.SpreadElement = alias("spreadElement"), + Super = exports.Super = alias("super"), + TaggedTemplateExpression = exports.TaggedTemplateExpression = alias("taggedTemplateExpression"), + TemplateElement = exports.TemplateElement = alias("templateElement"), + TemplateLiteral = exports.TemplateLiteral = alias("templateLiteral"), + YieldExpression = exports.YieldExpression = alias("yieldExpression"), + AwaitExpression = exports.AwaitExpression = alias("awaitExpression"), + Import = exports.Import = alias("import"), + BigIntLiteral = exports.BigIntLiteral = alias("bigIntLiteral"), + ExportNamespaceSpecifier = exports.ExportNamespaceSpecifier = alias("exportNamespaceSpecifier"), + OptionalMemberExpression = exports.OptionalMemberExpression = alias("optionalMemberExpression"), + OptionalCallExpression = exports.OptionalCallExpression = alias("optionalCallExpression"), + ClassProperty = exports.ClassProperty = alias("classProperty"), + ClassAccessorProperty = exports.ClassAccessorProperty = alias("classAccessorProperty"), + ClassPrivateProperty = exports.ClassPrivateProperty = alias("classPrivateProperty"), + ClassPrivateMethod = exports.ClassPrivateMethod = alias("classPrivateMethod"), + PrivateName = exports.PrivateName = alias("privateName"), + StaticBlock = exports.StaticBlock = alias("staticBlock"), + ImportAttribute = exports.ImportAttribute = alias("importAttribute"), + AnyTypeAnnotation = exports.AnyTypeAnnotation = alias("anyTypeAnnotation"), + ArrayTypeAnnotation = exports.ArrayTypeAnnotation = alias("arrayTypeAnnotation"), + BooleanTypeAnnotation = exports.BooleanTypeAnnotation = alias("booleanTypeAnnotation"), + BooleanLiteralTypeAnnotation = exports.BooleanLiteralTypeAnnotation = alias("booleanLiteralTypeAnnotation"), + NullLiteralTypeAnnotation = exports.NullLiteralTypeAnnotation = alias("nullLiteralTypeAnnotation"), + ClassImplements = exports.ClassImplements = alias("classImplements"), + DeclareClass = exports.DeclareClass = alias("declareClass"), + DeclareFunction = exports.DeclareFunction = alias("declareFunction"), + DeclareInterface = exports.DeclareInterface = alias("declareInterface"), + DeclareModule = exports.DeclareModule = alias("declareModule"), + DeclareModuleExports = exports.DeclareModuleExports = alias("declareModuleExports"), + DeclareTypeAlias = exports.DeclareTypeAlias = alias("declareTypeAlias"), + DeclareOpaqueType = exports.DeclareOpaqueType = alias("declareOpaqueType"), + DeclareVariable = exports.DeclareVariable = alias("declareVariable"), + DeclareExportDeclaration = exports.DeclareExportDeclaration = alias("declareExportDeclaration"), + DeclareExportAllDeclaration = exports.DeclareExportAllDeclaration = alias("declareExportAllDeclaration"), + DeclaredPredicate = exports.DeclaredPredicate = alias("declaredPredicate"), + ExistsTypeAnnotation = exports.ExistsTypeAnnotation = alias("existsTypeAnnotation"), + FunctionTypeAnnotation = exports.FunctionTypeAnnotation = alias("functionTypeAnnotation"), + FunctionTypeParam = exports.FunctionTypeParam = alias("functionTypeParam"), + GenericTypeAnnotation = exports.GenericTypeAnnotation = alias("genericTypeAnnotation"), + InferredPredicate = exports.InferredPredicate = alias("inferredPredicate"), + InterfaceExtends = exports.InterfaceExtends = alias("interfaceExtends"), + InterfaceDeclaration = exports.InterfaceDeclaration = alias("interfaceDeclaration"), + InterfaceTypeAnnotation = exports.InterfaceTypeAnnotation = alias("interfaceTypeAnnotation"), + IntersectionTypeAnnotation = exports.IntersectionTypeAnnotation = alias("intersectionTypeAnnotation"), + MixedTypeAnnotation = exports.MixedTypeAnnotation = alias("mixedTypeAnnotation"), + EmptyTypeAnnotation = exports.EmptyTypeAnnotation = alias("emptyTypeAnnotation"), + NullableTypeAnnotation = exports.NullableTypeAnnotation = alias("nullableTypeAnnotation"), + NumberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = alias("numberLiteralTypeAnnotation"), + NumberTypeAnnotation = exports.NumberTypeAnnotation = alias("numberTypeAnnotation"), + ObjectTypeAnnotation = exports.ObjectTypeAnnotation = alias("objectTypeAnnotation"), + ObjectTypeInternalSlot = exports.ObjectTypeInternalSlot = alias("objectTypeInternalSlot"), + ObjectTypeCallProperty = exports.ObjectTypeCallProperty = alias("objectTypeCallProperty"), + ObjectTypeIndexer = exports.ObjectTypeIndexer = alias("objectTypeIndexer"), + ObjectTypeProperty = exports.ObjectTypeProperty = alias("objectTypeProperty"), + ObjectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = alias("objectTypeSpreadProperty"), + OpaqueType = exports.OpaqueType = alias("opaqueType"), + QualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = alias("qualifiedTypeIdentifier"), + StringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = alias("stringLiteralTypeAnnotation"), + StringTypeAnnotation = exports.StringTypeAnnotation = alias("stringTypeAnnotation"), + SymbolTypeAnnotation = exports.SymbolTypeAnnotation = alias("symbolTypeAnnotation"), + ThisTypeAnnotation = exports.ThisTypeAnnotation = alias("thisTypeAnnotation"), + TupleTypeAnnotation = exports.TupleTypeAnnotation = alias("tupleTypeAnnotation"), + TypeofTypeAnnotation = exports.TypeofTypeAnnotation = alias("typeofTypeAnnotation"), + TypeAlias = exports.TypeAlias = alias("typeAlias"), + TypeAnnotation = exports.TypeAnnotation = alias("typeAnnotation"), + TypeCastExpression = exports.TypeCastExpression = alias("typeCastExpression"), + TypeParameter = exports.TypeParameter = alias("typeParameter"), + TypeParameterDeclaration = exports.TypeParameterDeclaration = alias("typeParameterDeclaration"), + TypeParameterInstantiation = exports.TypeParameterInstantiation = alias("typeParameterInstantiation"), + UnionTypeAnnotation = exports.UnionTypeAnnotation = alias("unionTypeAnnotation"), + Variance = exports.Variance = alias("variance"), + VoidTypeAnnotation = exports.VoidTypeAnnotation = alias("voidTypeAnnotation"), + EnumDeclaration = exports.EnumDeclaration = alias("enumDeclaration"), + EnumBooleanBody = exports.EnumBooleanBody = alias("enumBooleanBody"), + EnumNumberBody = exports.EnumNumberBody = alias("enumNumberBody"), + EnumStringBody = exports.EnumStringBody = alias("enumStringBody"), + EnumSymbolBody = exports.EnumSymbolBody = alias("enumSymbolBody"), + EnumBooleanMember = exports.EnumBooleanMember = alias("enumBooleanMember"), + EnumNumberMember = exports.EnumNumberMember = alias("enumNumberMember"), + EnumStringMember = exports.EnumStringMember = alias("enumStringMember"), + EnumDefaultedMember = exports.EnumDefaultedMember = alias("enumDefaultedMember"), + IndexedAccessType = exports.IndexedAccessType = alias("indexedAccessType"), + OptionalIndexedAccessType = exports.OptionalIndexedAccessType = alias("optionalIndexedAccessType"), + JSXAttribute = exports.JSXAttribute = alias("jsxAttribute"), + JSXClosingElement = exports.JSXClosingElement = alias("jsxClosingElement"), + JSXElement = exports.JSXElement = alias("jsxElement"), + JSXEmptyExpression = exports.JSXEmptyExpression = alias("jsxEmptyExpression"), + JSXExpressionContainer = exports.JSXExpressionContainer = alias("jsxExpressionContainer"), + JSXSpreadChild = exports.JSXSpreadChild = alias("jsxSpreadChild"), + JSXIdentifier = exports.JSXIdentifier = alias("jsxIdentifier"), + JSXMemberExpression = exports.JSXMemberExpression = alias("jsxMemberExpression"), + JSXNamespacedName = exports.JSXNamespacedName = alias("jsxNamespacedName"), + JSXOpeningElement = exports.JSXOpeningElement = alias("jsxOpeningElement"), + JSXSpreadAttribute = exports.JSXSpreadAttribute = alias("jsxSpreadAttribute"), + JSXText = exports.JSXText = alias("jsxText"), + JSXFragment = exports.JSXFragment = alias("jsxFragment"), + JSXOpeningFragment = exports.JSXOpeningFragment = alias("jsxOpeningFragment"), + JSXClosingFragment = exports.JSXClosingFragment = alias("jsxClosingFragment"), + Noop = exports.Noop = alias("noop"), + Placeholder = exports.Placeholder = alias("placeholder"), + V8IntrinsicIdentifier = exports.V8IntrinsicIdentifier = alias("v8IntrinsicIdentifier"), + ArgumentPlaceholder = exports.ArgumentPlaceholder = alias("argumentPlaceholder"), + BindExpression = exports.BindExpression = alias("bindExpression"), + Decorator = exports.Decorator = alias("decorator"), + DoExpression = exports.DoExpression = alias("doExpression"), + ExportDefaultSpecifier = exports.ExportDefaultSpecifier = alias("exportDefaultSpecifier"), + RecordExpression = exports.RecordExpression = alias("recordExpression"), + TupleExpression = exports.TupleExpression = alias("tupleExpression"), + DecimalLiteral = exports.DecimalLiteral = alias("decimalLiteral"), + ModuleExpression = exports.ModuleExpression = alias("moduleExpression"), + TopicReference = exports.TopicReference = alias("topicReference"), + PipelineTopicExpression = exports.PipelineTopicExpression = alias("pipelineTopicExpression"), + PipelineBareFunction = exports.PipelineBareFunction = alias("pipelineBareFunction"), + PipelinePrimaryTopicReference = exports.PipelinePrimaryTopicReference = alias("pipelinePrimaryTopicReference"), + VoidPattern = exports.VoidPattern = alias("voidPattern"), + TSParameterProperty = exports.TSParameterProperty = alias("tsParameterProperty"), + TSDeclareFunction = exports.TSDeclareFunction = alias("tsDeclareFunction"), + TSDeclareMethod = exports.TSDeclareMethod = alias("tsDeclareMethod"), + TSQualifiedName = exports.TSQualifiedName = alias("tsQualifiedName"), + TSCallSignatureDeclaration = exports.TSCallSignatureDeclaration = alias("tsCallSignatureDeclaration"), + TSConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = alias("tsConstructSignatureDeclaration"), + TSPropertySignature = exports.TSPropertySignature = alias("tsPropertySignature"), + TSMethodSignature = exports.TSMethodSignature = alias("tsMethodSignature"), + TSIndexSignature = exports.TSIndexSignature = alias("tsIndexSignature"), + TSAnyKeyword = exports.TSAnyKeyword = alias("tsAnyKeyword"), + TSBooleanKeyword = exports.TSBooleanKeyword = alias("tsBooleanKeyword"), + TSBigIntKeyword = exports.TSBigIntKeyword = alias("tsBigIntKeyword"), + TSIntrinsicKeyword = exports.TSIntrinsicKeyword = alias("tsIntrinsicKeyword"), + TSNeverKeyword = exports.TSNeverKeyword = alias("tsNeverKeyword"), + TSNullKeyword = exports.TSNullKeyword = alias("tsNullKeyword"), + TSNumberKeyword = exports.TSNumberKeyword = alias("tsNumberKeyword"), + TSObjectKeyword = exports.TSObjectKeyword = alias("tsObjectKeyword"), + TSStringKeyword = exports.TSStringKeyword = alias("tsStringKeyword"), + TSSymbolKeyword = exports.TSSymbolKeyword = alias("tsSymbolKeyword"), + TSUndefinedKeyword = exports.TSUndefinedKeyword = alias("tsUndefinedKeyword"), + TSUnknownKeyword = exports.TSUnknownKeyword = alias("tsUnknownKeyword"), + TSVoidKeyword = exports.TSVoidKeyword = alias("tsVoidKeyword"), + TSThisType = exports.TSThisType = alias("tsThisType"), + TSFunctionType = exports.TSFunctionType = alias("tsFunctionType"), + TSConstructorType = exports.TSConstructorType = alias("tsConstructorType"), + TSTypeReference = exports.TSTypeReference = alias("tsTypeReference"), + TSTypePredicate = exports.TSTypePredicate = alias("tsTypePredicate"), + TSTypeQuery = exports.TSTypeQuery = alias("tsTypeQuery"), + TSTypeLiteral = exports.TSTypeLiteral = alias("tsTypeLiteral"), + TSArrayType = exports.TSArrayType = alias("tsArrayType"), + TSTupleType = exports.TSTupleType = alias("tsTupleType"), + TSOptionalType = exports.TSOptionalType = alias("tsOptionalType"), + TSRestType = exports.TSRestType = alias("tsRestType"), + TSNamedTupleMember = exports.TSNamedTupleMember = alias("tsNamedTupleMember"), + TSUnionType = exports.TSUnionType = alias("tsUnionType"), + TSIntersectionType = exports.TSIntersectionType = alias("tsIntersectionType"), + TSConditionalType = exports.TSConditionalType = alias("tsConditionalType"), + TSInferType = exports.TSInferType = alias("tsInferType"), + TSParenthesizedType = exports.TSParenthesizedType = alias("tsParenthesizedType"), + TSTypeOperator = exports.TSTypeOperator = alias("tsTypeOperator"), + TSIndexedAccessType = exports.TSIndexedAccessType = alias("tsIndexedAccessType"), + TSMappedType = exports.TSMappedType = alias("tsMappedType"), + TSTemplateLiteralType = exports.TSTemplateLiteralType = alias("tsTemplateLiteralType"), + TSLiteralType = exports.TSLiteralType = alias("tsLiteralType"), + TSExpressionWithTypeArguments = exports.TSExpressionWithTypeArguments = alias("tsExpressionWithTypeArguments"), + TSInterfaceDeclaration = exports.TSInterfaceDeclaration = alias("tsInterfaceDeclaration"), + TSInterfaceBody = exports.TSInterfaceBody = alias("tsInterfaceBody"), + TSTypeAliasDeclaration = exports.TSTypeAliasDeclaration = alias("tsTypeAliasDeclaration"), + TSInstantiationExpression = exports.TSInstantiationExpression = alias("tsInstantiationExpression"), + TSAsExpression = exports.TSAsExpression = alias("tsAsExpression"), + TSSatisfiesExpression = exports.TSSatisfiesExpression = alias("tsSatisfiesExpression"), + TSTypeAssertion = exports.TSTypeAssertion = alias("tsTypeAssertion"), + TSEnumBody = exports.TSEnumBody = alias("tsEnumBody"), + TSEnumDeclaration = exports.TSEnumDeclaration = alias("tsEnumDeclaration"), + TSEnumMember = exports.TSEnumMember = alias("tsEnumMember"), + TSModuleDeclaration = exports.TSModuleDeclaration = alias("tsModuleDeclaration"), + TSModuleBlock = exports.TSModuleBlock = alias("tsModuleBlock"), + TSImportType = exports.TSImportType = alias("tsImportType"), + TSImportEqualsDeclaration = exports.TSImportEqualsDeclaration = alias("tsImportEqualsDeclaration"), + TSExternalModuleReference = exports.TSExternalModuleReference = alias("tsExternalModuleReference"), + TSNonNullExpression = exports.TSNonNullExpression = alias("tsNonNullExpression"), + TSExportAssignment = exports.TSExportAssignment = alias("tsExportAssignment"), + TSNamespaceExportDeclaration = exports.TSNamespaceExportDeclaration = alias("tsNamespaceExportDeclaration"), + TSTypeAnnotation = exports.TSTypeAnnotation = alias("tsTypeAnnotation"), + TSTypeParameterInstantiation = exports.TSTypeParameterInstantiation = alias("tsTypeParameterInstantiation"), + TSTypeParameterDeclaration = exports.TSTypeParameterDeclaration = alias("tsTypeParameterDeclaration"), + TSTypeParameter = exports.TSTypeParameter = alias("tsTypeParameter"); +const NumberLiteral = exports.NumberLiteral = b.numberLiteral, + RegexLiteral = exports.RegexLiteral = b.regexLiteral, + RestProperty = exports.RestProperty = b.restProperty, + SpreadProperty = exports.SpreadProperty = b.spreadProperty; + +//# sourceMappingURL=uppercase.js.map + +}, function(modId) { var map = {"./lowercase.js":1771034509030,"../../utils/deprecationWarning.js":1771034509025}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509048, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = assertNode; +var _isNode = require("../validators/isNode.js"); +function assertNode(node) { + if (!(0, _isNode.default)(node)) { + var _node$type; + const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node); + throw new TypeError(`Not a valid node of type "${type}"`); + } +} + +//# sourceMappingURL=assertNode.js.map + +}, function(modId) { var map = {"../validators/isNode.js":1771034509049}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509049, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isNode; +var _index = require("../definitions/index.js"); +function isNode(node) { + return !!(node && _index.VISITOR_KEYS[node.type]); +} + +//# sourceMappingURL=isNode.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509050, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.assertAccessor = assertAccessor; +exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; +exports.assertArgumentPlaceholder = assertArgumentPlaceholder; +exports.assertArrayExpression = assertArrayExpression; +exports.assertArrayPattern = assertArrayPattern; +exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; +exports.assertArrowFunctionExpression = assertArrowFunctionExpression; +exports.assertAssignmentExpression = assertAssignmentExpression; +exports.assertAssignmentPattern = assertAssignmentPattern; +exports.assertAwaitExpression = assertAwaitExpression; +exports.assertBigIntLiteral = assertBigIntLiteral; +exports.assertBinary = assertBinary; +exports.assertBinaryExpression = assertBinaryExpression; +exports.assertBindExpression = assertBindExpression; +exports.assertBlock = assertBlock; +exports.assertBlockParent = assertBlockParent; +exports.assertBlockStatement = assertBlockStatement; +exports.assertBooleanLiteral = assertBooleanLiteral; +exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; +exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; +exports.assertBreakStatement = assertBreakStatement; +exports.assertCallExpression = assertCallExpression; +exports.assertCatchClause = assertCatchClause; +exports.assertClass = assertClass; +exports.assertClassAccessorProperty = assertClassAccessorProperty; +exports.assertClassBody = assertClassBody; +exports.assertClassDeclaration = assertClassDeclaration; +exports.assertClassExpression = assertClassExpression; +exports.assertClassImplements = assertClassImplements; +exports.assertClassMethod = assertClassMethod; +exports.assertClassPrivateMethod = assertClassPrivateMethod; +exports.assertClassPrivateProperty = assertClassPrivateProperty; +exports.assertClassProperty = assertClassProperty; +exports.assertCompletionStatement = assertCompletionStatement; +exports.assertConditional = assertConditional; +exports.assertConditionalExpression = assertConditionalExpression; +exports.assertContinueStatement = assertContinueStatement; +exports.assertDebuggerStatement = assertDebuggerStatement; +exports.assertDecimalLiteral = assertDecimalLiteral; +exports.assertDeclaration = assertDeclaration; +exports.assertDeclareClass = assertDeclareClass; +exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; +exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; +exports.assertDeclareFunction = assertDeclareFunction; +exports.assertDeclareInterface = assertDeclareInterface; +exports.assertDeclareModule = assertDeclareModule; +exports.assertDeclareModuleExports = assertDeclareModuleExports; +exports.assertDeclareOpaqueType = assertDeclareOpaqueType; +exports.assertDeclareTypeAlias = assertDeclareTypeAlias; +exports.assertDeclareVariable = assertDeclareVariable; +exports.assertDeclaredPredicate = assertDeclaredPredicate; +exports.assertDecorator = assertDecorator; +exports.assertDirective = assertDirective; +exports.assertDirectiveLiteral = assertDirectiveLiteral; +exports.assertDoExpression = assertDoExpression; +exports.assertDoWhileStatement = assertDoWhileStatement; +exports.assertEmptyStatement = assertEmptyStatement; +exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; +exports.assertEnumBody = assertEnumBody; +exports.assertEnumBooleanBody = assertEnumBooleanBody; +exports.assertEnumBooleanMember = assertEnumBooleanMember; +exports.assertEnumDeclaration = assertEnumDeclaration; +exports.assertEnumDefaultedMember = assertEnumDefaultedMember; +exports.assertEnumMember = assertEnumMember; +exports.assertEnumNumberBody = assertEnumNumberBody; +exports.assertEnumNumberMember = assertEnumNumberMember; +exports.assertEnumStringBody = assertEnumStringBody; +exports.assertEnumStringMember = assertEnumStringMember; +exports.assertEnumSymbolBody = assertEnumSymbolBody; +exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; +exports.assertExportAllDeclaration = assertExportAllDeclaration; +exports.assertExportDeclaration = assertExportDeclaration; +exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; +exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; +exports.assertExportNamedDeclaration = assertExportNamedDeclaration; +exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; +exports.assertExportSpecifier = assertExportSpecifier; +exports.assertExpression = assertExpression; +exports.assertExpressionStatement = assertExpressionStatement; +exports.assertExpressionWrapper = assertExpressionWrapper; +exports.assertFile = assertFile; +exports.assertFlow = assertFlow; +exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; +exports.assertFlowDeclaration = assertFlowDeclaration; +exports.assertFlowPredicate = assertFlowPredicate; +exports.assertFlowType = assertFlowType; +exports.assertFor = assertFor; +exports.assertForInStatement = assertForInStatement; +exports.assertForOfStatement = assertForOfStatement; +exports.assertForStatement = assertForStatement; +exports.assertForXStatement = assertForXStatement; +exports.assertFunction = assertFunction; +exports.assertFunctionDeclaration = assertFunctionDeclaration; +exports.assertFunctionExpression = assertFunctionExpression; +exports.assertFunctionParameter = assertFunctionParameter; +exports.assertFunctionParent = assertFunctionParent; +exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; +exports.assertFunctionTypeParam = assertFunctionTypeParam; +exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; +exports.assertIdentifier = assertIdentifier; +exports.assertIfStatement = assertIfStatement; +exports.assertImmutable = assertImmutable; +exports.assertImport = assertImport; +exports.assertImportAttribute = assertImportAttribute; +exports.assertImportDeclaration = assertImportDeclaration; +exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; +exports.assertImportExpression = assertImportExpression; +exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; +exports.assertImportOrExportDeclaration = assertImportOrExportDeclaration; +exports.assertImportSpecifier = assertImportSpecifier; +exports.assertIndexedAccessType = assertIndexedAccessType; +exports.assertInferredPredicate = assertInferredPredicate; +exports.assertInterfaceDeclaration = assertInterfaceDeclaration; +exports.assertInterfaceExtends = assertInterfaceExtends; +exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; +exports.assertInterpreterDirective = assertInterpreterDirective; +exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; +exports.assertJSX = assertJSX; +exports.assertJSXAttribute = assertJSXAttribute; +exports.assertJSXClosingElement = assertJSXClosingElement; +exports.assertJSXClosingFragment = assertJSXClosingFragment; +exports.assertJSXElement = assertJSXElement; +exports.assertJSXEmptyExpression = assertJSXEmptyExpression; +exports.assertJSXExpressionContainer = assertJSXExpressionContainer; +exports.assertJSXFragment = assertJSXFragment; +exports.assertJSXIdentifier = assertJSXIdentifier; +exports.assertJSXMemberExpression = assertJSXMemberExpression; +exports.assertJSXNamespacedName = assertJSXNamespacedName; +exports.assertJSXOpeningElement = assertJSXOpeningElement; +exports.assertJSXOpeningFragment = assertJSXOpeningFragment; +exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; +exports.assertJSXSpreadChild = assertJSXSpreadChild; +exports.assertJSXText = assertJSXText; +exports.assertLVal = assertLVal; +exports.assertLabeledStatement = assertLabeledStatement; +exports.assertLiteral = assertLiteral; +exports.assertLogicalExpression = assertLogicalExpression; +exports.assertLoop = assertLoop; +exports.assertMemberExpression = assertMemberExpression; +exports.assertMetaProperty = assertMetaProperty; +exports.assertMethod = assertMethod; +exports.assertMiscellaneous = assertMiscellaneous; +exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; +exports.assertModuleDeclaration = assertModuleDeclaration; +exports.assertModuleExpression = assertModuleExpression; +exports.assertModuleSpecifier = assertModuleSpecifier; +exports.assertNewExpression = assertNewExpression; +exports.assertNoop = assertNoop; +exports.assertNullLiteral = assertNullLiteral; +exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; +exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; +exports.assertNumberLiteral = assertNumberLiteral; +exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; +exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; +exports.assertNumericLiteral = assertNumericLiteral; +exports.assertObjectExpression = assertObjectExpression; +exports.assertObjectMember = assertObjectMember; +exports.assertObjectMethod = assertObjectMethod; +exports.assertObjectPattern = assertObjectPattern; +exports.assertObjectProperty = assertObjectProperty; +exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; +exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; +exports.assertObjectTypeIndexer = assertObjectTypeIndexer; +exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; +exports.assertObjectTypeProperty = assertObjectTypeProperty; +exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; +exports.assertOpaqueType = assertOpaqueType; +exports.assertOptionalCallExpression = assertOptionalCallExpression; +exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType; +exports.assertOptionalMemberExpression = assertOptionalMemberExpression; +exports.assertParenthesizedExpression = assertParenthesizedExpression; +exports.assertPattern = assertPattern; +exports.assertPatternLike = assertPatternLike; +exports.assertPipelineBareFunction = assertPipelineBareFunction; +exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; +exports.assertPipelineTopicExpression = assertPipelineTopicExpression; +exports.assertPlaceholder = assertPlaceholder; +exports.assertPrivate = assertPrivate; +exports.assertPrivateName = assertPrivateName; +exports.assertProgram = assertProgram; +exports.assertProperty = assertProperty; +exports.assertPureish = assertPureish; +exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; +exports.assertRecordExpression = assertRecordExpression; +exports.assertRegExpLiteral = assertRegExpLiteral; +exports.assertRegexLiteral = assertRegexLiteral; +exports.assertRestElement = assertRestElement; +exports.assertRestProperty = assertRestProperty; +exports.assertReturnStatement = assertReturnStatement; +exports.assertScopable = assertScopable; +exports.assertSequenceExpression = assertSequenceExpression; +exports.assertSpreadElement = assertSpreadElement; +exports.assertSpreadProperty = assertSpreadProperty; +exports.assertStandardized = assertStandardized; +exports.assertStatement = assertStatement; +exports.assertStaticBlock = assertStaticBlock; +exports.assertStringLiteral = assertStringLiteral; +exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; +exports.assertStringTypeAnnotation = assertStringTypeAnnotation; +exports.assertSuper = assertSuper; +exports.assertSwitchCase = assertSwitchCase; +exports.assertSwitchStatement = assertSwitchStatement; +exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation; +exports.assertTSAnyKeyword = assertTSAnyKeyword; +exports.assertTSArrayType = assertTSArrayType; +exports.assertTSAsExpression = assertTSAsExpression; +exports.assertTSBaseType = assertTSBaseType; +exports.assertTSBigIntKeyword = assertTSBigIntKeyword; +exports.assertTSBooleanKeyword = assertTSBooleanKeyword; +exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; +exports.assertTSConditionalType = assertTSConditionalType; +exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; +exports.assertTSConstructorType = assertTSConstructorType; +exports.assertTSDeclareFunction = assertTSDeclareFunction; +exports.assertTSDeclareMethod = assertTSDeclareMethod; +exports.assertTSEntityName = assertTSEntityName; +exports.assertTSEnumBody = assertTSEnumBody; +exports.assertTSEnumDeclaration = assertTSEnumDeclaration; +exports.assertTSEnumMember = assertTSEnumMember; +exports.assertTSExportAssignment = assertTSExportAssignment; +exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; +exports.assertTSExternalModuleReference = assertTSExternalModuleReference; +exports.assertTSFunctionType = assertTSFunctionType; +exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; +exports.assertTSImportType = assertTSImportType; +exports.assertTSIndexSignature = assertTSIndexSignature; +exports.assertTSIndexedAccessType = assertTSIndexedAccessType; +exports.assertTSInferType = assertTSInferType; +exports.assertTSInstantiationExpression = assertTSInstantiationExpression; +exports.assertTSInterfaceBody = assertTSInterfaceBody; +exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; +exports.assertTSIntersectionType = assertTSIntersectionType; +exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword; +exports.assertTSLiteralType = assertTSLiteralType; +exports.assertTSMappedType = assertTSMappedType; +exports.assertTSMethodSignature = assertTSMethodSignature; +exports.assertTSModuleBlock = assertTSModuleBlock; +exports.assertTSModuleDeclaration = assertTSModuleDeclaration; +exports.assertTSNamedTupleMember = assertTSNamedTupleMember; +exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; +exports.assertTSNeverKeyword = assertTSNeverKeyword; +exports.assertTSNonNullExpression = assertTSNonNullExpression; +exports.assertTSNullKeyword = assertTSNullKeyword; +exports.assertTSNumberKeyword = assertTSNumberKeyword; +exports.assertTSObjectKeyword = assertTSObjectKeyword; +exports.assertTSOptionalType = assertTSOptionalType; +exports.assertTSParameterProperty = assertTSParameterProperty; +exports.assertTSParenthesizedType = assertTSParenthesizedType; +exports.assertTSPropertySignature = assertTSPropertySignature; +exports.assertTSQualifiedName = assertTSQualifiedName; +exports.assertTSRestType = assertTSRestType; +exports.assertTSSatisfiesExpression = assertTSSatisfiesExpression; +exports.assertTSStringKeyword = assertTSStringKeyword; +exports.assertTSSymbolKeyword = assertTSSymbolKeyword; +exports.assertTSTemplateLiteralType = assertTSTemplateLiteralType; +exports.assertTSThisType = assertTSThisType; +exports.assertTSTupleType = assertTSTupleType; +exports.assertTSType = assertTSType; +exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; +exports.assertTSTypeAnnotation = assertTSTypeAnnotation; +exports.assertTSTypeAssertion = assertTSTypeAssertion; +exports.assertTSTypeElement = assertTSTypeElement; +exports.assertTSTypeLiteral = assertTSTypeLiteral; +exports.assertTSTypeOperator = assertTSTypeOperator; +exports.assertTSTypeParameter = assertTSTypeParameter; +exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; +exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; +exports.assertTSTypePredicate = assertTSTypePredicate; +exports.assertTSTypeQuery = assertTSTypeQuery; +exports.assertTSTypeReference = assertTSTypeReference; +exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; +exports.assertTSUnionType = assertTSUnionType; +exports.assertTSUnknownKeyword = assertTSUnknownKeyword; +exports.assertTSVoidKeyword = assertTSVoidKeyword; +exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; +exports.assertTemplateElement = assertTemplateElement; +exports.assertTemplateLiteral = assertTemplateLiteral; +exports.assertTerminatorless = assertTerminatorless; +exports.assertThisExpression = assertThisExpression; +exports.assertThisTypeAnnotation = assertThisTypeAnnotation; +exports.assertThrowStatement = assertThrowStatement; +exports.assertTopicReference = assertTopicReference; +exports.assertTryStatement = assertTryStatement; +exports.assertTupleExpression = assertTupleExpression; +exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; +exports.assertTypeAlias = assertTypeAlias; +exports.assertTypeAnnotation = assertTypeAnnotation; +exports.assertTypeCastExpression = assertTypeCastExpression; +exports.assertTypeParameter = assertTypeParameter; +exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; +exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; +exports.assertTypeScript = assertTypeScript; +exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; +exports.assertUnaryExpression = assertUnaryExpression; +exports.assertUnaryLike = assertUnaryLike; +exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; +exports.assertUpdateExpression = assertUpdateExpression; +exports.assertUserWhitespacable = assertUserWhitespacable; +exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier; +exports.assertVariableDeclaration = assertVariableDeclaration; +exports.assertVariableDeclarator = assertVariableDeclarator; +exports.assertVariance = assertVariance; +exports.assertVoidPattern = assertVoidPattern; +exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; +exports.assertWhile = assertWhile; +exports.assertWhileStatement = assertWhileStatement; +exports.assertWithStatement = assertWithStatement; +exports.assertYieldExpression = assertYieldExpression; +var _is = require("../../validators/is.js"); +var _deprecationWarning = require("../../utils/deprecationWarning.js"); +function assert(type, node, opts) { + if (!(0, _is.default)(type, node, opts)) { + throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`); + } +} +function assertArrayExpression(node, opts) { + assert("ArrayExpression", node, opts); +} +function assertAssignmentExpression(node, opts) { + assert("AssignmentExpression", node, opts); +} +function assertBinaryExpression(node, opts) { + assert("BinaryExpression", node, opts); +} +function assertInterpreterDirective(node, opts) { + assert("InterpreterDirective", node, opts); +} +function assertDirective(node, opts) { + assert("Directive", node, opts); +} +function assertDirectiveLiteral(node, opts) { + assert("DirectiveLiteral", node, opts); +} +function assertBlockStatement(node, opts) { + assert("BlockStatement", node, opts); +} +function assertBreakStatement(node, opts) { + assert("BreakStatement", node, opts); +} +function assertCallExpression(node, opts) { + assert("CallExpression", node, opts); +} +function assertCatchClause(node, opts) { + assert("CatchClause", node, opts); +} +function assertConditionalExpression(node, opts) { + assert("ConditionalExpression", node, opts); +} +function assertContinueStatement(node, opts) { + assert("ContinueStatement", node, opts); +} +function assertDebuggerStatement(node, opts) { + assert("DebuggerStatement", node, opts); +} +function assertDoWhileStatement(node, opts) { + assert("DoWhileStatement", node, opts); +} +function assertEmptyStatement(node, opts) { + assert("EmptyStatement", node, opts); +} +function assertExpressionStatement(node, opts) { + assert("ExpressionStatement", node, opts); +} +function assertFile(node, opts) { + assert("File", node, opts); +} +function assertForInStatement(node, opts) { + assert("ForInStatement", node, opts); +} +function assertForStatement(node, opts) { + assert("ForStatement", node, opts); +} +function assertFunctionDeclaration(node, opts) { + assert("FunctionDeclaration", node, opts); +} +function assertFunctionExpression(node, opts) { + assert("FunctionExpression", node, opts); +} +function assertIdentifier(node, opts) { + assert("Identifier", node, opts); +} +function assertIfStatement(node, opts) { + assert("IfStatement", node, opts); +} +function assertLabeledStatement(node, opts) { + assert("LabeledStatement", node, opts); +} +function assertStringLiteral(node, opts) { + assert("StringLiteral", node, opts); +} +function assertNumericLiteral(node, opts) { + assert("NumericLiteral", node, opts); +} +function assertNullLiteral(node, opts) { + assert("NullLiteral", node, opts); +} +function assertBooleanLiteral(node, opts) { + assert("BooleanLiteral", node, opts); +} +function assertRegExpLiteral(node, opts) { + assert("RegExpLiteral", node, opts); +} +function assertLogicalExpression(node, opts) { + assert("LogicalExpression", node, opts); +} +function assertMemberExpression(node, opts) { + assert("MemberExpression", node, opts); +} +function assertNewExpression(node, opts) { + assert("NewExpression", node, opts); +} +function assertProgram(node, opts) { + assert("Program", node, opts); +} +function assertObjectExpression(node, opts) { + assert("ObjectExpression", node, opts); +} +function assertObjectMethod(node, opts) { + assert("ObjectMethod", node, opts); +} +function assertObjectProperty(node, opts) { + assert("ObjectProperty", node, opts); +} +function assertRestElement(node, opts) { + assert("RestElement", node, opts); +} +function assertReturnStatement(node, opts) { + assert("ReturnStatement", node, opts); +} +function assertSequenceExpression(node, opts) { + assert("SequenceExpression", node, opts); +} +function assertParenthesizedExpression(node, opts) { + assert("ParenthesizedExpression", node, opts); +} +function assertSwitchCase(node, opts) { + assert("SwitchCase", node, opts); +} +function assertSwitchStatement(node, opts) { + assert("SwitchStatement", node, opts); +} +function assertThisExpression(node, opts) { + assert("ThisExpression", node, opts); +} +function assertThrowStatement(node, opts) { + assert("ThrowStatement", node, opts); +} +function assertTryStatement(node, opts) { + assert("TryStatement", node, opts); +} +function assertUnaryExpression(node, opts) { + assert("UnaryExpression", node, opts); +} +function assertUpdateExpression(node, opts) { + assert("UpdateExpression", node, opts); +} +function assertVariableDeclaration(node, opts) { + assert("VariableDeclaration", node, opts); +} +function assertVariableDeclarator(node, opts) { + assert("VariableDeclarator", node, opts); +} +function assertWhileStatement(node, opts) { + assert("WhileStatement", node, opts); +} +function assertWithStatement(node, opts) { + assert("WithStatement", node, opts); +} +function assertAssignmentPattern(node, opts) { + assert("AssignmentPattern", node, opts); +} +function assertArrayPattern(node, opts) { + assert("ArrayPattern", node, opts); +} +function assertArrowFunctionExpression(node, opts) { + assert("ArrowFunctionExpression", node, opts); +} +function assertClassBody(node, opts) { + assert("ClassBody", node, opts); +} +function assertClassExpression(node, opts) { + assert("ClassExpression", node, opts); +} +function assertClassDeclaration(node, opts) { + assert("ClassDeclaration", node, opts); +} +function assertExportAllDeclaration(node, opts) { + assert("ExportAllDeclaration", node, opts); +} +function assertExportDefaultDeclaration(node, opts) { + assert("ExportDefaultDeclaration", node, opts); +} +function assertExportNamedDeclaration(node, opts) { + assert("ExportNamedDeclaration", node, opts); +} +function assertExportSpecifier(node, opts) { + assert("ExportSpecifier", node, opts); +} +function assertForOfStatement(node, opts) { + assert("ForOfStatement", node, opts); +} +function assertImportDeclaration(node, opts) { + assert("ImportDeclaration", node, opts); +} +function assertImportDefaultSpecifier(node, opts) { + assert("ImportDefaultSpecifier", node, opts); +} +function assertImportNamespaceSpecifier(node, opts) { + assert("ImportNamespaceSpecifier", node, opts); +} +function assertImportSpecifier(node, opts) { + assert("ImportSpecifier", node, opts); +} +function assertImportExpression(node, opts) { + assert("ImportExpression", node, opts); +} +function assertMetaProperty(node, opts) { + assert("MetaProperty", node, opts); +} +function assertClassMethod(node, opts) { + assert("ClassMethod", node, opts); +} +function assertObjectPattern(node, opts) { + assert("ObjectPattern", node, opts); +} +function assertSpreadElement(node, opts) { + assert("SpreadElement", node, opts); +} +function assertSuper(node, opts) { + assert("Super", node, opts); +} +function assertTaggedTemplateExpression(node, opts) { + assert("TaggedTemplateExpression", node, opts); +} +function assertTemplateElement(node, opts) { + assert("TemplateElement", node, opts); +} +function assertTemplateLiteral(node, opts) { + assert("TemplateLiteral", node, opts); +} +function assertYieldExpression(node, opts) { + assert("YieldExpression", node, opts); +} +function assertAwaitExpression(node, opts) { + assert("AwaitExpression", node, opts); +} +function assertImport(node, opts) { + assert("Import", node, opts); +} +function assertBigIntLiteral(node, opts) { + assert("BigIntLiteral", node, opts); +} +function assertExportNamespaceSpecifier(node, opts) { + assert("ExportNamespaceSpecifier", node, opts); +} +function assertOptionalMemberExpression(node, opts) { + assert("OptionalMemberExpression", node, opts); +} +function assertOptionalCallExpression(node, opts) { + assert("OptionalCallExpression", node, opts); +} +function assertClassProperty(node, opts) { + assert("ClassProperty", node, opts); +} +function assertClassAccessorProperty(node, opts) { + assert("ClassAccessorProperty", node, opts); +} +function assertClassPrivateProperty(node, opts) { + assert("ClassPrivateProperty", node, opts); +} +function assertClassPrivateMethod(node, opts) { + assert("ClassPrivateMethod", node, opts); +} +function assertPrivateName(node, opts) { + assert("PrivateName", node, opts); +} +function assertStaticBlock(node, opts) { + assert("StaticBlock", node, opts); +} +function assertImportAttribute(node, opts) { + assert("ImportAttribute", node, opts); +} +function assertAnyTypeAnnotation(node, opts) { + assert("AnyTypeAnnotation", node, opts); +} +function assertArrayTypeAnnotation(node, opts) { + assert("ArrayTypeAnnotation", node, opts); +} +function assertBooleanTypeAnnotation(node, opts) { + assert("BooleanTypeAnnotation", node, opts); +} +function assertBooleanLiteralTypeAnnotation(node, opts) { + assert("BooleanLiteralTypeAnnotation", node, opts); +} +function assertNullLiteralTypeAnnotation(node, opts) { + assert("NullLiteralTypeAnnotation", node, opts); +} +function assertClassImplements(node, opts) { + assert("ClassImplements", node, opts); +} +function assertDeclareClass(node, opts) { + assert("DeclareClass", node, opts); +} +function assertDeclareFunction(node, opts) { + assert("DeclareFunction", node, opts); +} +function assertDeclareInterface(node, opts) { + assert("DeclareInterface", node, opts); +} +function assertDeclareModule(node, opts) { + assert("DeclareModule", node, opts); +} +function assertDeclareModuleExports(node, opts) { + assert("DeclareModuleExports", node, opts); +} +function assertDeclareTypeAlias(node, opts) { + assert("DeclareTypeAlias", node, opts); +} +function assertDeclareOpaqueType(node, opts) { + assert("DeclareOpaqueType", node, opts); +} +function assertDeclareVariable(node, opts) { + assert("DeclareVariable", node, opts); +} +function assertDeclareExportDeclaration(node, opts) { + assert("DeclareExportDeclaration", node, opts); +} +function assertDeclareExportAllDeclaration(node, opts) { + assert("DeclareExportAllDeclaration", node, opts); +} +function assertDeclaredPredicate(node, opts) { + assert("DeclaredPredicate", node, opts); +} +function assertExistsTypeAnnotation(node, opts) { + assert("ExistsTypeAnnotation", node, opts); +} +function assertFunctionTypeAnnotation(node, opts) { + assert("FunctionTypeAnnotation", node, opts); +} +function assertFunctionTypeParam(node, opts) { + assert("FunctionTypeParam", node, opts); +} +function assertGenericTypeAnnotation(node, opts) { + assert("GenericTypeAnnotation", node, opts); +} +function assertInferredPredicate(node, opts) { + assert("InferredPredicate", node, opts); +} +function assertInterfaceExtends(node, opts) { + assert("InterfaceExtends", node, opts); +} +function assertInterfaceDeclaration(node, opts) { + assert("InterfaceDeclaration", node, opts); +} +function assertInterfaceTypeAnnotation(node, opts) { + assert("InterfaceTypeAnnotation", node, opts); +} +function assertIntersectionTypeAnnotation(node, opts) { + assert("IntersectionTypeAnnotation", node, opts); +} +function assertMixedTypeAnnotation(node, opts) { + assert("MixedTypeAnnotation", node, opts); +} +function assertEmptyTypeAnnotation(node, opts) { + assert("EmptyTypeAnnotation", node, opts); +} +function assertNullableTypeAnnotation(node, opts) { + assert("NullableTypeAnnotation", node, opts); +} +function assertNumberLiteralTypeAnnotation(node, opts) { + assert("NumberLiteralTypeAnnotation", node, opts); +} +function assertNumberTypeAnnotation(node, opts) { + assert("NumberTypeAnnotation", node, opts); +} +function assertObjectTypeAnnotation(node, opts) { + assert("ObjectTypeAnnotation", node, opts); +} +function assertObjectTypeInternalSlot(node, opts) { + assert("ObjectTypeInternalSlot", node, opts); +} +function assertObjectTypeCallProperty(node, opts) { + assert("ObjectTypeCallProperty", node, opts); +} +function assertObjectTypeIndexer(node, opts) { + assert("ObjectTypeIndexer", node, opts); +} +function assertObjectTypeProperty(node, opts) { + assert("ObjectTypeProperty", node, opts); +} +function assertObjectTypeSpreadProperty(node, opts) { + assert("ObjectTypeSpreadProperty", node, opts); +} +function assertOpaqueType(node, opts) { + assert("OpaqueType", node, opts); +} +function assertQualifiedTypeIdentifier(node, opts) { + assert("QualifiedTypeIdentifier", node, opts); +} +function assertStringLiteralTypeAnnotation(node, opts) { + assert("StringLiteralTypeAnnotation", node, opts); +} +function assertStringTypeAnnotation(node, opts) { + assert("StringTypeAnnotation", node, opts); +} +function assertSymbolTypeAnnotation(node, opts) { + assert("SymbolTypeAnnotation", node, opts); +} +function assertThisTypeAnnotation(node, opts) { + assert("ThisTypeAnnotation", node, opts); +} +function assertTupleTypeAnnotation(node, opts) { + assert("TupleTypeAnnotation", node, opts); +} +function assertTypeofTypeAnnotation(node, opts) { + assert("TypeofTypeAnnotation", node, opts); +} +function assertTypeAlias(node, opts) { + assert("TypeAlias", node, opts); +} +function assertTypeAnnotation(node, opts) { + assert("TypeAnnotation", node, opts); +} +function assertTypeCastExpression(node, opts) { + assert("TypeCastExpression", node, opts); +} +function assertTypeParameter(node, opts) { + assert("TypeParameter", node, opts); +} +function assertTypeParameterDeclaration(node, opts) { + assert("TypeParameterDeclaration", node, opts); +} +function assertTypeParameterInstantiation(node, opts) { + assert("TypeParameterInstantiation", node, opts); +} +function assertUnionTypeAnnotation(node, opts) { + assert("UnionTypeAnnotation", node, opts); +} +function assertVariance(node, opts) { + assert("Variance", node, opts); +} +function assertVoidTypeAnnotation(node, opts) { + assert("VoidTypeAnnotation", node, opts); +} +function assertEnumDeclaration(node, opts) { + assert("EnumDeclaration", node, opts); +} +function assertEnumBooleanBody(node, opts) { + assert("EnumBooleanBody", node, opts); +} +function assertEnumNumberBody(node, opts) { + assert("EnumNumberBody", node, opts); +} +function assertEnumStringBody(node, opts) { + assert("EnumStringBody", node, opts); +} +function assertEnumSymbolBody(node, opts) { + assert("EnumSymbolBody", node, opts); +} +function assertEnumBooleanMember(node, opts) { + assert("EnumBooleanMember", node, opts); +} +function assertEnumNumberMember(node, opts) { + assert("EnumNumberMember", node, opts); +} +function assertEnumStringMember(node, opts) { + assert("EnumStringMember", node, opts); +} +function assertEnumDefaultedMember(node, opts) { + assert("EnumDefaultedMember", node, opts); +} +function assertIndexedAccessType(node, opts) { + assert("IndexedAccessType", node, opts); +} +function assertOptionalIndexedAccessType(node, opts) { + assert("OptionalIndexedAccessType", node, opts); +} +function assertJSXAttribute(node, opts) { + assert("JSXAttribute", node, opts); +} +function assertJSXClosingElement(node, opts) { + assert("JSXClosingElement", node, opts); +} +function assertJSXElement(node, opts) { + assert("JSXElement", node, opts); +} +function assertJSXEmptyExpression(node, opts) { + assert("JSXEmptyExpression", node, opts); +} +function assertJSXExpressionContainer(node, opts) { + assert("JSXExpressionContainer", node, opts); +} +function assertJSXSpreadChild(node, opts) { + assert("JSXSpreadChild", node, opts); +} +function assertJSXIdentifier(node, opts) { + assert("JSXIdentifier", node, opts); +} +function assertJSXMemberExpression(node, opts) { + assert("JSXMemberExpression", node, opts); +} +function assertJSXNamespacedName(node, opts) { + assert("JSXNamespacedName", node, opts); +} +function assertJSXOpeningElement(node, opts) { + assert("JSXOpeningElement", node, opts); +} +function assertJSXSpreadAttribute(node, opts) { + assert("JSXSpreadAttribute", node, opts); +} +function assertJSXText(node, opts) { + assert("JSXText", node, opts); +} +function assertJSXFragment(node, opts) { + assert("JSXFragment", node, opts); +} +function assertJSXOpeningFragment(node, opts) { + assert("JSXOpeningFragment", node, opts); +} +function assertJSXClosingFragment(node, opts) { + assert("JSXClosingFragment", node, opts); +} +function assertNoop(node, opts) { + assert("Noop", node, opts); +} +function assertPlaceholder(node, opts) { + assert("Placeholder", node, opts); +} +function assertV8IntrinsicIdentifier(node, opts) { + assert("V8IntrinsicIdentifier", node, opts); +} +function assertArgumentPlaceholder(node, opts) { + assert("ArgumentPlaceholder", node, opts); +} +function assertBindExpression(node, opts) { + assert("BindExpression", node, opts); +} +function assertDecorator(node, opts) { + assert("Decorator", node, opts); +} +function assertDoExpression(node, opts) { + assert("DoExpression", node, opts); +} +function assertExportDefaultSpecifier(node, opts) { + assert("ExportDefaultSpecifier", node, opts); +} +function assertRecordExpression(node, opts) { + assert("RecordExpression", node, opts); +} +function assertTupleExpression(node, opts) { + assert("TupleExpression", node, opts); +} +function assertDecimalLiteral(node, opts) { + assert("DecimalLiteral", node, opts); +} +function assertModuleExpression(node, opts) { + assert("ModuleExpression", node, opts); +} +function assertTopicReference(node, opts) { + assert("TopicReference", node, opts); +} +function assertPipelineTopicExpression(node, opts) { + assert("PipelineTopicExpression", node, opts); +} +function assertPipelineBareFunction(node, opts) { + assert("PipelineBareFunction", node, opts); +} +function assertPipelinePrimaryTopicReference(node, opts) { + assert("PipelinePrimaryTopicReference", node, opts); +} +function assertVoidPattern(node, opts) { + assert("VoidPattern", node, opts); +} +function assertTSParameterProperty(node, opts) { + assert("TSParameterProperty", node, opts); +} +function assertTSDeclareFunction(node, opts) { + assert("TSDeclareFunction", node, opts); +} +function assertTSDeclareMethod(node, opts) { + assert("TSDeclareMethod", node, opts); +} +function assertTSQualifiedName(node, opts) { + assert("TSQualifiedName", node, opts); +} +function assertTSCallSignatureDeclaration(node, opts) { + assert("TSCallSignatureDeclaration", node, opts); +} +function assertTSConstructSignatureDeclaration(node, opts) { + assert("TSConstructSignatureDeclaration", node, opts); +} +function assertTSPropertySignature(node, opts) { + assert("TSPropertySignature", node, opts); +} +function assertTSMethodSignature(node, opts) { + assert("TSMethodSignature", node, opts); +} +function assertTSIndexSignature(node, opts) { + assert("TSIndexSignature", node, opts); +} +function assertTSAnyKeyword(node, opts) { + assert("TSAnyKeyword", node, opts); +} +function assertTSBooleanKeyword(node, opts) { + assert("TSBooleanKeyword", node, opts); +} +function assertTSBigIntKeyword(node, opts) { + assert("TSBigIntKeyword", node, opts); +} +function assertTSIntrinsicKeyword(node, opts) { + assert("TSIntrinsicKeyword", node, opts); +} +function assertTSNeverKeyword(node, opts) { + assert("TSNeverKeyword", node, opts); +} +function assertTSNullKeyword(node, opts) { + assert("TSNullKeyword", node, opts); +} +function assertTSNumberKeyword(node, opts) { + assert("TSNumberKeyword", node, opts); +} +function assertTSObjectKeyword(node, opts) { + assert("TSObjectKeyword", node, opts); +} +function assertTSStringKeyword(node, opts) { + assert("TSStringKeyword", node, opts); +} +function assertTSSymbolKeyword(node, opts) { + assert("TSSymbolKeyword", node, opts); +} +function assertTSUndefinedKeyword(node, opts) { + assert("TSUndefinedKeyword", node, opts); +} +function assertTSUnknownKeyword(node, opts) { + assert("TSUnknownKeyword", node, opts); +} +function assertTSVoidKeyword(node, opts) { + assert("TSVoidKeyword", node, opts); +} +function assertTSThisType(node, opts) { + assert("TSThisType", node, opts); +} +function assertTSFunctionType(node, opts) { + assert("TSFunctionType", node, opts); +} +function assertTSConstructorType(node, opts) { + assert("TSConstructorType", node, opts); +} +function assertTSTypeReference(node, opts) { + assert("TSTypeReference", node, opts); +} +function assertTSTypePredicate(node, opts) { + assert("TSTypePredicate", node, opts); +} +function assertTSTypeQuery(node, opts) { + assert("TSTypeQuery", node, opts); +} +function assertTSTypeLiteral(node, opts) { + assert("TSTypeLiteral", node, opts); +} +function assertTSArrayType(node, opts) { + assert("TSArrayType", node, opts); +} +function assertTSTupleType(node, opts) { + assert("TSTupleType", node, opts); +} +function assertTSOptionalType(node, opts) { + assert("TSOptionalType", node, opts); +} +function assertTSRestType(node, opts) { + assert("TSRestType", node, opts); +} +function assertTSNamedTupleMember(node, opts) { + assert("TSNamedTupleMember", node, opts); +} +function assertTSUnionType(node, opts) { + assert("TSUnionType", node, opts); +} +function assertTSIntersectionType(node, opts) { + assert("TSIntersectionType", node, opts); +} +function assertTSConditionalType(node, opts) { + assert("TSConditionalType", node, opts); +} +function assertTSInferType(node, opts) { + assert("TSInferType", node, opts); +} +function assertTSParenthesizedType(node, opts) { + assert("TSParenthesizedType", node, opts); +} +function assertTSTypeOperator(node, opts) { + assert("TSTypeOperator", node, opts); +} +function assertTSIndexedAccessType(node, opts) { + assert("TSIndexedAccessType", node, opts); +} +function assertTSMappedType(node, opts) { + assert("TSMappedType", node, opts); +} +function assertTSTemplateLiteralType(node, opts) { + assert("TSTemplateLiteralType", node, opts); +} +function assertTSLiteralType(node, opts) { + assert("TSLiteralType", node, opts); +} +function assertTSExpressionWithTypeArguments(node, opts) { + assert("TSExpressionWithTypeArguments", node, opts); +} +function assertTSInterfaceDeclaration(node, opts) { + assert("TSInterfaceDeclaration", node, opts); +} +function assertTSInterfaceBody(node, opts) { + assert("TSInterfaceBody", node, opts); +} +function assertTSTypeAliasDeclaration(node, opts) { + assert("TSTypeAliasDeclaration", node, opts); +} +function assertTSInstantiationExpression(node, opts) { + assert("TSInstantiationExpression", node, opts); +} +function assertTSAsExpression(node, opts) { + assert("TSAsExpression", node, opts); +} +function assertTSSatisfiesExpression(node, opts) { + assert("TSSatisfiesExpression", node, opts); +} +function assertTSTypeAssertion(node, opts) { + assert("TSTypeAssertion", node, opts); +} +function assertTSEnumBody(node, opts) { + assert("TSEnumBody", node, opts); +} +function assertTSEnumDeclaration(node, opts) { + assert("TSEnumDeclaration", node, opts); +} +function assertTSEnumMember(node, opts) { + assert("TSEnumMember", node, opts); +} +function assertTSModuleDeclaration(node, opts) { + assert("TSModuleDeclaration", node, opts); +} +function assertTSModuleBlock(node, opts) { + assert("TSModuleBlock", node, opts); +} +function assertTSImportType(node, opts) { + assert("TSImportType", node, opts); +} +function assertTSImportEqualsDeclaration(node, opts) { + assert("TSImportEqualsDeclaration", node, opts); +} +function assertTSExternalModuleReference(node, opts) { + assert("TSExternalModuleReference", node, opts); +} +function assertTSNonNullExpression(node, opts) { + assert("TSNonNullExpression", node, opts); +} +function assertTSExportAssignment(node, opts) { + assert("TSExportAssignment", node, opts); +} +function assertTSNamespaceExportDeclaration(node, opts) { + assert("TSNamespaceExportDeclaration", node, opts); +} +function assertTSTypeAnnotation(node, opts) { + assert("TSTypeAnnotation", node, opts); +} +function assertTSTypeParameterInstantiation(node, opts) { + assert("TSTypeParameterInstantiation", node, opts); +} +function assertTSTypeParameterDeclaration(node, opts) { + assert("TSTypeParameterDeclaration", node, opts); +} +function assertTSTypeParameter(node, opts) { + assert("TSTypeParameter", node, opts); +} +function assertStandardized(node, opts) { + assert("Standardized", node, opts); +} +function assertExpression(node, opts) { + assert("Expression", node, opts); +} +function assertBinary(node, opts) { + assert("Binary", node, opts); +} +function assertScopable(node, opts) { + assert("Scopable", node, opts); +} +function assertBlockParent(node, opts) { + assert("BlockParent", node, opts); +} +function assertBlock(node, opts) { + assert("Block", node, opts); +} +function assertStatement(node, opts) { + assert("Statement", node, opts); +} +function assertTerminatorless(node, opts) { + assert("Terminatorless", node, opts); +} +function assertCompletionStatement(node, opts) { + assert("CompletionStatement", node, opts); +} +function assertConditional(node, opts) { + assert("Conditional", node, opts); +} +function assertLoop(node, opts) { + assert("Loop", node, opts); +} +function assertWhile(node, opts) { + assert("While", node, opts); +} +function assertExpressionWrapper(node, opts) { + assert("ExpressionWrapper", node, opts); +} +function assertFor(node, opts) { + assert("For", node, opts); +} +function assertForXStatement(node, opts) { + assert("ForXStatement", node, opts); +} +function assertFunction(node, opts) { + assert("Function", node, opts); +} +function assertFunctionParent(node, opts) { + assert("FunctionParent", node, opts); +} +function assertPureish(node, opts) { + assert("Pureish", node, opts); +} +function assertDeclaration(node, opts) { + assert("Declaration", node, opts); +} +function assertFunctionParameter(node, opts) { + assert("FunctionParameter", node, opts); +} +function assertPatternLike(node, opts) { + assert("PatternLike", node, opts); +} +function assertLVal(node, opts) { + assert("LVal", node, opts); +} +function assertTSEntityName(node, opts) { + assert("TSEntityName", node, opts); +} +function assertLiteral(node, opts) { + assert("Literal", node, opts); +} +function assertImmutable(node, opts) { + assert("Immutable", node, opts); +} +function assertUserWhitespacable(node, opts) { + assert("UserWhitespacable", node, opts); +} +function assertMethod(node, opts) { + assert("Method", node, opts); +} +function assertObjectMember(node, opts) { + assert("ObjectMember", node, opts); +} +function assertProperty(node, opts) { + assert("Property", node, opts); +} +function assertUnaryLike(node, opts) { + assert("UnaryLike", node, opts); +} +function assertPattern(node, opts) { + assert("Pattern", node, opts); +} +function assertClass(node, opts) { + assert("Class", node, opts); +} +function assertImportOrExportDeclaration(node, opts) { + assert("ImportOrExportDeclaration", node, opts); +} +function assertExportDeclaration(node, opts) { + assert("ExportDeclaration", node, opts); +} +function assertModuleSpecifier(node, opts) { + assert("ModuleSpecifier", node, opts); +} +function assertAccessor(node, opts) { + assert("Accessor", node, opts); +} +function assertPrivate(node, opts) { + assert("Private", node, opts); +} +function assertFlow(node, opts) { + assert("Flow", node, opts); +} +function assertFlowType(node, opts) { + assert("FlowType", node, opts); +} +function assertFlowBaseAnnotation(node, opts) { + assert("FlowBaseAnnotation", node, opts); +} +function assertFlowDeclaration(node, opts) { + assert("FlowDeclaration", node, opts); +} +function assertFlowPredicate(node, opts) { + assert("FlowPredicate", node, opts); +} +function assertEnumBody(node, opts) { + assert("EnumBody", node, opts); +} +function assertEnumMember(node, opts) { + assert("EnumMember", node, opts); +} +function assertJSX(node, opts) { + assert("JSX", node, opts); +} +function assertMiscellaneous(node, opts) { + assert("Miscellaneous", node, opts); +} +function assertTypeScript(node, opts) { + assert("TypeScript", node, opts); +} +function assertTSTypeElement(node, opts) { + assert("TSTypeElement", node, opts); +} +function assertTSType(node, opts) { + assert("TSType", node, opts); +} +function assertTSBaseType(node, opts) { + assert("TSBaseType", node, opts); +} +function assertNumberLiteral(node, opts) { + (0, _deprecationWarning.default)("assertNumberLiteral", "assertNumericLiteral"); + assert("NumberLiteral", node, opts); +} +function assertRegexLiteral(node, opts) { + (0, _deprecationWarning.default)("assertRegexLiteral", "assertRegExpLiteral"); + assert("RegexLiteral", node, opts); +} +function assertRestProperty(node, opts) { + (0, _deprecationWarning.default)("assertRestProperty", "assertRestElement"); + assert("RestProperty", node, opts); +} +function assertSpreadProperty(node, opts) { + (0, _deprecationWarning.default)("assertSpreadProperty", "assertSpreadElement"); + assert("SpreadProperty", node, opts); +} +function assertModuleDeclaration(node, opts) { + (0, _deprecationWarning.default)("assertModuleDeclaration", "assertImportOrExportDeclaration"); + assert("ModuleDeclaration", node, opts); +} + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {"../../validators/is.js":1771034509034,"../../utils/deprecationWarning.js":1771034509025}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509051, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _index = require("../generated/index.js"); +var _default = exports.default = createTypeAnnotationBasedOnTypeof; +function createTypeAnnotationBasedOnTypeof(type) { + switch (type) { + case "string": + return (0, _index.stringTypeAnnotation)(); + case "number": + return (0, _index.numberTypeAnnotation)(); + case "undefined": + return (0, _index.voidTypeAnnotation)(); + case "boolean": + return (0, _index.booleanTypeAnnotation)(); + case "function": + return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Function")); + case "object": + return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Object")); + case "symbol": + return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Symbol")); + case "bigint": + return (0, _index.anyTypeAnnotation)(); + } + throw new Error("Invalid typeof value: " + type); +} + +//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map + +}, function(modId) { var map = {"../generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509052, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = createFlowUnionType; +var _index = require("../generated/index.js"); +var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates.js"); +function createFlowUnionType(types) { + const flattened = (0, _removeTypeDuplicates.default)(types); + if (flattened.length === 1) { + return flattened[0]; + } else { + return (0, _index.unionTypeAnnotation)(flattened); + } +} + +//# sourceMappingURL=createFlowUnionType.js.map + +}, function(modId) { var map = {"../generated/index.js":1771034509029,"../../modifications/flow/removeTypeDuplicates.js":1771034509053}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509053, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeTypeDuplicates; +var _index = require("../../validators/generated/index.js"); +function getQualifiedName(node) { + return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`; +} +function removeTypeDuplicates(nodesIn) { + const nodes = Array.from(nodesIn); + const generics = new Map(); + const bases = new Map(); + const typeGroups = new Set(); + const types = []; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (!node) continue; + if (types.includes(node)) { + continue; + } + if ((0, _index.isAnyTypeAnnotation)(node)) { + return [node]; + } + if ((0, _index.isFlowBaseAnnotation)(node)) { + bases.set(node.type, node); + continue; + } + if ((0, _index.isUnionTypeAnnotation)(node)) { + if (!typeGroups.has(node.types)) { + nodes.push(...node.types); + typeGroups.add(node.types); + } + continue; + } + if ((0, _index.isGenericTypeAnnotation)(node)) { + const name = getQualifiedName(node.id); + if (generics.has(name)) { + let existing = generics.get(name); + if (existing.typeParameters) { + if (node.typeParameters) { + existing.typeParameters.params.push(...node.typeParameters.params); + existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params); + } + } else { + existing = node.typeParameters; + } + } else { + generics.set(name, node); + } + continue; + } + types.push(node); + } + for (const [, baseType] of bases) { + types.push(baseType); + } + for (const [, genericName] of generics) { + types.push(genericName); + } + return types; +} + +//# sourceMappingURL=removeTypeDuplicates.js.map + +}, function(modId) { var map = {"../../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509054, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = createTSUnionType; +var _index = require("../generated/index.js"); +var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates.js"); +var _index2 = require("../../validators/generated/index.js"); +function createTSUnionType(typeAnnotations) { + const types = typeAnnotations.map(type => { + return (0, _index2.isTSTypeAnnotation)(type) ? type.typeAnnotation : type; + }); + const flattened = (0, _removeTypeDuplicates.default)(types); + if (flattened.length === 1) { + return flattened[0]; + } else { + return (0, _index.tsUnionType)(flattened); + } +} + +//# sourceMappingURL=createTSUnionType.js.map + +}, function(modId) { var map = {"../generated/index.js":1771034509029,"../../modifications/typescript/removeTypeDuplicates.js":1771034509055,"../../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509055, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeTypeDuplicates; +var _index = require("../../validators/generated/index.js"); +function getQualifiedName(node) { + return (0, _index.isIdentifier)(node) ? node.name : (0, _index.isThisExpression)(node) ? "this" : `${node.right.name}.${getQualifiedName(node.left)}`; +} +function removeTypeDuplicates(nodesIn) { + const nodes = Array.from(nodesIn); + const generics = new Map(); + const bases = new Map(); + const typeGroups = new Set(); + const types = []; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (!node) continue; + if (types.includes(node)) { + continue; + } + if ((0, _index.isTSAnyKeyword)(node)) { + return [node]; + } + if ((0, _index.isTSBaseType)(node)) { + bases.set(node.type, node); + continue; + } + if ((0, _index.isTSUnionType)(node)) { + if (!typeGroups.has(node.types)) { + nodes.push(...node.types); + typeGroups.add(node.types); + } + continue; + } + const typeArgumentsKey = "typeParameters"; + if ((0, _index.isTSTypeReference)(node) && node[typeArgumentsKey]) { + const typeArguments = node[typeArgumentsKey]; + const name = getQualifiedName(node.typeName); + if (generics.has(name)) { + let existing = generics.get(name); + const existingTypeArguments = existing[typeArgumentsKey]; + if (existingTypeArguments) { + existingTypeArguments.params.push(...typeArguments.params); + existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params); + } else { + existing = typeArguments; + } + } else { + generics.set(name, node); + } + continue; + } + types.push(node); + } + for (const [, baseType] of bases) { + types.push(baseType); + } + for (const [, genericName] of generics) { + types.push(genericName); + } + return types; +} + +//# sourceMappingURL=removeTypeDuplicates.js.map + +}, function(modId) { var map = {"../../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509056, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.buildUndefinedNode = buildUndefinedNode; +var _index = require("./generated/index.js"); +function buildUndefinedNode() { + return (0, _index.unaryExpression)("void", (0, _index.numericLiteral)(0), true); +} + +//# sourceMappingURL=productions.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509057, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cloneNode; +var _index = require("../definitions/index.js"); +var _index2 = require("../validators/generated/index.js"); +const { + hasOwn +} = { + hasOwn: Function.call.bind(Object.prototype.hasOwnProperty) +}; +function cloneIfNode(obj, deep, withoutLoc, commentsCache) { + if (obj && typeof obj.type === "string") { + return cloneNodeInternal(obj, deep, withoutLoc, commentsCache); + } + return obj; +} +function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) { + if (Array.isArray(obj)) { + return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache)); + } + return cloneIfNode(obj, deep, withoutLoc, commentsCache); +} +function cloneNode(node, deep = true, withoutLoc = false) { + return cloneNodeInternal(node, deep, withoutLoc, new Map()); +} +function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) { + if (!node) return node; + const { + type + } = node; + const newNode = { + type: node.type + }; + if ((0, _index2.isIdentifier)(node)) { + newNode.name = node.name; + if (hasOwn(node, "optional") && typeof node.optional === "boolean") { + newNode.optional = node.optional; + } + if (hasOwn(node, "typeAnnotation")) { + newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation; + } + if (hasOwn(node, "decorators")) { + newNode.decorators = deep ? cloneIfNodeOrArray(node.decorators, true, withoutLoc, commentsCache) : node.decorators; + } + } else if (!hasOwn(_index.NODE_FIELDS, type)) { + throw new Error(`Unknown node type: "${type}"`); + } else { + for (const field of Object.keys(_index.NODE_FIELDS[type])) { + if (hasOwn(node, field)) { + if (deep) { + newNode[field] = (0, _index2.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache); + } else { + newNode[field] = node[field]; + } + } + } + } + if (hasOwn(node, "loc")) { + if (withoutLoc) { + newNode.loc = null; + } else { + newNode.loc = node.loc; + } + } + if (hasOwn(node, "leadingComments")) { + newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache); + } + if (hasOwn(node, "innerComments")) { + newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache); + } + if (hasOwn(node, "trailingComments")) { + newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache); + } + if (hasOwn(node, "extra")) { + newNode.extra = Object.assign({}, node.extra); + } + return newNode; +} +function maybeCloneComments(comments, deep, withoutLoc, commentsCache) { + if (!comments || !deep) { + return comments; + } + return comments.map(comment => { + const cache = commentsCache.get(comment); + if (cache) return cache; + const { + type, + value, + loc + } = comment; + const ret = { + type, + value, + loc + }; + if (withoutLoc) { + ret.loc = null; + } + commentsCache.set(comment, ret); + return ret; + }); +} + +//# sourceMappingURL=cloneNode.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032,"../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509058, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = clone; +var _cloneNode = require("./cloneNode.js"); +function clone(node) { + return (0, _cloneNode.default)(node, false); +} + +//# sourceMappingURL=clone.js.map + +}, function(modId) { var map = {"./cloneNode.js":1771034509057}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509059, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cloneDeep; +var _cloneNode = require("./cloneNode.js"); +function cloneDeep(node) { + return (0, _cloneNode.default)(node); +} + +//# sourceMappingURL=cloneDeep.js.map + +}, function(modId) { var map = {"./cloneNode.js":1771034509057}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509060, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cloneDeepWithoutLoc; +var _cloneNode = require("./cloneNode.js"); +function cloneDeepWithoutLoc(node) { + return (0, _cloneNode.default)(node, true, true); +} + +//# sourceMappingURL=cloneDeepWithoutLoc.js.map + +}, function(modId) { var map = {"./cloneNode.js":1771034509057}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509061, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = cloneWithoutLoc; +var _cloneNode = require("./cloneNode.js"); +function cloneWithoutLoc(node) { + return (0, _cloneNode.default)(node, false, true); +} + +//# sourceMappingURL=cloneWithoutLoc.js.map + +}, function(modId) { var map = {"./cloneNode.js":1771034509057}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509062, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = addComment; +var _addComments = require("./addComments.js"); +function addComment(node, type, content, line) { + return (0, _addComments.default)(node, type, [{ + type: line ? "CommentLine" : "CommentBlock", + value: content + }]); +} + +//# sourceMappingURL=addComment.js.map + +}, function(modId) { var map = {"./addComments.js":1771034509063}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509063, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = addComments; +function addComments(node, type, comments) { + if (!comments || !node) return node; + const key = `${type}Comments`; + if (node[key]) { + if (type === "leading") { + node[key] = comments.concat(node[key]); + } else { + node[key].push(...comments); + } + } else { + node[key] = comments; + } + return node; +} + +//# sourceMappingURL=addComments.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509064, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inheritInnerComments; +var _inherit = require("../utils/inherit.js"); +function inheritInnerComments(child, parent) { + (0, _inherit.default)("innerComments", child, parent); +} + +//# sourceMappingURL=inheritInnerComments.js.map + +}, function(modId) { var map = {"../utils/inherit.js":1771034509065}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509065, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inherit; +function inherit(key, child, parent) { + if (child && parent) { + child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean))); + } +} + +//# sourceMappingURL=inherit.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509066, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inheritLeadingComments; +var _inherit = require("../utils/inherit.js"); +function inheritLeadingComments(child, parent) { + (0, _inherit.default)("leadingComments", child, parent); +} + +//# sourceMappingURL=inheritLeadingComments.js.map + +}, function(modId) { var map = {"../utils/inherit.js":1771034509065}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509067, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inheritsComments; +var _inheritTrailingComments = require("./inheritTrailingComments.js"); +var _inheritLeadingComments = require("./inheritLeadingComments.js"); +var _inheritInnerComments = require("./inheritInnerComments.js"); +function inheritsComments(child, parent) { + (0, _inheritTrailingComments.default)(child, parent); + (0, _inheritLeadingComments.default)(child, parent); + (0, _inheritInnerComments.default)(child, parent); + return child; +} + +//# sourceMappingURL=inheritsComments.js.map + +}, function(modId) { var map = {"./inheritTrailingComments.js":1771034509068,"./inheritLeadingComments.js":1771034509066,"./inheritInnerComments.js":1771034509064}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509068, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inheritTrailingComments; +var _inherit = require("../utils/inherit.js"); +function inheritTrailingComments(child, parent) { + (0, _inherit.default)("trailingComments", child, parent); +} + +//# sourceMappingURL=inheritTrailingComments.js.map + +}, function(modId) { var map = {"../utils/inherit.js":1771034509065}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509069, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeComments; +var _index = require("../constants/index.js"); +function removeComments(node) { + _index.COMMENT_KEYS.forEach(key => { + node[key] = null; + }); + return node; +} + +//# sourceMappingURL=removeComments.js.map + +}, function(modId) { var map = {"../constants/index.js":1771034509038}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509070, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTIONPARAMETER_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0; +var _index = require("../../definitions/index.js"); +const STANDARDIZED_TYPES = exports.STANDARDIZED_TYPES = _index.FLIPPED_ALIAS_KEYS["Standardized"]; +const EXPRESSION_TYPES = exports.EXPRESSION_TYPES = _index.FLIPPED_ALIAS_KEYS["Expression"]; +const BINARY_TYPES = exports.BINARY_TYPES = _index.FLIPPED_ALIAS_KEYS["Binary"]; +const SCOPABLE_TYPES = exports.SCOPABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Scopable"]; +const BLOCKPARENT_TYPES = exports.BLOCKPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["BlockParent"]; +const BLOCK_TYPES = exports.BLOCK_TYPES = _index.FLIPPED_ALIAS_KEYS["Block"]; +const STATEMENT_TYPES = exports.STATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["Statement"]; +const TERMINATORLESS_TYPES = exports.TERMINATORLESS_TYPES = _index.FLIPPED_ALIAS_KEYS["Terminatorless"]; +const COMPLETIONSTATEMENT_TYPES = exports.COMPLETIONSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["CompletionStatement"]; +const CONDITIONAL_TYPES = exports.CONDITIONAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Conditional"]; +const LOOP_TYPES = exports.LOOP_TYPES = _index.FLIPPED_ALIAS_KEYS["Loop"]; +const WHILE_TYPES = exports.WHILE_TYPES = _index.FLIPPED_ALIAS_KEYS["While"]; +const EXPRESSIONWRAPPER_TYPES = exports.EXPRESSIONWRAPPER_TYPES = _index.FLIPPED_ALIAS_KEYS["ExpressionWrapper"]; +const FOR_TYPES = exports.FOR_TYPES = _index.FLIPPED_ALIAS_KEYS["For"]; +const FORXSTATEMENT_TYPES = exports.FORXSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["ForXStatement"]; +const FUNCTION_TYPES = exports.FUNCTION_TYPES = _index.FLIPPED_ALIAS_KEYS["Function"]; +const FUNCTIONPARENT_TYPES = exports.FUNCTIONPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParent"]; +const PUREISH_TYPES = exports.PUREISH_TYPES = _index.FLIPPED_ALIAS_KEYS["Pureish"]; +const DECLARATION_TYPES = exports.DECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["Declaration"]; +const FUNCTIONPARAMETER_TYPES = exports.FUNCTIONPARAMETER_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParameter"]; +const PATTERNLIKE_TYPES = exports.PATTERNLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["PatternLike"]; +const LVAL_TYPES = exports.LVAL_TYPES = _index.FLIPPED_ALIAS_KEYS["LVal"]; +const TSENTITYNAME_TYPES = exports.TSENTITYNAME_TYPES = _index.FLIPPED_ALIAS_KEYS["TSEntityName"]; +const LITERAL_TYPES = exports.LITERAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Literal"]; +const IMMUTABLE_TYPES = exports.IMMUTABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Immutable"]; +const USERWHITESPACABLE_TYPES = exports.USERWHITESPACABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["UserWhitespacable"]; +const METHOD_TYPES = exports.METHOD_TYPES = _index.FLIPPED_ALIAS_KEYS["Method"]; +const OBJECTMEMBER_TYPES = exports.OBJECTMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["ObjectMember"]; +const PROPERTY_TYPES = exports.PROPERTY_TYPES = _index.FLIPPED_ALIAS_KEYS["Property"]; +const UNARYLIKE_TYPES = exports.UNARYLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["UnaryLike"]; +const PATTERN_TYPES = exports.PATTERN_TYPES = _index.FLIPPED_ALIAS_KEYS["Pattern"]; +const CLASS_TYPES = exports.CLASS_TYPES = _index.FLIPPED_ALIAS_KEYS["Class"]; +const IMPORTOREXPORTDECLARATION_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"]; +const EXPORTDECLARATION_TYPES = exports.EXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ExportDeclaration"]; +const MODULESPECIFIER_TYPES = exports.MODULESPECIFIER_TYPES = _index.FLIPPED_ALIAS_KEYS["ModuleSpecifier"]; +const ACCESSOR_TYPES = exports.ACCESSOR_TYPES = _index.FLIPPED_ALIAS_KEYS["Accessor"]; +const PRIVATE_TYPES = exports.PRIVATE_TYPES = _index.FLIPPED_ALIAS_KEYS["Private"]; +const FLOW_TYPES = exports.FLOW_TYPES = _index.FLIPPED_ALIAS_KEYS["Flow"]; +const FLOWTYPE_TYPES = exports.FLOWTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowType"]; +const FLOWBASEANNOTATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"]; +const FLOWDECLARATION_TYPES = exports.FLOWDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowDeclaration"]; +const FLOWPREDICATE_TYPES = exports.FLOWPREDICATE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowPredicate"]; +const ENUMBODY_TYPES = exports.ENUMBODY_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumBody"]; +const ENUMMEMBER_TYPES = exports.ENUMMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumMember"]; +const JSX_TYPES = exports.JSX_TYPES = _index.FLIPPED_ALIAS_KEYS["JSX"]; +const MISCELLANEOUS_TYPES = exports.MISCELLANEOUS_TYPES = _index.FLIPPED_ALIAS_KEYS["Miscellaneous"]; +const TYPESCRIPT_TYPES = exports.TYPESCRIPT_TYPES = _index.FLIPPED_ALIAS_KEYS["TypeScript"]; +const TSTYPEELEMENT_TYPES = exports.TSTYPEELEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["TSTypeElement"]; +const TSTYPE_TYPES = exports.TSTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSType"]; +const TSBASETYPE_TYPES = exports.TSBASETYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSBaseType"]; +const MODULEDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES; + +//# sourceMappingURL=index.js.map + +}, function(modId) { var map = {"../../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509071, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = ensureBlock; +var _toBlock = require("./toBlock.js"); +function ensureBlock(node, key = "body") { + const result = (0, _toBlock.default)(node[key], node); + node[key] = result; + return result; +} + +//# sourceMappingURL=ensureBlock.js.map + +}, function(modId) { var map = {"./toBlock.js":1771034509072}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509072, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toBlock; +var _index = require("../validators/generated/index.js"); +var _index2 = require("../builders/generated/index.js"); +function toBlock(node, parent) { + if ((0, _index.isBlockStatement)(node)) { + return node; + } + let blockNodes = []; + if ((0, _index.isEmptyStatement)(node)) { + blockNodes = []; + } else { + if (!(0, _index.isStatement)(node)) { + if ((0, _index.isFunction)(parent)) { + node = (0, _index2.returnStatement)(node); + } else { + node = (0, _index2.expressionStatement)(node); + } + } + blockNodes = [node]; + } + return (0, _index2.blockStatement)(blockNodes); +} + +//# sourceMappingURL=toBlock.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023,"../builders/generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509073, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toBindingIdentifierName; +var _toIdentifier = require("./toIdentifier.js"); +function toBindingIdentifierName(name) { + name = (0, _toIdentifier.default)(name); + if (name === "eval" || name === "arguments") name = "_" + name; + return name; +} + +//# sourceMappingURL=toBindingIdentifierName.js.map + +}, function(modId) { var map = {"./toIdentifier.js":1771034509074}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509074, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toIdentifier; +var _isValidIdentifier = require("../validators/isValidIdentifier.js"); +var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); +function toIdentifier(input) { + input = input + ""; + let name = ""; + for (const c of input) { + name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-"; + } + name = name.replace(/^[-0-9]+/, ""); + name = name.replace(/[-\s]+(.)?/g, function (match, c) { + return c ? c.toUpperCase() : ""; + }); + if (!(0, _isValidIdentifier.default)(name)) { + name = `_${name}`; + } + return name || "_"; +} + +//# sourceMappingURL=toIdentifier.js.map + +}, function(modId) { var map = {"../validators/isValidIdentifier.js":1771034509037}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509075, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toComputedKey; +var _index = require("../validators/generated/index.js"); +var _index2 = require("../builders/generated/index.js"); +function toComputedKey(node, key = node.key || node.property) { + if (!node.computed && (0, _index.isIdentifier)(key)) key = (0, _index2.stringLiteral)(key.name); + return key; +} + +//# sourceMappingURL=toComputedKey.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023,"../builders/generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509076, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _index = require("../validators/generated/index.js"); +var _default = exports.default = toExpression; +function toExpression(node) { + if ((0, _index.isExpressionStatement)(node)) { + node = node.expression; + } + if ((0, _index.isExpression)(node)) { + return node; + } + if ((0, _index.isClass)(node)) { + node.type = "ClassExpression"; + node.abstract = false; + } else if ((0, _index.isFunction)(node)) { + node.type = "FunctionExpression"; + } + if (!(0, _index.isExpression)(node)) { + throw new Error(`cannot turn ${node.type} to an expression`); + } + return node; +} + +//# sourceMappingURL=toExpression.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509077, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toKeyAlias; +var _index = require("../validators/generated/index.js"); +var _cloneNode = require("../clone/cloneNode.js"); +var _removePropertiesDeep = require("../modifications/removePropertiesDeep.js"); +function toKeyAlias(node, key = node.key) { + let alias; + if (node.kind === "method") { + return toKeyAlias.increment() + ""; + } else if ((0, _index.isIdentifier)(key)) { + alias = key.name; + } else if ((0, _index.isStringLiteral)(key)) { + alias = JSON.stringify(key.value); + } else { + alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key))); + } + if (node.computed) { + alias = `[${alias}]`; + } + if (node.static) { + alias = `static:${alias}`; + } + return alias; +} +toKeyAlias.uid = 0; +toKeyAlias.increment = function () { + if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) { + return toKeyAlias.uid = 0; + } else { + return toKeyAlias.uid++; + } +}; + +//# sourceMappingURL=toKeyAlias.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023,"../clone/cloneNode.js":1771034509057,"../modifications/removePropertiesDeep.js":1771034509078}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509078, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removePropertiesDeep; +var _traverseFast = require("../traverse/traverseFast.js"); +var _removeProperties = require("./removeProperties.js"); +function removePropertiesDeep(tree, opts) { + (0, _traverseFast.default)(tree, _removeProperties.default, opts); + return tree; +} + +//# sourceMappingURL=removePropertiesDeep.js.map + +}, function(modId) { var map = {"../traverse/traverseFast.js":1771034509079,"./removeProperties.js":1771034509080}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509079, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = traverseFast; +var _index = require("../definitions/index.js"); +const _skip = Symbol(); +const _stop = Symbol(); +function traverseFast(node, enter, opts) { + if (!node) return false; + const keys = _index.VISITOR_KEYS[node.type]; + if (!keys) return false; + opts = opts || {}; + const ret = enter(node, opts); + if (ret !== undefined) { + switch (ret) { + case _skip: + return false; + case _stop: + return true; + } + } + for (const key of keys) { + const subNode = node[key]; + if (!subNode) continue; + if (Array.isArray(subNode)) { + for (const node of subNode) { + if (traverseFast(node, enter, opts)) return true; + } + } else { + if (traverseFast(subNode, enter, opts)) return true; + } + } + return false; +} +traverseFast.skip = _skip; +traverseFast.stop = _stop; + +//# sourceMappingURL=traverseFast.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509080, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = removeProperties; +var _index = require("../constants/index.js"); +const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; +const CLEAR_KEYS_PLUS_COMMENTS = [..._index.COMMENT_KEYS, "comments", ...CLEAR_KEYS]; +function removeProperties(node, opts = {}) { + const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; + for (const key of map) { + if (node[key] != null) node[key] = undefined; + } + for (const key of Object.keys(node)) { + if (key.startsWith("_") && node[key] != null) node[key] = undefined; + } + const symbols = Object.getOwnPropertySymbols(node); + for (const sym of symbols) { + node[sym] = null; + } +} + +//# sourceMappingURL=removeProperties.js.map + +}, function(modId) { var map = {"../constants/index.js":1771034509038}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509081, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _index = require("../validators/generated/index.js"); +var _index2 = require("../builders/generated/index.js"); +var _default = exports.default = toStatement; +function toStatement(node, ignore) { + if ((0, _index.isStatement)(node)) { + return node; + } + let mustHaveId = false; + let newType; + if ((0, _index.isClass)(node)) { + mustHaveId = true; + newType = "ClassDeclaration"; + } else if ((0, _index.isFunction)(node)) { + mustHaveId = true; + newType = "FunctionDeclaration"; + } else if ((0, _index.isAssignmentExpression)(node)) { + return (0, _index2.expressionStatement)(node); + } + if (mustHaveId && !node.id) { + newType = false; + } + if (!newType) { + if (ignore) { + return false; + } else { + throw new Error(`cannot turn ${node.type} to a statement`); + } + } + node.type = newType; + return node; +} + +//# sourceMappingURL=toStatement.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023,"../builders/generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509082, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _isValidIdentifier = require("../validators/isValidIdentifier.js"); +var _index = require("../builders/generated/index.js"); +var _default = exports.default = valueToNode; +const objectToString = Function.call.bind(Object.prototype.toString); +function isRegExp(value) { + return objectToString(value) === "[object RegExp]"; +} +function isPlainObject(value) { + if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") { + return false; + } + const proto = Object.getPrototypeOf(value); + return proto === null || Object.getPrototypeOf(proto) === null; +} +function valueToNode(value) { + if (value === undefined) { + return (0, _index.identifier)("undefined"); + } + if (value === true || value === false) { + return (0, _index.booleanLiteral)(value); + } + if (value === null) { + return (0, _index.nullLiteral)(); + } + if (typeof value === "string") { + return (0, _index.stringLiteral)(value); + } + if (typeof value === "number") { + let result; + if (Number.isFinite(value)) { + result = (0, _index.numericLiteral)(Math.abs(value)); + } else { + let numerator; + if (Number.isNaN(value)) { + numerator = (0, _index.numericLiteral)(0); + } else { + numerator = (0, _index.numericLiteral)(1); + } + result = (0, _index.binaryExpression)("/", numerator, (0, _index.numericLiteral)(0)); + } + if (value < 0 || Object.is(value, -0)) { + result = (0, _index.unaryExpression)("-", result); + } + return result; + } + if (typeof value === "bigint") { + if (value < 0) { + return (0, _index.unaryExpression)("-", (0, _index.bigIntLiteral)(-value)); + } else { + return (0, _index.bigIntLiteral)(value); + } + } + if (isRegExp(value)) { + const pattern = value.source; + const flags = /\/([a-z]*)$/.exec(value.toString())[1]; + return (0, _index.regExpLiteral)(pattern, flags); + } + if (Array.isArray(value)) { + return (0, _index.arrayExpression)(value.map(valueToNode)); + } + if (isPlainObject(value)) { + const props = []; + for (const key of Object.keys(value)) { + let nodeKey, + computed = false; + if ((0, _isValidIdentifier.default)(key)) { + if (key === "__proto__") { + computed = true; + nodeKey = (0, _index.stringLiteral)(key); + } else { + nodeKey = (0, _index.identifier)(key); + } + } else { + nodeKey = (0, _index.stringLiteral)(key); + } + props.push((0, _index.objectProperty)(nodeKey, valueToNode(value[key]), computed)); + } + return (0, _index.objectExpression)(props); + } + throw new Error("don't know how to turn this value into a node"); +} + +//# sourceMappingURL=valueToNode.js.map + +}, function(modId) { var map = {"../validators/isValidIdentifier.js":1771034509037,"../builders/generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509083, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = appendToMemberExpression; +var _index = require("../builders/generated/index.js"); +function appendToMemberExpression(member, append, computed = false) { + member.object = (0, _index.memberExpression)(member.object, member.property, member.computed); + member.property = append; + member.computed = !!computed; + return member; +} + +//# sourceMappingURL=appendToMemberExpression.js.map + +}, function(modId) { var map = {"../builders/generated/index.js":1771034509029}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509084, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = inherits; +var _index = require("../constants/index.js"); +var _inheritsComments = require("../comments/inheritsComments.js"); +function inherits(child, parent) { + if (!child || !parent) return child; + for (const key of _index.INHERIT_KEYS.optional) { + if (child[key] == null) { + child[key] = parent[key]; + } + } + for (const key of Object.keys(parent)) { + if (key.startsWith("_") && key !== "__clone") { + child[key] = parent[key]; + } + } + for (const key of _index.INHERIT_KEYS.force) { + child[key] = parent[key]; + } + (0, _inheritsComments.default)(child, parent); + return child; +} + +//# sourceMappingURL=inherits.js.map + +}, function(modId) { var map = {"../constants/index.js":1771034509038,"../comments/inheritsComments.js":1771034509067}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509085, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = prependToMemberExpression; +var _index = require("../builders/generated/index.js"); +var _index2 = require("../index.js"); +function prependToMemberExpression(member, prepend) { + if ((0, _index2.isSuper)(member.object)) { + throw new Error("Cannot prepend node to super property access (`super.foo`)."); + } + member.object = (0, _index.memberExpression)(prepend, member.object); + return member; +} + +//# sourceMappingURL=prependToMemberExpression.js.map + +}, function(modId) { var map = {"../builders/generated/index.js":1771034509029,"../index.js":1771034509019}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509086, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getAssignmentIdentifiers; +function getAssignmentIdentifiers(node) { + const search = [].concat(node); + const ids = Object.create(null); + while (search.length) { + const id = search.pop(); + if (!id) continue; + switch (id.type) { + case "ArrayPattern": + search.push(...id.elements); + break; + case "AssignmentExpression": + case "AssignmentPattern": + case "ForInStatement": + case "ForOfStatement": + search.push(id.left); + break; + case "ObjectPattern": + search.push(...id.properties); + break; + case "ObjectProperty": + search.push(id.value); + break; + case "RestElement": + case "UpdateExpression": + search.push(id.argument); + break; + case "UnaryExpression": + if (id.operator === "delete") { + search.push(id.argument); + } + break; + case "Identifier": + ids[id.name] = id; + break; + default: + break; + } + } + return ids; +} + +//# sourceMappingURL=getAssignmentIdentifiers.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509087, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getBindingIdentifiers; +var _index = require("../validators/generated/index.js"); +function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) { + const search = [].concat(node); + const ids = Object.create(null); + while (search.length) { + const id = search.shift(); + if (!id) continue; + if (newBindingsOnly && ((0, _index.isAssignmentExpression)(id) || (0, _index.isUnaryExpression)(id) || (0, _index.isUpdateExpression)(id))) { + continue; + } + if ((0, _index.isIdentifier)(id)) { + if (duplicates) { + const _ids = ids[id.name] = ids[id.name] || []; + _ids.push(id); + } else { + ids[id.name] = id; + } + continue; + } + if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) { + if ((0, _index.isDeclaration)(id.declaration)) { + search.push(id.declaration); + } + continue; + } + if (outerOnly) { + if ((0, _index.isFunctionDeclaration)(id)) { + search.push(id.id); + continue; + } + if ((0, _index.isFunctionExpression)(id)) { + continue; + } + } + const keys = getBindingIdentifiers.keys[id.type]; + if (keys) { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const nodes = id[key]; + if (nodes) { + if (Array.isArray(nodes)) { + search.push(...nodes); + } else { + search.push(nodes); + } + } + } + } + } + return ids; +} +const keys = { + DeclareClass: ["id"], + DeclareFunction: ["id"], + DeclareModule: ["id"], + DeclareVariable: ["id"], + DeclareInterface: ["id"], + DeclareTypeAlias: ["id"], + DeclareOpaqueType: ["id"], + InterfaceDeclaration: ["id"], + TypeAlias: ["id"], + OpaqueType: ["id"], + CatchClause: ["param"], + LabeledStatement: ["label"], + UnaryExpression: ["argument"], + AssignmentExpression: ["left"], + ImportSpecifier: ["local"], + ImportNamespaceSpecifier: ["local"], + ImportDefaultSpecifier: ["local"], + ImportDeclaration: ["specifiers"], + TSImportEqualsDeclaration: ["id"], + ExportSpecifier: ["exported"], + ExportNamespaceSpecifier: ["exported"], + ExportDefaultSpecifier: ["exported"], + FunctionDeclaration: ["id", "params"], + FunctionExpression: ["id", "params"], + ArrowFunctionExpression: ["params"], + ObjectMethod: ["params"], + ClassMethod: ["params"], + ClassPrivateMethod: ["params"], + ForInStatement: ["left"], + ForOfStatement: ["left"], + ClassDeclaration: ["id"], + ClassExpression: ["id"], + RestElement: ["argument"], + UpdateExpression: ["argument"], + ObjectProperty: ["value"], + AssignmentPattern: ["left"], + ArrayPattern: ["elements"], + ObjectPattern: ["properties"], + VariableDeclaration: ["declarations"], + VariableDeclarator: ["id"] +}; +getBindingIdentifiers.keys = keys; + +//# sourceMappingURL=getBindingIdentifiers.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509088, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _getBindingIdentifiers = require("./getBindingIdentifiers.js"); +var _default = exports.default = getOuterBindingIdentifiers; +function getOuterBindingIdentifiers(node, duplicates) { + return (0, _getBindingIdentifiers.default)(node, duplicates, true); +} + +//# sourceMappingURL=getOuterBindingIdentifiers.js.map + +}, function(modId) { var map = {"./getBindingIdentifiers.js":1771034509087}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509089, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getFunctionName; +var _index = require("../validators/generated/index.js"); +function getNameFromLiteralId(id) { + if ((0, _index.isNullLiteral)(id)) { + return "null"; + } + if ((0, _index.isRegExpLiteral)(id)) { + return `/${id.pattern}/${id.flags}`; + } + if ((0, _index.isTemplateLiteral)(id)) { + return id.quasis.map(quasi => quasi.value.raw).join(""); + } + if (id.value !== undefined) { + return String(id.value); + } + return null; +} +function getObjectMemberKey(node) { + if (!node.computed || (0, _index.isLiteral)(node.key)) { + return node.key; + } +} +function getFunctionName(node, parent) { + if ("id" in node && node.id) { + return { + name: node.id.name, + originalNode: node.id + }; + } + let prefix = ""; + let id; + if ((0, _index.isObjectProperty)(parent, { + value: node + })) { + id = getObjectMemberKey(parent); + } else if ((0, _index.isObjectMethod)(node) || (0, _index.isClassMethod)(node)) { + id = getObjectMemberKey(node); + if (node.kind === "get") prefix = "get ";else if (node.kind === "set") prefix = "set "; + } else if ((0, _index.isVariableDeclarator)(parent, { + init: node + })) { + id = parent.id; + } else if ((0, _index.isAssignmentExpression)(parent, { + operator: "=", + right: node + })) { + id = parent.left; + } + if (!id) return null; + const name = (0, _index.isLiteral)(id) ? getNameFromLiteralId(id) : (0, _index.isIdentifier)(id) ? id.name : (0, _index.isPrivateName)(id) ? id.id.name : null; + if (name == null) return null; + return { + name: prefix + name, + originalNode: id + }; +} + +//# sourceMappingURL=getFunctionName.js.map + +}, function(modId) { var map = {"../validators/generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509090, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = traverse; +var _index = require("../definitions/index.js"); +function traverse(node, handlers, state) { + if (typeof handlers === "function") { + handlers = { + enter: handlers + }; + } + const { + enter, + exit + } = handlers; + traverseSimpleImpl(node, enter, exit, state, []); +} +function traverseSimpleImpl(node, enter, exit, state, ancestors) { + const keys = _index.VISITOR_KEYS[node.type]; + if (!keys) return; + if (enter) enter(node, ancestors, state); + for (const key of keys) { + const subNode = node[key]; + if (Array.isArray(subNode)) { + for (let i = 0; i < subNode.length; i++) { + const child = subNode[i]; + if (!child) continue; + ancestors.push({ + node, + key, + index: i + }); + traverseSimpleImpl(child, enter, exit, state, ancestors); + ancestors.pop(); + } + } else if (subNode) { + ancestors.push({ + node, + key + }); + traverseSimpleImpl(subNode, enter, exit, state, ancestors); + ancestors.pop(); + } + } + if (exit) exit(node, ancestors, state); +} + +//# sourceMappingURL=traverse.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509091, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isBinding; +var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers.js"); +function isBinding(node, parent, grandparent) { + if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") { + return false; + } + const keys = _getBindingIdentifiers.default.keys[parent.type]; + if (keys) { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const val = parent[key]; + if (Array.isArray(val)) { + if (val.includes(node)) return true; + } else { + if (val === node) return true; + } + } + } + return false; +} + +//# sourceMappingURL=isBinding.js.map + +}, function(modId) { var map = {"../retrievers/getBindingIdentifiers.js":1771034509087}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509092, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isBlockScoped; +var _index = require("./generated/index.js"); +var _isLet = require("./isLet.js"); +function isBlockScoped(node) { + return (0, _index.isFunctionDeclaration)(node) || (0, _index.isClassDeclaration)(node) || (0, _isLet.default)(node); +} + +//# sourceMappingURL=isBlockScoped.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023,"./isLet.js":1771034509093}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509093, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isLet; +var _index = require("./generated/index.js"); +var BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); +function isLet(node) { + return (0, _index.isVariableDeclaration)(node) && (node.kind !== "var" || node[BLOCK_SCOPED_SYMBOL]); +} + +//# sourceMappingURL=isLet.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509094, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isImmutable; +var _isType = require("./isType.js"); +var _index = require("./generated/index.js"); +function isImmutable(node) { + if ((0, _isType.default)(node.type, "Immutable")) return true; + if ((0, _index.isIdentifier)(node)) { + if (node.name === "undefined") { + return true; + } else { + return false; + } + } + return false; +} + +//# sourceMappingURL=isImmutable.js.map + +}, function(modId) { var map = {"./isType.js":1771034509035,"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509095, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isNodesEquivalent; +var _index = require("../definitions/index.js"); +function isNodesEquivalent(a, b) { + if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) { + return a === b; + } + if (a.type !== b.type) { + return false; + } + const fields = Object.keys(_index.NODE_FIELDS[a.type] || a.type); + const visitorKeys = _index.VISITOR_KEYS[a.type]; + for (const field of fields) { + const val_a = a[field]; + const val_b = b[field]; + if (typeof val_a !== typeof val_b) { + return false; + } + if (val_a == null && val_b == null) { + continue; + } else if (val_a == null || val_b == null) { + return false; + } + if (Array.isArray(val_a)) { + if (!Array.isArray(val_b)) { + return false; + } + if (val_a.length !== val_b.length) { + return false; + } + for (let i = 0; i < val_a.length; i++) { + if (!isNodesEquivalent(val_a[i], val_b[i])) { + return false; + } + } + continue; + } + if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) { + for (const key of Object.keys(val_a)) { + if (val_a[key] !== val_b[key]) { + return false; + } + } + continue; + } + if (!isNodesEquivalent(val_a, val_b)) { + return false; + } + } + return true; +} + +//# sourceMappingURL=isNodesEquivalent.js.map + +}, function(modId) { var map = {"../definitions/index.js":1771034509032}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509096, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isReferenced; +function isReferenced(node, parent, grandparent) { + switch (parent.type) { + case "MemberExpression": + case "OptionalMemberExpression": + if (parent.property === node) { + return !!parent.computed; + } + return parent.object === node; + case "JSXMemberExpression": + return parent.object === node; + case "VariableDeclarator": + return parent.init === node; + case "ArrowFunctionExpression": + return parent.body === node; + case "PrivateName": + return false; + case "ClassMethod": + case "ClassPrivateMethod": + case "ObjectMethod": + if (parent.key === node) { + return !!parent.computed; + } + return false; + case "ObjectProperty": + if (parent.key === node) { + return !!parent.computed; + } + return (grandparent == null ? void 0 : grandparent.type) !== "ObjectPattern"; + case "ClassProperty": + case "ClassAccessorProperty": + if (parent.key === node) { + return !!parent.computed; + } + return true; + case "ClassPrivateProperty": + return parent.key !== node; + case "ClassDeclaration": + case "ClassExpression": + return parent.superClass === node; + case "AssignmentExpression": + return parent.right === node; + case "AssignmentPattern": + return parent.right === node; + case "LabeledStatement": + return false; + case "CatchClause": + return false; + case "RestElement": + return false; + case "BreakStatement": + case "ContinueStatement": + return false; + case "FunctionDeclaration": + case "FunctionExpression": + return false; + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + return false; + case "ExportSpecifier": + if (grandparent != null && grandparent.source) { + return false; + } + return parent.local === node; + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + return false; + case "ImportAttribute": + return false; + case "JSXAttribute": + return false; + case "ObjectPattern": + case "ArrayPattern": + return false; + case "MetaProperty": + return false; + case "ObjectTypeProperty": + return parent.key !== node; + case "TSEnumMember": + return parent.id !== node; + case "TSPropertySignature": + if (parent.key === node) { + return !!parent.computed; + } + return true; + } + return true; +} + +//# sourceMappingURL=isReferenced.js.map + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509097, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isScope; +var _index = require("./generated/index.js"); +function isScope(node, parent) { + if ((0, _index.isBlockStatement)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) { + return false; + } + if ((0, _index.isPattern)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) { + return true; + } + return (0, _index.isScopable)(node); +} + +//# sourceMappingURL=isScope.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509098, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isSpecifierDefault; +var _index = require("./generated/index.js"); +function isSpecifierDefault(specifier) { + return (0, _index.isImportDefaultSpecifier)(specifier) || (0, _index.isIdentifier)(specifier.imported || specifier.exported, { + name: "default" + }); +} + +//# sourceMappingURL=isSpecifierDefault.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509099, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isValidES3Identifier; +var _isValidIdentifier = require("./isValidIdentifier.js"); +const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]); +function isValidES3Identifier(name) { + return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name); +} + +//# sourceMappingURL=isValidES3Identifier.js.map + +}, function(modId) { var map = {"./isValidIdentifier.js":1771034509037}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509100, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = isVar; +var _index = require("./generated/index.js"); +var BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); +function isVar(node) { + return (0, _index.isVariableDeclaration)(node, { + kind: "var" + }) && !node[BLOCK_SCOPED_SYMBOL]; +} + +//# sourceMappingURL=isVar.js.map + +}, function(modId) { var map = {"./generated/index.js":1771034509023}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509101, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = toSequenceExpression; +var _gatherSequenceExpressions = require("./gatherSequenceExpressions.js"); +function toSequenceExpression(nodes, scope) { + if (!(nodes != null && nodes.length)) return; + const declars = []; + const result = (0, _gatherSequenceExpressions.default)(nodes, declars); + if (!result) return; + for (const declar of declars) { + scope.push(declar); + } + return result; +} + +//# sourceMappingURL=toSequenceExpression.js.map + +}, function(modId) { var map = {"./gatherSequenceExpressions.js":1771034509102}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509102, function(require, module, exports) { + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = gatherSequenceExpressions; +var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers.js"); +var _index = require("../validators/generated/index.js"); +var _index2 = require("../builders/generated/index.js"); +var _productions = require("../builders/productions.js"); +var _cloneNode = require("../clone/cloneNode.js"); +function gatherSequenceExpressions(nodes, declars) { + const exprs = []; + let ensureLastUndefined = true; + for (const node of nodes) { + if (!(0, _index.isEmptyStatement)(node)) { + ensureLastUndefined = false; + } + if ((0, _index.isExpression)(node)) { + exprs.push(node); + } else if ((0, _index.isExpressionStatement)(node)) { + exprs.push(node.expression); + } else if ((0, _index.isVariableDeclaration)(node)) { + if (node.kind !== "var") return; + for (const declar of node.declarations) { + const bindings = (0, _getBindingIdentifiers.default)(declar); + for (const key of Object.keys(bindings)) { + declars.push({ + kind: node.kind, + id: (0, _cloneNode.default)(bindings[key]) + }); + } + if (declar.init) { + exprs.push((0, _index2.assignmentExpression)("=", declar.id, declar.init)); + } + } + ensureLastUndefined = true; + } else if ((0, _index.isIfStatement)(node)) { + const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : (0, _productions.buildUndefinedNode)(); + const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : (0, _productions.buildUndefinedNode)(); + if (!consequent || !alternate) return; + exprs.push((0, _index2.conditionalExpression)(node.test, consequent, alternate)); + } else if ((0, _index.isBlockStatement)(node)) { + const body = gatherSequenceExpressions(node.body, declars); + if (!body) return; + exprs.push(body); + } else if ((0, _index.isEmptyStatement)(node)) { + if (nodes.indexOf(node) === 0) { + ensureLastUndefined = true; + } + } else { + return; + } + } + if (ensureLastUndefined) { + exprs.push((0, _productions.buildUndefinedNode)()); + } + if (exprs.length === 1) { + return exprs[0]; + } else { + return (0, _index2.sequenceExpression)(exprs); + } +} + +//# sourceMappingURL=gatherSequenceExpressions.js.map + +}, function(modId) { var map = {"../retrievers/getBindingIdentifiers.js":1771034509087,"../validators/generated/index.js":1771034509023,"../builders/generated/index.js":1771034509029,"../builders/productions.js":1771034509056,"../clone/cloneNode.js":1771034509057}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509019); +})() +//miniprogram-npm-outsideDeps=["@babel/helper-validator-identifier","@babel/helper-string-parser"] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@babel/types/index.js.map b/miniapp/miniprogram_npm/@babel/types/index.js.map new file mode 100644 index 0000000..a8bc978 --- /dev/null +++ b/miniapp/miniprogram_npm/@babel/types/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js","validators/react/isReactComponent.js","validators/buildMatchMemberExpression.js","validators/matchesPattern.js","validators/generated/index.js","utils/shallowEqual.js","utils/deprecationWarning.js","validators/react/isCompatTag.js","builders/react/buildChildren.js","utils/react/cleanJSXElementLiteralChild.js","builders/generated/index.js","builders/generated/lowercase.js","validators/validate.js","definitions/index.js","definitions/core.js","validators/is.js","validators/isType.js","validators/isPlaceholderType.js","validators/isValidIdentifier.js","constants/index.js","definitions/utils.js","definitions/flow.js","definitions/jsx.js","definitions/misc.js","definitions/placeholders.js","definitions/experimental.js","definitions/typescript.js","definitions/deprecated-aliases.js","builders/generated/uppercase.js","asserts/assertNode.js","validators/isNode.js","asserts/generated/index.js","builders/flow/createTypeAnnotationBasedOnTypeof.js","builders/flow/createFlowUnionType.js","modifications/flow/removeTypeDuplicates.js","builders/typescript/createTSUnionType.js","modifications/typescript/removeTypeDuplicates.js","builders/productions.js","clone/cloneNode.js","clone/clone.js","clone/cloneDeep.js","clone/cloneDeepWithoutLoc.js","clone/cloneWithoutLoc.js","comments/addComment.js","comments/addComments.js","comments/inheritInnerComments.js","utils/inherit.js","comments/inheritLeadingComments.js","comments/inheritsComments.js","comments/inheritTrailingComments.js","comments/removeComments.js","constants/generated/index.js","converters/ensureBlock.js","converters/toBlock.js","converters/toBindingIdentifierName.js","converters/toIdentifier.js","converters/toComputedKey.js","converters/toExpression.js","converters/toKeyAlias.js","modifications/removePropertiesDeep.js","traverse/traverseFast.js","modifications/removeProperties.js","converters/toStatement.js","converters/valueToNode.js","modifications/appendToMemberExpression.js","modifications/inherits.js","modifications/prependToMemberExpression.js","retrievers/getAssignmentIdentifiers.js","retrievers/getBindingIdentifiers.js","retrievers/getOuterBindingIdentifiers.js","retrievers/getFunctionName.js","traverse/traverse.js","validators/isBinding.js","validators/isBlockScoped.js","validators/isLet.js","validators/isImmutable.js","validators/isNodesEquivalent.js","validators/isReferenced.js","validators/isScope.js","validators/isSpecifierDefault.js","validators/isValidES3Identifier.js","validators/isVar.js","converters/toSequenceExpression.js","converters/gatherSequenceExpressions.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA,ACHA;ADIA,ACHA;ADIA,ACHA;ADIA,AENA,ADGA;ADIA,AENA,ADGA;ADIA,AENA,ADGA;ADIA,AENA,ACHA,AFMA;ADIA,AENA,ACHA,AFMA;ADIA,AENA,ACHA,AFMA;ADIA,AENA,AENA,ADGA,AFMA;ADIA,AENA,AENA,ADGA,AFMA;ADIA,AENA,AENA,ADGA,AFMA;ADIA,AKfA,AHSA,AENA,ADGA;AHUA,AKfA,AHSA,AENA,ADGA;AHUA,AKfA,AHSA,AENA,ADGA;AHUA,AMlBA,ADGA,AHSA,AENA,ADGA;AHUA,AMlBA,ADGA,AHSA,AENA,ADGA;AHUA,AMlBA,ADGA,ADGA,ADGA;AHUA,AMlBA,ADGA,ADGA,ADGA,AIZA;APsBA,AMlBA,ADGA,ADGA,ADGA,AIZA;APsBA,AMlBA,ADGA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,ADGA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,ADGA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,ADGA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;ACFA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;AGRA,AFMA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;AGRA,AFMA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;AGRA,AFMA,ARwBA,AMlBA,AGTA,AJYA,ADGA,ADGA,AIZA;AGRA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA;AOpBA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA;AOpBA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA;AOpBA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,ARwBA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AKfA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AKfA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AKfA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,ADGA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AZoCA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AZoCA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AZoCA,AS3BA;AFOA,ACHA,AHSA,AMlBA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,ACHA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,ACHA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,ACHA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AbuCA,AS3BA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;AFOA,ACHA,AGTA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;AFOA,ACHA,AQxBA,ALeA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;AFOA,ACHA,AQxBA,ALeA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;AFOA,ACHA,AQxBA,ALeA,ADGA,AbuCA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,ADGA,AOrBA,ApB4DA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,ADGA,AOrBA,ApB4DA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,ADGA,AOrBA,ApB4DA,AMlBA,AGTA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AOrBA,ApB4DA,AS3BA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AOrBA,ApB4DA,AS3BA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AOrBA,ApB4DA,AS3BA,ALeA,AWjCA,AENA,ADGA,AENA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,AFMA,ApB4DA,AS3BA,ALeA,AWjCA,AENA,ACHA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,AFMA,ApB4DA,AS3BA,ALeA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,AFMA,ApB4DA,AIZA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,AHSA,ApB4DA,AIZA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,AHSA,ApB4DA,AIZA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,AHSA,ApB4DA,AIZA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AWjCA,AGTA,ANkBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AOrBA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AJYA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,AQxBA;ADIA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AQxBA,ALeA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AQxBA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AQxBA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AQxBA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AiBnDA,AT2BA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AiBnDA,AT2BA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AOpBA,AiBnDA,AT2BA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AyB1EA,AlBsDA,AiBnDA,AT2BA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AyB1EA,AlBsDA,AiBnDA,AT2BA,ALeA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AyB1EA,AlBsDA,AiBnDA,Ad0CA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA;AyB1EA,AlBsDA,AiBnDA,Ad0CA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AlBsDA,AiBnDA,Ad0CA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AlBsDA,AiBnDA,Ad0CA,AavCA,AFMA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ApB4DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ApB4DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ApB4DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ACHA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ACHA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,ACHA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,ACHA,AENA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,ACHA,AGTA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AIZA,A0B9EA;ADIA,AENA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA,A0B9EA;ADIA,AENA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,Ad0CA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,A9B0FA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AOrBA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,ArB+DA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,AGTA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,AGTA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,AGTA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,AENA,ADGA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ADGA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ADGA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ADGA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ACHA,AFMA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ACHA,AFMA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ACHA,AFMA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AS3BA,AFMA,AIZA,ACHA,ACHA,AHSA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AOrBA,AIZA,ACHA,ACHA,AHSA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AOrBA,AIZA,ACHA,ACHA,AHSA,AxBwEA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AOrBA,AIZA,ACHA,ACHA,AHSA,AIZA,A5BoFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ACHA,ArB+DA,AiBnDA,AOrBA,AIZA,ACHA,ACHA,AHSA,AIZA,A5BoFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AWjCA,ACHA,ACHA,AHSA,AIZA,A5BoFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AWjCA,ACHA,ACHA,AHSA,AIZA,ACHA,A7BuFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AYpCA,ACHA,AHSA,AIZA,ACHA,A7BuFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AYpCA,ACHA,AHSA,AIZA,ACHA,A7BuFA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AYpCA,ACHA,AHSA,AIZA,ACHA,ACHA,A9B0FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AavCA,AHSA,AIZA,ACHA,ACHA,A9B0FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AavCA,AHSA,AIZA,ACHA,ACHA,A9B0FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AavCA,AHSA,AIZA,ACHA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AIZA,ACHA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AIZA,ACHA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AIZA,ACHA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,A/B6FA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,AENA,AjCmGA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,AENA,AjCmGA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,AENA,AjCmGA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AKfA,ACHA,ACHA,AENA,ACHA,AlCsGA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,ACHA,AENA,ACHA,AlCsGA,AWjCA,AJYA,ARwBA,AS3BA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,ACHA,AENA,ACHA,AlCsGA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,ACHA,AENA,AENA,ADGA,AlCsGA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AlCsGA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AlCsGA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AENA,ApC4GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AENA,ApC4GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AU9BA,A1C8HA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AENA,ApC4GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AGTA,AENA,ADGA,AENA,ACHA,ArC+GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AMlBA,AKfA,ADGA,AENA,ACHA,ArC+GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AWjCA,ADGA,AENA,ACHA,ArC+GA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AWjCA,ADGA,AENA,ACHA,ACHA,AtCkHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AWjCA,ADGA,AENA,ACHA,ACHA,AtCkHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AWjCA,ADGA,AENA,ACHA,ACHA,AtCkHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AWjCA,ADGA,AENA,ACHA,ACHA,ACHA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AU9BA,AENA,ACHA,ACHA,ACHA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AU9BA,AENA,ACHA,ACHA,ACHA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AYpCA,ACHA,ACHA,AENA,ADGA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AYpCA,ACHA,ACHA,AENA,ADGA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AYpCA,ACHA,ACHA,AENA,ADGA,AvCqHA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AYpCA,ACHA,ACHA,AENA,ADGA,AENA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,ACHA,AENA,ADGA,AENA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,ACHA,AENA,ADGA,AENA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AkCtGA,AENA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,ACHA,AENA,ADGA,AGTA,ADGA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,ACHA,AENA,ADGA,AGTA,ADGA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,ACHA,AENA,ADGA,AGTA,ADGA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AzC2HA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AoC5GA,AhCgGA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AGTA,ADGA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,AvDqKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,AvDqKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,AvDqKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AGTA,ACHA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A2DjLA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,A5CoIA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,AIZA,AhDgJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,AIZA,AhDgJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AENA,AIZA,AFMA,AGTA,AIZA,AhDgJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,AFMA,AGTA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,AFMA,AGTA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,A6DvLA,AFMA,ACHA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,AHSA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,AHSA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,AHSA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,AJYA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,AJYA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,AJYA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AMlBA,ACHA,AIZA,ACHA,AjDmJA,AWjCA,AJYA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,ADGA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,APqBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,APqBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,APqBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,ACHA,ARwBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,ACHA,ARwBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,ACHA,ARwBA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AgEhMA,ACHA,ACHA,ALeA,AMlBA,ACHA,ACHA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,ACHA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,ACHA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AOrBA,AIZA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AT2BA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AavCA,AWjCA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,ACHA,ACHA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA;A2BhFA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA,AoE5MA;AzC4HA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA,AoE5MA;AzC4HA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA,AoE5MA;AzC4HA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA,AoE5MA,ACHA;A1C+HA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ADGA,AENA,AXiCA,AxDwKA,AoE5MA,ACHA;A1C+HA,ApB4DA,AiBnDA,AU9BA,AwBxEA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA;A1C+HA,ApB4DA,AiBnDA,AkCtGA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,ACHA;A3CkIA,ApB4DA,AiBnDA,AkCtGA,ACHA,AjDmJA,AOrBA,ACHA,AIZA,ANkBA,ApB4DA,AiEnMA,AENA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,ACHA;A3CkIA,ApB4DA,AiBnDA,AkCtGA,ACHA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,ACHA;A3CkIA,ApB4DA,AiBnDA,AkCtGA,ACHA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA;A3CkIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA;A3CkIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA;A3CkIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA,AENA;A7CwIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA,AENA;A7CwIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA,AENA;A7CwIA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA,AENA,ACHA;A9C2IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,ACHA,AENA,ADGA,AENA,ACHA;A9C2IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ADGA,AENA,ACHA;A9C2IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ADGA,AENA,ACHA,ACHA;A/C8IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ADGA,AENA,ACHA,ACHA;A/C8IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA;A/C8IA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA;AhDiJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA;AhDiJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA;AhDiJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA,ACHA;AjDoJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA,ACHA;AjDoJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA,ACHA;AjDoJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AoE5MA,AGTA,ACHA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AuErNA,ACHA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AmCzGA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AuErNA,ACHA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AsDlKA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AuErNA,ACHA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AsDlKA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AsDlKA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AmEzMA,ACHA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,ACHA,ACHA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,ACHA,AENA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AGTA,ACHA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AIZA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AIZA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AIZA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AIZA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA,AIZA;AlDuJA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,ACHA,AnEyMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ADGA,AnByDA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AENA,AlEsMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ApB4DA,AjDmJA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AwExNA,ACHA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AoE5MA,AhEgMA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,AuDrKA,ArE+MA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA,AyE3NA;A9C2IA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AiBnDA,Ad0CA,AOrBA,AKfA,ANkBA,ApB4DA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AOrBA,AKfA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,A1B8EA,AIZA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AYpCA,AtBkEA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;A2BhFA,ApB4DA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,AGTA,AV8BA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA,APqBA;AOpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nvar _exportNames = {\n react: true,\n assertNode: true,\n createTypeAnnotationBasedOnTypeof: true,\n createUnionTypeAnnotation: true,\n createFlowUnionType: true,\n createTSUnionType: true,\n cloneNode: true,\n clone: true,\n cloneDeep: true,\n cloneDeepWithoutLoc: true,\n cloneWithoutLoc: true,\n addComment: true,\n addComments: true,\n inheritInnerComments: true,\n inheritLeadingComments: true,\n inheritsComments: true,\n inheritTrailingComments: true,\n removeComments: true,\n ensureBlock: true,\n toBindingIdentifierName: true,\n toBlock: true,\n toComputedKey: true,\n toExpression: true,\n toIdentifier: true,\n toKeyAlias: true,\n toStatement: true,\n valueToNode: true,\n appendToMemberExpression: true,\n inherits: true,\n prependToMemberExpression: true,\n removeProperties: true,\n removePropertiesDeep: true,\n removeTypeDuplicates: true,\n getAssignmentIdentifiers: true,\n getBindingIdentifiers: true,\n getOuterBindingIdentifiers: true,\n getFunctionName: true,\n traverse: true,\n traverseFast: true,\n shallowEqual: true,\n is: true,\n isBinding: true,\n isBlockScoped: true,\n isImmutable: true,\n isLet: true,\n isNode: true,\n isNodesEquivalent: true,\n isPlaceholderType: true,\n isReferenced: true,\n isScope: true,\n isSpecifierDefault: true,\n isType: true,\n isValidES3Identifier: true,\n isValidIdentifier: true,\n isVar: true,\n matchesPattern: true,\n validate: true,\n buildMatchMemberExpression: true,\n __internal__deprecationWarning: true\n};\nObject.defineProperty(exports, \"__internal__deprecationWarning\", {\n enumerable: true,\n get: function () {\n return _deprecationWarning.default;\n }\n});\nObject.defineProperty(exports, \"addComment\", {\n enumerable: true,\n get: function () {\n return _addComment.default;\n }\n});\nObject.defineProperty(exports, \"addComments\", {\n enumerable: true,\n get: function () {\n return _addComments.default;\n }\n});\nObject.defineProperty(exports, \"appendToMemberExpression\", {\n enumerable: true,\n get: function () {\n return _appendToMemberExpression.default;\n }\n});\nObject.defineProperty(exports, \"assertNode\", {\n enumerable: true,\n get: function () {\n return _assertNode.default;\n }\n});\nObject.defineProperty(exports, \"buildMatchMemberExpression\", {\n enumerable: true,\n get: function () {\n return _buildMatchMemberExpression.default;\n }\n});\nObject.defineProperty(exports, \"clone\", {\n enumerable: true,\n get: function () {\n return _clone.default;\n }\n});\nObject.defineProperty(exports, \"cloneDeep\", {\n enumerable: true,\n get: function () {\n return _cloneDeep.default;\n }\n});\nObject.defineProperty(exports, \"cloneDeepWithoutLoc\", {\n enumerable: true,\n get: function () {\n return _cloneDeepWithoutLoc.default;\n }\n});\nObject.defineProperty(exports, \"cloneNode\", {\n enumerable: true,\n get: function () {\n return _cloneNode.default;\n }\n});\nObject.defineProperty(exports, \"cloneWithoutLoc\", {\n enumerable: true,\n get: function () {\n return _cloneWithoutLoc.default;\n }\n});\nObject.defineProperty(exports, \"createFlowUnionType\", {\n enumerable: true,\n get: function () {\n return _createFlowUnionType.default;\n }\n});\nObject.defineProperty(exports, \"createTSUnionType\", {\n enumerable: true,\n get: function () {\n return _createTSUnionType.default;\n }\n});\nObject.defineProperty(exports, \"createTypeAnnotationBasedOnTypeof\", {\n enumerable: true,\n get: function () {\n return _createTypeAnnotationBasedOnTypeof.default;\n }\n});\nObject.defineProperty(exports, \"createUnionTypeAnnotation\", {\n enumerable: true,\n get: function () {\n return _createFlowUnionType.default;\n }\n});\nObject.defineProperty(exports, \"ensureBlock\", {\n enumerable: true,\n get: function () {\n return _ensureBlock.default;\n }\n});\nObject.defineProperty(exports, \"getAssignmentIdentifiers\", {\n enumerable: true,\n get: function () {\n return _getAssignmentIdentifiers.default;\n }\n});\nObject.defineProperty(exports, \"getBindingIdentifiers\", {\n enumerable: true,\n get: function () {\n return _getBindingIdentifiers.default;\n }\n});\nObject.defineProperty(exports, \"getFunctionName\", {\n enumerable: true,\n get: function () {\n return _getFunctionName.default;\n }\n});\nObject.defineProperty(exports, \"getOuterBindingIdentifiers\", {\n enumerable: true,\n get: function () {\n return _getOuterBindingIdentifiers.default;\n }\n});\nObject.defineProperty(exports, \"inheritInnerComments\", {\n enumerable: true,\n get: function () {\n return _inheritInnerComments.default;\n }\n});\nObject.defineProperty(exports, \"inheritLeadingComments\", {\n enumerable: true,\n get: function () {\n return _inheritLeadingComments.default;\n }\n});\nObject.defineProperty(exports, \"inheritTrailingComments\", {\n enumerable: true,\n get: function () {\n return _inheritTrailingComments.default;\n }\n});\nObject.defineProperty(exports, \"inherits\", {\n enumerable: true,\n get: function () {\n return _inherits.default;\n }\n});\nObject.defineProperty(exports, \"inheritsComments\", {\n enumerable: true,\n get: function () {\n return _inheritsComments.default;\n }\n});\nObject.defineProperty(exports, \"is\", {\n enumerable: true,\n get: function () {\n return _is.default;\n }\n});\nObject.defineProperty(exports, \"isBinding\", {\n enumerable: true,\n get: function () {\n return _isBinding.default;\n }\n});\nObject.defineProperty(exports, \"isBlockScoped\", {\n enumerable: true,\n get: function () {\n return _isBlockScoped.default;\n }\n});\nObject.defineProperty(exports, \"isImmutable\", {\n enumerable: true,\n get: function () {\n return _isImmutable.default;\n }\n});\nObject.defineProperty(exports, \"isLet\", {\n enumerable: true,\n get: function () {\n return _isLet.default;\n }\n});\nObject.defineProperty(exports, \"isNode\", {\n enumerable: true,\n get: function () {\n return _isNode.default;\n }\n});\nObject.defineProperty(exports, \"isNodesEquivalent\", {\n enumerable: true,\n get: function () {\n return _isNodesEquivalent.default;\n }\n});\nObject.defineProperty(exports, \"isPlaceholderType\", {\n enumerable: true,\n get: function () {\n return _isPlaceholderType.default;\n }\n});\nObject.defineProperty(exports, \"isReferenced\", {\n enumerable: true,\n get: function () {\n return _isReferenced.default;\n }\n});\nObject.defineProperty(exports, \"isScope\", {\n enumerable: true,\n get: function () {\n return _isScope.default;\n }\n});\nObject.defineProperty(exports, \"isSpecifierDefault\", {\n enumerable: true,\n get: function () {\n return _isSpecifierDefault.default;\n }\n});\nObject.defineProperty(exports, \"isType\", {\n enumerable: true,\n get: function () {\n return _isType.default;\n }\n});\nObject.defineProperty(exports, \"isValidES3Identifier\", {\n enumerable: true,\n get: function () {\n return _isValidES3Identifier.default;\n }\n});\nObject.defineProperty(exports, \"isValidIdentifier\", {\n enumerable: true,\n get: function () {\n return _isValidIdentifier.default;\n }\n});\nObject.defineProperty(exports, \"isVar\", {\n enumerable: true,\n get: function () {\n return _isVar.default;\n }\n});\nObject.defineProperty(exports, \"matchesPattern\", {\n enumerable: true,\n get: function () {\n return _matchesPattern.default;\n }\n});\nObject.defineProperty(exports, \"prependToMemberExpression\", {\n enumerable: true,\n get: function () {\n return _prependToMemberExpression.default;\n }\n});\nexports.react = void 0;\nObject.defineProperty(exports, \"removeComments\", {\n enumerable: true,\n get: function () {\n return _removeComments.default;\n }\n});\nObject.defineProperty(exports, \"removeProperties\", {\n enumerable: true,\n get: function () {\n return _removeProperties.default;\n }\n});\nObject.defineProperty(exports, \"removePropertiesDeep\", {\n enumerable: true,\n get: function () {\n return _removePropertiesDeep.default;\n }\n});\nObject.defineProperty(exports, \"removeTypeDuplicates\", {\n enumerable: true,\n get: function () {\n return _removeTypeDuplicates.default;\n }\n});\nObject.defineProperty(exports, \"shallowEqual\", {\n enumerable: true,\n get: function () {\n return _shallowEqual.default;\n }\n});\nObject.defineProperty(exports, \"toBindingIdentifierName\", {\n enumerable: true,\n get: function () {\n return _toBindingIdentifierName.default;\n }\n});\nObject.defineProperty(exports, \"toBlock\", {\n enumerable: true,\n get: function () {\n return _toBlock.default;\n }\n});\nObject.defineProperty(exports, \"toComputedKey\", {\n enumerable: true,\n get: function () {\n return _toComputedKey.default;\n }\n});\nObject.defineProperty(exports, \"toExpression\", {\n enumerable: true,\n get: function () {\n return _toExpression.default;\n }\n});\nObject.defineProperty(exports, \"toIdentifier\", {\n enumerable: true,\n get: function () {\n return _toIdentifier.default;\n }\n});\nObject.defineProperty(exports, \"toKeyAlias\", {\n enumerable: true,\n get: function () {\n return _toKeyAlias.default;\n }\n});\nObject.defineProperty(exports, \"toStatement\", {\n enumerable: true,\n get: function () {\n return _toStatement.default;\n }\n});\nObject.defineProperty(exports, \"traverse\", {\n enumerable: true,\n get: function () {\n return _traverse.default;\n }\n});\nObject.defineProperty(exports, \"traverseFast\", {\n enumerable: true,\n get: function () {\n return _traverseFast.default;\n }\n});\nObject.defineProperty(exports, \"validate\", {\n enumerable: true,\n get: function () {\n return _validate.default;\n }\n});\nObject.defineProperty(exports, \"valueToNode\", {\n enumerable: true,\n get: function () {\n return _valueToNode.default;\n }\n});\nvar _isReactComponent = require(\"./validators/react/isReactComponent.js\");\nvar _isCompatTag = require(\"./validators/react/isCompatTag.js\");\nvar _buildChildren = require(\"./builders/react/buildChildren.js\");\nvar _assertNode = require(\"./asserts/assertNode.js\");\nvar _index = require(\"./asserts/generated/index.js\");\nObject.keys(_index).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index[key];\n }\n });\n});\nvar _createTypeAnnotationBasedOnTypeof = require(\"./builders/flow/createTypeAnnotationBasedOnTypeof.js\");\nvar _createFlowUnionType = require(\"./builders/flow/createFlowUnionType.js\");\nvar _createTSUnionType = require(\"./builders/typescript/createTSUnionType.js\");\nvar _productions = require(\"./builders/productions.js\");\nObject.keys(_productions).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _productions[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _productions[key];\n }\n });\n});\nvar _index2 = require(\"./builders/generated/index.js\");\nObject.keys(_index2).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index2[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index2[key];\n }\n });\n});\nvar _cloneNode = require(\"./clone/cloneNode.js\");\nvar _clone = require(\"./clone/clone.js\");\nvar _cloneDeep = require(\"./clone/cloneDeep.js\");\nvar _cloneDeepWithoutLoc = require(\"./clone/cloneDeepWithoutLoc.js\");\nvar _cloneWithoutLoc = require(\"./clone/cloneWithoutLoc.js\");\nvar _addComment = require(\"./comments/addComment.js\");\nvar _addComments = require(\"./comments/addComments.js\");\nvar _inheritInnerComments = require(\"./comments/inheritInnerComments.js\");\nvar _inheritLeadingComments = require(\"./comments/inheritLeadingComments.js\");\nvar _inheritsComments = require(\"./comments/inheritsComments.js\");\nvar _inheritTrailingComments = require(\"./comments/inheritTrailingComments.js\");\nvar _removeComments = require(\"./comments/removeComments.js\");\nvar _index3 = require(\"./constants/generated/index.js\");\nObject.keys(_index3).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index3[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index3[key];\n }\n });\n});\nvar _index4 = require(\"./constants/index.js\");\nObject.keys(_index4).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index4[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index4[key];\n }\n });\n});\nvar _ensureBlock = require(\"./converters/ensureBlock.js\");\nvar _toBindingIdentifierName = require(\"./converters/toBindingIdentifierName.js\");\nvar _toBlock = require(\"./converters/toBlock.js\");\nvar _toComputedKey = require(\"./converters/toComputedKey.js\");\nvar _toExpression = require(\"./converters/toExpression.js\");\nvar _toIdentifier = require(\"./converters/toIdentifier.js\");\nvar _toKeyAlias = require(\"./converters/toKeyAlias.js\");\nvar _toStatement = require(\"./converters/toStatement.js\");\nvar _valueToNode = require(\"./converters/valueToNode.js\");\nvar _index5 = require(\"./definitions/index.js\");\nObject.keys(_index5).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index5[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index5[key];\n }\n });\n});\nvar _appendToMemberExpression = require(\"./modifications/appendToMemberExpression.js\");\nvar _inherits = require(\"./modifications/inherits.js\");\nvar _prependToMemberExpression = require(\"./modifications/prependToMemberExpression.js\");\nvar _removeProperties = require(\"./modifications/removeProperties.js\");\nvar _removePropertiesDeep = require(\"./modifications/removePropertiesDeep.js\");\nvar _removeTypeDuplicates = require(\"./modifications/flow/removeTypeDuplicates.js\");\nvar _getAssignmentIdentifiers = require(\"./retrievers/getAssignmentIdentifiers.js\");\nvar _getBindingIdentifiers = require(\"./retrievers/getBindingIdentifiers.js\");\nvar _getOuterBindingIdentifiers = require(\"./retrievers/getOuterBindingIdentifiers.js\");\nvar _getFunctionName = require(\"./retrievers/getFunctionName.js\");\nvar _traverse = require(\"./traverse/traverse.js\");\nObject.keys(_traverse).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _traverse[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _traverse[key];\n }\n });\n});\nvar _traverseFast = require(\"./traverse/traverseFast.js\");\nvar _shallowEqual = require(\"./utils/shallowEqual.js\");\nvar _is = require(\"./validators/is.js\");\nvar _isBinding = require(\"./validators/isBinding.js\");\nvar _isBlockScoped = require(\"./validators/isBlockScoped.js\");\nvar _isImmutable = require(\"./validators/isImmutable.js\");\nvar _isLet = require(\"./validators/isLet.js\");\nvar _isNode = require(\"./validators/isNode.js\");\nvar _isNodesEquivalent = require(\"./validators/isNodesEquivalent.js\");\nvar _isPlaceholderType = require(\"./validators/isPlaceholderType.js\");\nvar _isReferenced = require(\"./validators/isReferenced.js\");\nvar _isScope = require(\"./validators/isScope.js\");\nvar _isSpecifierDefault = require(\"./validators/isSpecifierDefault.js\");\nvar _isType = require(\"./validators/isType.js\");\nvar _isValidES3Identifier = require(\"./validators/isValidES3Identifier.js\");\nvar _isValidIdentifier = require(\"./validators/isValidIdentifier.js\");\nvar _isVar = require(\"./validators/isVar.js\");\nvar _matchesPattern = require(\"./validators/matchesPattern.js\");\nvar _validate = require(\"./validators/validate.js\");\nvar _buildMatchMemberExpression = require(\"./validators/buildMatchMemberExpression.js\");\nvar _index6 = require(\"./validators/generated/index.js\");\nObject.keys(_index6).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n if (key in exports && exports[key] === _index6[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _index6[key];\n }\n });\n});\nvar _deprecationWarning = require(\"./utils/deprecationWarning.js\");\nvar _toSequenceExpression = require(\"./converters/toSequenceExpression.js\");\nconst react = exports.react = {\n isReactComponent: _isReactComponent.default,\n isCompatTag: _isCompatTag.default,\n buildChildren: _buildChildren.default\n};\nexports.toSequenceExpression = _toSequenceExpression.default;\nif (process.env.BABEL_TYPES_8_BREAKING) {\n console.warn(\"BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!\");\n}\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _buildMatchMemberExpression = require(\"../buildMatchMemberExpression.js\");\nconst isReactComponent = (0, _buildMatchMemberExpression.default)(\"React.Component\");\nvar _default = exports.default = isReactComponent;\n\n//# sourceMappingURL=isReactComponent.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = buildMatchMemberExpression;\nvar _matchesPattern = require(\"./matchesPattern.js\");\nfunction buildMatchMemberExpression(match, allowPartial) {\n const parts = match.split(\".\");\n return member => (0, _matchesPattern.default)(member, parts, allowPartial);\n}\n\n//# sourceMappingURL=buildMatchMemberExpression.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = matchesPattern;\nvar _index = require(\"./generated/index.js\");\nfunction isMemberExpressionLike(node) {\n return (0, _index.isMemberExpression)(node) || (0, _index.isMetaProperty)(node);\n}\nfunction matchesPattern(member, match, allowPartial) {\n if (!isMemberExpressionLike(member)) return false;\n const parts = Array.isArray(match) ? match : match.split(\".\");\n const nodes = [];\n let node;\n for (node = member; isMemberExpressionLike(node); node = (_object = node.object) != null ? _object : node.meta) {\n var _object;\n nodes.push(node.property);\n }\n nodes.push(node);\n if (nodes.length < parts.length) return false;\n if (!allowPartial && nodes.length > parts.length) return false;\n for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {\n const node = nodes[j];\n let value;\n if ((0, _index.isIdentifier)(node)) {\n value = node.name;\n } else if ((0, _index.isStringLiteral)(node)) {\n value = node.value;\n } else if ((0, _index.isThisExpression)(node)) {\n value = \"this\";\n } else if ((0, _index.isSuper)(node)) {\n value = \"super\";\n } else if ((0, _index.isPrivateName)(node)) {\n value = \"#\" + node.id.name;\n } else {\n return false;\n }\n if (parts[i] !== value) return false;\n }\n return true;\n}\n\n//# sourceMappingURL=matchesPattern.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isAccessor = isAccessor;\nexports.isAnyTypeAnnotation = isAnyTypeAnnotation;\nexports.isArgumentPlaceholder = isArgumentPlaceholder;\nexports.isArrayExpression = isArrayExpression;\nexports.isArrayPattern = isArrayPattern;\nexports.isArrayTypeAnnotation = isArrayTypeAnnotation;\nexports.isArrowFunctionExpression = isArrowFunctionExpression;\nexports.isAssignmentExpression = isAssignmentExpression;\nexports.isAssignmentPattern = isAssignmentPattern;\nexports.isAwaitExpression = isAwaitExpression;\nexports.isBigIntLiteral = isBigIntLiteral;\nexports.isBinary = isBinary;\nexports.isBinaryExpression = isBinaryExpression;\nexports.isBindExpression = isBindExpression;\nexports.isBlock = isBlock;\nexports.isBlockParent = isBlockParent;\nexports.isBlockStatement = isBlockStatement;\nexports.isBooleanLiteral = isBooleanLiteral;\nexports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;\nexports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;\nexports.isBreakStatement = isBreakStatement;\nexports.isCallExpression = isCallExpression;\nexports.isCatchClause = isCatchClause;\nexports.isClass = isClass;\nexports.isClassAccessorProperty = isClassAccessorProperty;\nexports.isClassBody = isClassBody;\nexports.isClassDeclaration = isClassDeclaration;\nexports.isClassExpression = isClassExpression;\nexports.isClassImplements = isClassImplements;\nexports.isClassMethod = isClassMethod;\nexports.isClassPrivateMethod = isClassPrivateMethod;\nexports.isClassPrivateProperty = isClassPrivateProperty;\nexports.isClassProperty = isClassProperty;\nexports.isCompletionStatement = isCompletionStatement;\nexports.isConditional = isConditional;\nexports.isConditionalExpression = isConditionalExpression;\nexports.isContinueStatement = isContinueStatement;\nexports.isDebuggerStatement = isDebuggerStatement;\nexports.isDecimalLiteral = isDecimalLiteral;\nexports.isDeclaration = isDeclaration;\nexports.isDeclareClass = isDeclareClass;\nexports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;\nexports.isDeclareExportDeclaration = isDeclareExportDeclaration;\nexports.isDeclareFunction = isDeclareFunction;\nexports.isDeclareInterface = isDeclareInterface;\nexports.isDeclareModule = isDeclareModule;\nexports.isDeclareModuleExports = isDeclareModuleExports;\nexports.isDeclareOpaqueType = isDeclareOpaqueType;\nexports.isDeclareTypeAlias = isDeclareTypeAlias;\nexports.isDeclareVariable = isDeclareVariable;\nexports.isDeclaredPredicate = isDeclaredPredicate;\nexports.isDecorator = isDecorator;\nexports.isDirective = isDirective;\nexports.isDirectiveLiteral = isDirectiveLiteral;\nexports.isDoExpression = isDoExpression;\nexports.isDoWhileStatement = isDoWhileStatement;\nexports.isEmptyStatement = isEmptyStatement;\nexports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;\nexports.isEnumBody = isEnumBody;\nexports.isEnumBooleanBody = isEnumBooleanBody;\nexports.isEnumBooleanMember = isEnumBooleanMember;\nexports.isEnumDeclaration = isEnumDeclaration;\nexports.isEnumDefaultedMember = isEnumDefaultedMember;\nexports.isEnumMember = isEnumMember;\nexports.isEnumNumberBody = isEnumNumberBody;\nexports.isEnumNumberMember = isEnumNumberMember;\nexports.isEnumStringBody = isEnumStringBody;\nexports.isEnumStringMember = isEnumStringMember;\nexports.isEnumSymbolBody = isEnumSymbolBody;\nexports.isExistsTypeAnnotation = isExistsTypeAnnotation;\nexports.isExportAllDeclaration = isExportAllDeclaration;\nexports.isExportDeclaration = isExportDeclaration;\nexports.isExportDefaultDeclaration = isExportDefaultDeclaration;\nexports.isExportDefaultSpecifier = isExportDefaultSpecifier;\nexports.isExportNamedDeclaration = isExportNamedDeclaration;\nexports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;\nexports.isExportSpecifier = isExportSpecifier;\nexports.isExpression = isExpression;\nexports.isExpressionStatement = isExpressionStatement;\nexports.isExpressionWrapper = isExpressionWrapper;\nexports.isFile = isFile;\nexports.isFlow = isFlow;\nexports.isFlowBaseAnnotation = isFlowBaseAnnotation;\nexports.isFlowDeclaration = isFlowDeclaration;\nexports.isFlowPredicate = isFlowPredicate;\nexports.isFlowType = isFlowType;\nexports.isFor = isFor;\nexports.isForInStatement = isForInStatement;\nexports.isForOfStatement = isForOfStatement;\nexports.isForStatement = isForStatement;\nexports.isForXStatement = isForXStatement;\nexports.isFunction = isFunction;\nexports.isFunctionDeclaration = isFunctionDeclaration;\nexports.isFunctionExpression = isFunctionExpression;\nexports.isFunctionParameter = isFunctionParameter;\nexports.isFunctionParent = isFunctionParent;\nexports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;\nexports.isFunctionTypeParam = isFunctionTypeParam;\nexports.isGenericTypeAnnotation = isGenericTypeAnnotation;\nexports.isIdentifier = isIdentifier;\nexports.isIfStatement = isIfStatement;\nexports.isImmutable = isImmutable;\nexports.isImport = isImport;\nexports.isImportAttribute = isImportAttribute;\nexports.isImportDeclaration = isImportDeclaration;\nexports.isImportDefaultSpecifier = isImportDefaultSpecifier;\nexports.isImportExpression = isImportExpression;\nexports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;\nexports.isImportOrExportDeclaration = isImportOrExportDeclaration;\nexports.isImportSpecifier = isImportSpecifier;\nexports.isIndexedAccessType = isIndexedAccessType;\nexports.isInferredPredicate = isInferredPredicate;\nexports.isInterfaceDeclaration = isInterfaceDeclaration;\nexports.isInterfaceExtends = isInterfaceExtends;\nexports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;\nexports.isInterpreterDirective = isInterpreterDirective;\nexports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;\nexports.isJSX = isJSX;\nexports.isJSXAttribute = isJSXAttribute;\nexports.isJSXClosingElement = isJSXClosingElement;\nexports.isJSXClosingFragment = isJSXClosingFragment;\nexports.isJSXElement = isJSXElement;\nexports.isJSXEmptyExpression = isJSXEmptyExpression;\nexports.isJSXExpressionContainer = isJSXExpressionContainer;\nexports.isJSXFragment = isJSXFragment;\nexports.isJSXIdentifier = isJSXIdentifier;\nexports.isJSXMemberExpression = isJSXMemberExpression;\nexports.isJSXNamespacedName = isJSXNamespacedName;\nexports.isJSXOpeningElement = isJSXOpeningElement;\nexports.isJSXOpeningFragment = isJSXOpeningFragment;\nexports.isJSXSpreadAttribute = isJSXSpreadAttribute;\nexports.isJSXSpreadChild = isJSXSpreadChild;\nexports.isJSXText = isJSXText;\nexports.isLVal = isLVal;\nexports.isLabeledStatement = isLabeledStatement;\nexports.isLiteral = isLiteral;\nexports.isLogicalExpression = isLogicalExpression;\nexports.isLoop = isLoop;\nexports.isMemberExpression = isMemberExpression;\nexports.isMetaProperty = isMetaProperty;\nexports.isMethod = isMethod;\nexports.isMiscellaneous = isMiscellaneous;\nexports.isMixedTypeAnnotation = isMixedTypeAnnotation;\nexports.isModuleDeclaration = isModuleDeclaration;\nexports.isModuleExpression = isModuleExpression;\nexports.isModuleSpecifier = isModuleSpecifier;\nexports.isNewExpression = isNewExpression;\nexports.isNoop = isNoop;\nexports.isNullLiteral = isNullLiteral;\nexports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;\nexports.isNullableTypeAnnotation = isNullableTypeAnnotation;\nexports.isNumberLiteral = isNumberLiteral;\nexports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;\nexports.isNumberTypeAnnotation = isNumberTypeAnnotation;\nexports.isNumericLiteral = isNumericLiteral;\nexports.isObjectExpression = isObjectExpression;\nexports.isObjectMember = isObjectMember;\nexports.isObjectMethod = isObjectMethod;\nexports.isObjectPattern = isObjectPattern;\nexports.isObjectProperty = isObjectProperty;\nexports.isObjectTypeAnnotation = isObjectTypeAnnotation;\nexports.isObjectTypeCallProperty = isObjectTypeCallProperty;\nexports.isObjectTypeIndexer = isObjectTypeIndexer;\nexports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;\nexports.isObjectTypeProperty = isObjectTypeProperty;\nexports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;\nexports.isOpaqueType = isOpaqueType;\nexports.isOptionalCallExpression = isOptionalCallExpression;\nexports.isOptionalIndexedAccessType = isOptionalIndexedAccessType;\nexports.isOptionalMemberExpression = isOptionalMemberExpression;\nexports.isParenthesizedExpression = isParenthesizedExpression;\nexports.isPattern = isPattern;\nexports.isPatternLike = isPatternLike;\nexports.isPipelineBareFunction = isPipelineBareFunction;\nexports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;\nexports.isPipelineTopicExpression = isPipelineTopicExpression;\nexports.isPlaceholder = isPlaceholder;\nexports.isPrivate = isPrivate;\nexports.isPrivateName = isPrivateName;\nexports.isProgram = isProgram;\nexports.isProperty = isProperty;\nexports.isPureish = isPureish;\nexports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;\nexports.isRecordExpression = isRecordExpression;\nexports.isRegExpLiteral = isRegExpLiteral;\nexports.isRegexLiteral = isRegexLiteral;\nexports.isRestElement = isRestElement;\nexports.isRestProperty = isRestProperty;\nexports.isReturnStatement = isReturnStatement;\nexports.isScopable = isScopable;\nexports.isSequenceExpression = isSequenceExpression;\nexports.isSpreadElement = isSpreadElement;\nexports.isSpreadProperty = isSpreadProperty;\nexports.isStandardized = isStandardized;\nexports.isStatement = isStatement;\nexports.isStaticBlock = isStaticBlock;\nexports.isStringLiteral = isStringLiteral;\nexports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;\nexports.isStringTypeAnnotation = isStringTypeAnnotation;\nexports.isSuper = isSuper;\nexports.isSwitchCase = isSwitchCase;\nexports.isSwitchStatement = isSwitchStatement;\nexports.isSymbolTypeAnnotation = isSymbolTypeAnnotation;\nexports.isTSAnyKeyword = isTSAnyKeyword;\nexports.isTSArrayType = isTSArrayType;\nexports.isTSAsExpression = isTSAsExpression;\nexports.isTSBaseType = isTSBaseType;\nexports.isTSBigIntKeyword = isTSBigIntKeyword;\nexports.isTSBooleanKeyword = isTSBooleanKeyword;\nexports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;\nexports.isTSConditionalType = isTSConditionalType;\nexports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;\nexports.isTSConstructorType = isTSConstructorType;\nexports.isTSDeclareFunction = isTSDeclareFunction;\nexports.isTSDeclareMethod = isTSDeclareMethod;\nexports.isTSEntityName = isTSEntityName;\nexports.isTSEnumBody = isTSEnumBody;\nexports.isTSEnumDeclaration = isTSEnumDeclaration;\nexports.isTSEnumMember = isTSEnumMember;\nexports.isTSExportAssignment = isTSExportAssignment;\nexports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;\nexports.isTSExternalModuleReference = isTSExternalModuleReference;\nexports.isTSFunctionType = isTSFunctionType;\nexports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;\nexports.isTSImportType = isTSImportType;\nexports.isTSIndexSignature = isTSIndexSignature;\nexports.isTSIndexedAccessType = isTSIndexedAccessType;\nexports.isTSInferType = isTSInferType;\nexports.isTSInstantiationExpression = isTSInstantiationExpression;\nexports.isTSInterfaceBody = isTSInterfaceBody;\nexports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;\nexports.isTSIntersectionType = isTSIntersectionType;\nexports.isTSIntrinsicKeyword = isTSIntrinsicKeyword;\nexports.isTSLiteralType = isTSLiteralType;\nexports.isTSMappedType = isTSMappedType;\nexports.isTSMethodSignature = isTSMethodSignature;\nexports.isTSModuleBlock = isTSModuleBlock;\nexports.isTSModuleDeclaration = isTSModuleDeclaration;\nexports.isTSNamedTupleMember = isTSNamedTupleMember;\nexports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;\nexports.isTSNeverKeyword = isTSNeverKeyword;\nexports.isTSNonNullExpression = isTSNonNullExpression;\nexports.isTSNullKeyword = isTSNullKeyword;\nexports.isTSNumberKeyword = isTSNumberKeyword;\nexports.isTSObjectKeyword = isTSObjectKeyword;\nexports.isTSOptionalType = isTSOptionalType;\nexports.isTSParameterProperty = isTSParameterProperty;\nexports.isTSParenthesizedType = isTSParenthesizedType;\nexports.isTSPropertySignature = isTSPropertySignature;\nexports.isTSQualifiedName = isTSQualifiedName;\nexports.isTSRestType = isTSRestType;\nexports.isTSSatisfiesExpression = isTSSatisfiesExpression;\nexports.isTSStringKeyword = isTSStringKeyword;\nexports.isTSSymbolKeyword = isTSSymbolKeyword;\nexports.isTSTemplateLiteralType = isTSTemplateLiteralType;\nexports.isTSThisType = isTSThisType;\nexports.isTSTupleType = isTSTupleType;\nexports.isTSType = isTSType;\nexports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;\nexports.isTSTypeAnnotation = isTSTypeAnnotation;\nexports.isTSTypeAssertion = isTSTypeAssertion;\nexports.isTSTypeElement = isTSTypeElement;\nexports.isTSTypeLiteral = isTSTypeLiteral;\nexports.isTSTypeOperator = isTSTypeOperator;\nexports.isTSTypeParameter = isTSTypeParameter;\nexports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;\nexports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;\nexports.isTSTypePredicate = isTSTypePredicate;\nexports.isTSTypeQuery = isTSTypeQuery;\nexports.isTSTypeReference = isTSTypeReference;\nexports.isTSUndefinedKeyword = isTSUndefinedKeyword;\nexports.isTSUnionType = isTSUnionType;\nexports.isTSUnknownKeyword = isTSUnknownKeyword;\nexports.isTSVoidKeyword = isTSVoidKeyword;\nexports.isTaggedTemplateExpression = isTaggedTemplateExpression;\nexports.isTemplateElement = isTemplateElement;\nexports.isTemplateLiteral = isTemplateLiteral;\nexports.isTerminatorless = isTerminatorless;\nexports.isThisExpression = isThisExpression;\nexports.isThisTypeAnnotation = isThisTypeAnnotation;\nexports.isThrowStatement = isThrowStatement;\nexports.isTopicReference = isTopicReference;\nexports.isTryStatement = isTryStatement;\nexports.isTupleExpression = isTupleExpression;\nexports.isTupleTypeAnnotation = isTupleTypeAnnotation;\nexports.isTypeAlias = isTypeAlias;\nexports.isTypeAnnotation = isTypeAnnotation;\nexports.isTypeCastExpression = isTypeCastExpression;\nexports.isTypeParameter = isTypeParameter;\nexports.isTypeParameterDeclaration = isTypeParameterDeclaration;\nexports.isTypeParameterInstantiation = isTypeParameterInstantiation;\nexports.isTypeScript = isTypeScript;\nexports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;\nexports.isUnaryExpression = isUnaryExpression;\nexports.isUnaryLike = isUnaryLike;\nexports.isUnionTypeAnnotation = isUnionTypeAnnotation;\nexports.isUpdateExpression = isUpdateExpression;\nexports.isUserWhitespacable = isUserWhitespacable;\nexports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;\nexports.isVariableDeclaration = isVariableDeclaration;\nexports.isVariableDeclarator = isVariableDeclarator;\nexports.isVariance = isVariance;\nexports.isVoidPattern = isVoidPattern;\nexports.isVoidTypeAnnotation = isVoidTypeAnnotation;\nexports.isWhile = isWhile;\nexports.isWhileStatement = isWhileStatement;\nexports.isWithStatement = isWithStatement;\nexports.isYieldExpression = isYieldExpression;\nvar _shallowEqual = require(\"../../utils/shallowEqual.js\");\nvar _deprecationWarning = require(\"../../utils/deprecationWarning.js\");\nfunction isArrayExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ArrayExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isAssignmentExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"AssignmentExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBinaryExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"BinaryExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isInterpreterDirective(node, opts) {\n if (!node) return false;\n if (node.type !== \"InterpreterDirective\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDirective(node, opts) {\n if (!node) return false;\n if (node.type !== \"Directive\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDirectiveLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"DirectiveLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBlockStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"BlockStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBreakStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"BreakStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isCallExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"CallExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isCatchClause(node, opts) {\n if (!node) return false;\n if (node.type !== \"CatchClause\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isConditionalExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ConditionalExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isContinueStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ContinueStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDebuggerStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"DebuggerStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDoWhileStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"DoWhileStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEmptyStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"EmptyStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExpressionStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExpressionStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFile(node, opts) {\n if (!node) return false;\n if (node.type !== \"File\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isForInStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ForInStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isForStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ForStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"FunctionDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"FunctionExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isIdentifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"Identifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isIfStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"IfStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isLabeledStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"LabeledStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStringLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"StringLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNumericLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"NumericLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNullLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"NullLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBooleanLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"BooleanLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isRegExpLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"RegExpLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isLogicalExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"LogicalExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isMemberExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"MemberExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNewExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"NewExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isProgram(node, opts) {\n if (!node) return false;\n if (node.type !== \"Program\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectMethod(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectMethod\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isRestElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"RestElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isReturnStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ReturnStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSequenceExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"SequenceExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isParenthesizedExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ParenthesizedExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSwitchCase(node, opts) {\n if (!node) return false;\n if (node.type !== \"SwitchCase\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSwitchStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"SwitchStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isThisExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ThisExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isThrowStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ThrowStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTryStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"TryStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isUnaryExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"UnaryExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isUpdateExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"UpdateExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isVariableDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"VariableDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isVariableDeclarator(node, opts) {\n if (!node) return false;\n if (node.type !== \"VariableDeclarator\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isWhileStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"WhileStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isWithStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"WithStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isAssignmentPattern(node, opts) {\n if (!node) return false;\n if (node.type !== \"AssignmentPattern\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isArrayPattern(node, opts) {\n if (!node) return false;\n if (node.type !== \"ArrayPattern\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isArrowFunctionExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ArrowFunctionExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportAllDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportAllDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportDefaultDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportDefaultDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportNamedDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportNamedDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isForOfStatement(node, opts) {\n if (!node) return false;\n if (node.type !== \"ForOfStatement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportDefaultSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportDefaultSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportNamespaceSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportNamespaceSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isMetaProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"MetaProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassMethod(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassMethod\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectPattern(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectPattern\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSpreadElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"SpreadElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSuper(node, opts) {\n if (!node) return false;\n if (node.type !== \"Super\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTaggedTemplateExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TaggedTemplateExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTemplateElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"TemplateElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTemplateLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"TemplateLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isYieldExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"YieldExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isAwaitExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"AwaitExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImport(node, opts) {\n if (!node) return false;\n if (node.type !== \"Import\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBigIntLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"BigIntLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportNamespaceSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportNamespaceSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isOptionalMemberExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"OptionalMemberExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isOptionalCallExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"OptionalCallExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassAccessorProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassAccessorProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassPrivateProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassPrivateProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassPrivateMethod(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassPrivateMethod\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPrivateName(node, opts) {\n if (!node) return false;\n if (node.type !== \"PrivateName\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStaticBlock(node, opts) {\n if (!node) return false;\n if (node.type !== \"StaticBlock\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportAttribute(node, opts) {\n if (!node) return false;\n if (node.type !== \"ImportAttribute\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isAnyTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"AnyTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isArrayTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"ArrayTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBooleanTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"BooleanTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBooleanLiteralTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"BooleanLiteralTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNullLiteralTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"NullLiteralTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClassImplements(node, opts) {\n if (!node) return false;\n if (node.type !== \"ClassImplements\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareClass(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareClass\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareFunction(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareFunction\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareInterface(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareInterface\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareModule(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareModule\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareModuleExports(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareModuleExports\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareTypeAlias(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareTypeAlias\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareOpaqueType(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareOpaqueType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareVariable(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareVariable\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareExportDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareExportDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclareExportAllDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclareExportAllDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclaredPredicate(node, opts) {\n if (!node) return false;\n if (node.type !== \"DeclaredPredicate\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExistsTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExistsTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"FunctionTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionTypeParam(node, opts) {\n if (!node) return false;\n if (node.type !== \"FunctionTypeParam\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isGenericTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"GenericTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isInferredPredicate(node, opts) {\n if (!node) return false;\n if (node.type !== \"InferredPredicate\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isInterfaceExtends(node, opts) {\n if (!node) return false;\n if (node.type !== \"InterfaceExtends\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isInterfaceDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"InterfaceDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isInterfaceTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"InterfaceTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isIntersectionTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"IntersectionTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isMixedTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"MixedTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEmptyTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"EmptyTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNullableTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"NullableTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNumberLiteralTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"NumberLiteralTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNumberTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"NumberTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeInternalSlot(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeInternalSlot\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeCallProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeCallProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeIndexer(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeIndexer\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectTypeSpreadProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"ObjectTypeSpreadProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isOpaqueType(node, opts) {\n if (!node) return false;\n if (node.type !== \"OpaqueType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isQualifiedTypeIdentifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"QualifiedTypeIdentifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStringLiteralTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"StringLiteralTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStringTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"StringTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSymbolTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"SymbolTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isThisTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"ThisTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTupleTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TupleTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeofTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeofTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeAlias(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeAlias\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeCastExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeCastExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeParameter(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeParameter\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeParameterDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeParameterDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeParameterInstantiation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TypeParameterInstantiation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isUnionTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"UnionTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isVariance(node, opts) {\n if (!node) return false;\n if (node.type !== \"Variance\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isVoidTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"VoidTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumBooleanBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumBooleanBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumNumberBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumNumberBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumStringBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumStringBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumSymbolBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumSymbolBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumBooleanMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumBooleanMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumNumberMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumNumberMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumStringMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumStringMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumDefaultedMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"EnumDefaultedMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isIndexedAccessType(node, opts) {\n if (!node) return false;\n if (node.type !== \"IndexedAccessType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isOptionalIndexedAccessType(node, opts) {\n if (!node) return false;\n if (node.type !== \"OptionalIndexedAccessType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXAttribute(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXAttribute\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXClosingElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXClosingElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXEmptyExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXEmptyExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXExpressionContainer(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXExpressionContainer\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXSpreadChild(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXSpreadChild\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXIdentifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXIdentifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXMemberExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXMemberExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXNamespacedName(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXNamespacedName\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXOpeningElement(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXOpeningElement\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXSpreadAttribute(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXSpreadAttribute\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXText(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXText\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXFragment(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXFragment\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXOpeningFragment(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXOpeningFragment\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSXClosingFragment(node, opts) {\n if (!node) return false;\n if (node.type !== \"JSXClosingFragment\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNoop(node, opts) {\n if (!node) return false;\n if (node.type !== \"Noop\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPlaceholder(node, opts) {\n if (!node) return false;\n if (node.type !== \"Placeholder\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isV8IntrinsicIdentifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"V8IntrinsicIdentifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isArgumentPlaceholder(node, opts) {\n if (!node) return false;\n if (node.type !== \"ArgumentPlaceholder\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBindExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"BindExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDecorator(node, opts) {\n if (!node) return false;\n if (node.type !== \"Decorator\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDoExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"DoExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportDefaultSpecifier(node, opts) {\n if (!node) return false;\n if (node.type !== \"ExportDefaultSpecifier\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isRecordExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"RecordExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTupleExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TupleExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDecimalLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"DecimalLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isModuleExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"ModuleExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTopicReference(node, opts) {\n if (!node) return false;\n if (node.type !== \"TopicReference\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPipelineTopicExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"PipelineTopicExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPipelineBareFunction(node, opts) {\n if (!node) return false;\n if (node.type !== \"PipelineBareFunction\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPipelinePrimaryTopicReference(node, opts) {\n if (!node) return false;\n if (node.type !== \"PipelinePrimaryTopicReference\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isVoidPattern(node, opts) {\n if (!node) return false;\n if (node.type !== \"VoidPattern\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSParameterProperty(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSParameterProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSDeclareFunction(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSDeclareFunction\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSDeclareMethod(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSDeclareMethod\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSQualifiedName(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSQualifiedName\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSCallSignatureDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSCallSignatureDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSConstructSignatureDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSConstructSignatureDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSPropertySignature(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSPropertySignature\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSMethodSignature(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSMethodSignature\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSIndexSignature(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSIndexSignature\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSAnyKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSAnyKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSBooleanKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSBooleanKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSBigIntKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSBigIntKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSIntrinsicKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSIntrinsicKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNeverKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNeverKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNullKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNullKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNumberKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNumberKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSObjectKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSObjectKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSStringKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSStringKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSSymbolKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSSymbolKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSUndefinedKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSUndefinedKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSUnknownKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSUnknownKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSVoidKeyword(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSVoidKeyword\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSThisType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSThisType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSFunctionType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSFunctionType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSConstructorType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSConstructorType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeReference(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeReference\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypePredicate(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypePredicate\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeQuery(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeQuery\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeLiteral(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSArrayType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSArrayType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTupleType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTupleType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSOptionalType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSOptionalType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSRestType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSRestType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNamedTupleMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNamedTupleMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSUnionType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSUnionType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSIntersectionType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSIntersectionType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSConditionalType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSConditionalType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSInferType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSInferType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSParenthesizedType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSParenthesizedType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeOperator(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeOperator\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSIndexedAccessType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSIndexedAccessType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSMappedType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSMappedType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTemplateLiteralType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTemplateLiteralType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSLiteralType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSLiteralType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSExpressionWithTypeArguments(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSExpressionWithTypeArguments\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSInterfaceDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSInterfaceDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSInterfaceBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSInterfaceBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeAliasDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeAliasDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSInstantiationExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSInstantiationExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSAsExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSAsExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSSatisfiesExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSSatisfiesExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeAssertion(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeAssertion\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSEnumBody(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSEnumBody\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSEnumDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSEnumDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSEnumMember(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSEnumMember\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSModuleDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSModuleDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSModuleBlock(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSModuleBlock\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSImportType(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSImportType\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSImportEqualsDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSImportEqualsDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSExternalModuleReference(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSExternalModuleReference\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNonNullExpression(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNonNullExpression\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSExportAssignment(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSExportAssignment\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSNamespaceExportDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSNamespaceExportDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeAnnotation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeAnnotation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeParameterInstantiation(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeParameterInstantiation\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeParameterDeclaration(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeParameterDeclaration\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeParameter(node, opts) {\n if (!node) return false;\n if (node.type !== \"TSTypeParameter\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStandardized(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ArrayExpression\":\n case \"AssignmentExpression\":\n case \"BinaryExpression\":\n case \"InterpreterDirective\":\n case \"Directive\":\n case \"DirectiveLiteral\":\n case \"BlockStatement\":\n case \"BreakStatement\":\n case \"CallExpression\":\n case \"CatchClause\":\n case \"ConditionalExpression\":\n case \"ContinueStatement\":\n case \"DebuggerStatement\":\n case \"DoWhileStatement\":\n case \"EmptyStatement\":\n case \"ExpressionStatement\":\n case \"File\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Identifier\":\n case \"IfStatement\":\n case \"LabeledStatement\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"LogicalExpression\":\n case \"MemberExpression\":\n case \"NewExpression\":\n case \"Program\":\n case \"ObjectExpression\":\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n case \"RestElement\":\n case \"ReturnStatement\":\n case \"SequenceExpression\":\n case \"ParenthesizedExpression\":\n case \"SwitchCase\":\n case \"SwitchStatement\":\n case \"ThisExpression\":\n case \"ThrowStatement\":\n case \"TryStatement\":\n case \"UnaryExpression\":\n case \"UpdateExpression\":\n case \"VariableDeclaration\":\n case \"VariableDeclarator\":\n case \"WhileStatement\":\n case \"WithStatement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ArrowFunctionExpression\":\n case \"ClassBody\":\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ExportSpecifier\":\n case \"ForOfStatement\":\n case \"ImportDeclaration\":\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n case \"ImportExpression\":\n case \"MetaProperty\":\n case \"ClassMethod\":\n case \"ObjectPattern\":\n case \"SpreadElement\":\n case \"Super\":\n case \"TaggedTemplateExpression\":\n case \"TemplateElement\":\n case \"TemplateLiteral\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n case \"Import\":\n case \"BigIntLiteral\":\n case \"ExportNamespaceSpecifier\":\n case \"OptionalMemberExpression\":\n case \"OptionalCallExpression\":\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n case \"ClassPrivateProperty\":\n case \"ClassPrivateMethod\":\n case \"PrivateName\":\n case \"StaticBlock\":\n case \"ImportAttribute\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Identifier\":\n case \"StringLiteral\":\n case \"BlockStatement\":\n case \"ClassBody\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExpression(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ArrayExpression\":\n case \"AssignmentExpression\":\n case \"BinaryExpression\":\n case \"CallExpression\":\n case \"ConditionalExpression\":\n case \"FunctionExpression\":\n case \"Identifier\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"LogicalExpression\":\n case \"MemberExpression\":\n case \"NewExpression\":\n case \"ObjectExpression\":\n case \"SequenceExpression\":\n case \"ParenthesizedExpression\":\n case \"ThisExpression\":\n case \"UnaryExpression\":\n case \"UpdateExpression\":\n case \"ArrowFunctionExpression\":\n case \"ClassExpression\":\n case \"ImportExpression\":\n case \"MetaProperty\":\n case \"Super\":\n case \"TaggedTemplateExpression\":\n case \"TemplateLiteral\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n case \"Import\":\n case \"BigIntLiteral\":\n case \"OptionalMemberExpression\":\n case \"OptionalCallExpression\":\n case \"TypeCastExpression\":\n case \"JSXElement\":\n case \"JSXFragment\":\n case \"BindExpression\":\n case \"DoExpression\":\n case \"RecordExpression\":\n case \"TupleExpression\":\n case \"DecimalLiteral\":\n case \"ModuleExpression\":\n case \"TopicReference\":\n case \"PipelineTopicExpression\":\n case \"PipelineBareFunction\":\n case \"PipelinePrimaryTopicReference\":\n case \"TSInstantiationExpression\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Expression\":\n case \"Identifier\":\n case \"StringLiteral\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBinary(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BinaryExpression\":\n case \"LogicalExpression\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isScopable(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BlockStatement\":\n case \"CatchClause\":\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Program\":\n case \"ObjectMethod\":\n case \"SwitchStatement\":\n case \"WhileStatement\":\n case \"ArrowFunctionExpression\":\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n case \"ForOfStatement\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBlockParent(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BlockStatement\":\n case \"CatchClause\":\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"Program\":\n case \"ObjectMethod\":\n case \"SwitchStatement\":\n case \"WhileStatement\":\n case \"ArrowFunctionExpression\":\n case \"ForOfStatement\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isBlock(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BlockStatement\":\n case \"Program\":\n case \"TSModuleBlock\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"BlockStatement\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isStatement(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BlockStatement\":\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"DebuggerStatement\":\n case \"DoWhileStatement\":\n case \"EmptyStatement\":\n case \"ExpressionStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"FunctionDeclaration\":\n case \"IfStatement\":\n case \"LabeledStatement\":\n case \"ReturnStatement\":\n case \"SwitchStatement\":\n case \"ThrowStatement\":\n case \"TryStatement\":\n case \"VariableDeclaration\":\n case \"WhileStatement\":\n case \"WithStatement\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ForOfStatement\":\n case \"ImportDeclaration\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n case \"EnumDeclaration\":\n case \"TSDeclareFunction\":\n case \"TSInterfaceDeclaration\":\n case \"TSTypeAliasDeclaration\":\n case \"TSEnumDeclaration\":\n case \"TSModuleDeclaration\":\n case \"TSImportEqualsDeclaration\":\n case \"TSExportAssignment\":\n case \"TSNamespaceExportDeclaration\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Statement\":\n case \"Declaration\":\n case \"BlockStatement\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTerminatorless(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"ReturnStatement\":\n case \"ThrowStatement\":\n case \"YieldExpression\":\n case \"AwaitExpression\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isCompletionStatement(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"BreakStatement\":\n case \"ContinueStatement\":\n case \"ReturnStatement\":\n case \"ThrowStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isConditional(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ConditionalExpression\":\n case \"IfStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isLoop(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"DoWhileStatement\":\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"WhileStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isWhile(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"DoWhileStatement\":\n case \"WhileStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExpressionWrapper(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ExpressionStatement\":\n case \"ParenthesizedExpression\":\n case \"TypeCastExpression\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFor(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ForInStatement\":\n case \"ForStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isForXStatement(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ForInStatement\":\n case \"ForOfStatement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunction(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ObjectMethod\":\n case \"ArrowFunctionExpression\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionParent(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"ObjectMethod\":\n case \"ArrowFunctionExpression\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"StaticBlock\":\n case \"TSModuleBlock\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPureish(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"ArrowFunctionExpression\":\n case \"BigIntLiteral\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isDeclaration(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"FunctionDeclaration\":\n case \"VariableDeclaration\":\n case \"ClassDeclaration\":\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n case \"EnumDeclaration\":\n case \"TSDeclareFunction\":\n case \"TSInterfaceDeclaration\":\n case \"TSTypeAliasDeclaration\":\n case \"TSEnumDeclaration\":\n case \"TSModuleDeclaration\":\n case \"TSImportEqualsDeclaration\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Declaration\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFunctionParameter(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"Identifier\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Identifier\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPatternLike(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"Identifier\":\n case \"MemberExpression\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Pattern\":\n case \"Identifier\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isLVal(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"Identifier\":\n case \"MemberExpression\":\n case \"RestElement\":\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"TSParameterProperty\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n break;\n case \"Placeholder\":\n switch (node.expectedNode) {\n case \"Pattern\":\n case \"Identifier\":\n break;\n default:\n return false;\n }\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSEntityName(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"Identifier\":\n case \"TSQualifiedName\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Identifier\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isLiteral(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"RegExpLiteral\":\n case \"TemplateLiteral\":\n case \"BigIntLiteral\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImmutable(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"StringLiteral\":\n case \"NumericLiteral\":\n case \"NullLiteral\":\n case \"BooleanLiteral\":\n case \"BigIntLiteral\":\n case \"JSXAttribute\":\n case \"JSXClosingElement\":\n case \"JSXElement\":\n case \"JSXExpressionContainer\":\n case \"JSXSpreadChild\":\n case \"JSXOpeningElement\":\n case \"JSXText\":\n case \"JSXFragment\":\n case \"JSXOpeningFragment\":\n case \"JSXClosingFragment\":\n case \"DecimalLiteral\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"StringLiteral\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isUserWhitespacable(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n case \"ObjectTypeInternalSlot\":\n case \"ObjectTypeCallProperty\":\n case \"ObjectTypeIndexer\":\n case \"ObjectTypeProperty\":\n case \"ObjectTypeSpreadProperty\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isMethod(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isObjectMember(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ObjectMethod\":\n case \"ObjectProperty\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isProperty(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ObjectProperty\":\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n case \"ClassPrivateProperty\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isUnaryLike(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"UnaryExpression\":\n case \"SpreadElement\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPattern(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"AssignmentPattern\":\n case \"ArrayPattern\":\n case \"ObjectPattern\":\n case \"VoidPattern\":\n break;\n case \"Placeholder\":\n if (node.expectedNode === \"Pattern\") break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isClass(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ClassExpression\":\n case \"ClassDeclaration\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isImportOrExportDeclaration(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n case \"ImportDeclaration\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isExportDeclaration(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ExportAllDeclaration\":\n case \"ExportDefaultDeclaration\":\n case \"ExportNamedDeclaration\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isModuleSpecifier(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ExportSpecifier\":\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isAccessor(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ClassAccessorProperty\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isPrivate(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"ClassPrivateProperty\":\n case \"ClassPrivateMethod\":\n case \"PrivateName\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFlow(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"ArrayTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"BooleanLiteralTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"ClassImplements\":\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"DeclaredPredicate\":\n case \"ExistsTypeAnnotation\":\n case \"FunctionTypeAnnotation\":\n case \"FunctionTypeParam\":\n case \"GenericTypeAnnotation\":\n case \"InferredPredicate\":\n case \"InterfaceExtends\":\n case \"InterfaceDeclaration\":\n case \"InterfaceTypeAnnotation\":\n case \"IntersectionTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NullableTypeAnnotation\":\n case \"NumberLiteralTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"ObjectTypeAnnotation\":\n case \"ObjectTypeInternalSlot\":\n case \"ObjectTypeCallProperty\":\n case \"ObjectTypeIndexer\":\n case \"ObjectTypeProperty\":\n case \"ObjectTypeSpreadProperty\":\n case \"OpaqueType\":\n case \"QualifiedTypeIdentifier\":\n case \"StringLiteralTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"TupleTypeAnnotation\":\n case \"TypeofTypeAnnotation\":\n case \"TypeAlias\":\n case \"TypeAnnotation\":\n case \"TypeCastExpression\":\n case \"TypeParameter\":\n case \"TypeParameterDeclaration\":\n case \"TypeParameterInstantiation\":\n case \"UnionTypeAnnotation\":\n case \"Variance\":\n case \"VoidTypeAnnotation\":\n case \"EnumDeclaration\":\n case \"EnumBooleanBody\":\n case \"EnumNumberBody\":\n case \"EnumStringBody\":\n case \"EnumSymbolBody\":\n case \"EnumBooleanMember\":\n case \"EnumNumberMember\":\n case \"EnumStringMember\":\n case \"EnumDefaultedMember\":\n case \"IndexedAccessType\":\n case \"OptionalIndexedAccessType\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFlowType(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"ArrayTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"BooleanLiteralTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"ExistsTypeAnnotation\":\n case \"FunctionTypeAnnotation\":\n case \"GenericTypeAnnotation\":\n case \"InterfaceTypeAnnotation\":\n case \"IntersectionTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NullableTypeAnnotation\":\n case \"NumberLiteralTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"ObjectTypeAnnotation\":\n case \"StringLiteralTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"TupleTypeAnnotation\":\n case \"TypeofTypeAnnotation\":\n case \"UnionTypeAnnotation\":\n case \"VoidTypeAnnotation\":\n case \"IndexedAccessType\":\n case \"OptionalIndexedAccessType\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFlowBaseAnnotation(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"AnyTypeAnnotation\":\n case \"BooleanTypeAnnotation\":\n case \"NullLiteralTypeAnnotation\":\n case \"MixedTypeAnnotation\":\n case \"EmptyTypeAnnotation\":\n case \"NumberTypeAnnotation\":\n case \"StringTypeAnnotation\":\n case \"SymbolTypeAnnotation\":\n case \"ThisTypeAnnotation\":\n case \"VoidTypeAnnotation\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFlowDeclaration(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"DeclareClass\":\n case \"DeclareFunction\":\n case \"DeclareInterface\":\n case \"DeclareModule\":\n case \"DeclareModuleExports\":\n case \"DeclareTypeAlias\":\n case \"DeclareOpaqueType\":\n case \"DeclareVariable\":\n case \"DeclareExportDeclaration\":\n case \"DeclareExportAllDeclaration\":\n case \"InterfaceDeclaration\":\n case \"OpaqueType\":\n case \"TypeAlias\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isFlowPredicate(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"DeclaredPredicate\":\n case \"InferredPredicate\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumBody(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"EnumBooleanBody\":\n case \"EnumNumberBody\":\n case \"EnumStringBody\":\n case \"EnumSymbolBody\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isEnumMember(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"EnumBooleanMember\":\n case \"EnumNumberMember\":\n case \"EnumStringMember\":\n case \"EnumDefaultedMember\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isJSX(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"JSXAttribute\":\n case \"JSXClosingElement\":\n case \"JSXElement\":\n case \"JSXEmptyExpression\":\n case \"JSXExpressionContainer\":\n case \"JSXSpreadChild\":\n case \"JSXIdentifier\":\n case \"JSXMemberExpression\":\n case \"JSXNamespacedName\":\n case \"JSXOpeningElement\":\n case \"JSXSpreadAttribute\":\n case \"JSXText\":\n case \"JSXFragment\":\n case \"JSXOpeningFragment\":\n case \"JSXClosingFragment\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isMiscellaneous(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"Noop\":\n case \"Placeholder\":\n case \"V8IntrinsicIdentifier\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTypeScript(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"TSParameterProperty\":\n case \"TSDeclareFunction\":\n case \"TSDeclareMethod\":\n case \"TSQualifiedName\":\n case \"TSCallSignatureDeclaration\":\n case \"TSConstructSignatureDeclaration\":\n case \"TSPropertySignature\":\n case \"TSMethodSignature\":\n case \"TSIndexSignature\":\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSFunctionType\":\n case \"TSConstructorType\":\n case \"TSTypeReference\":\n case \"TSTypePredicate\":\n case \"TSTypeQuery\":\n case \"TSTypeLiteral\":\n case \"TSArrayType\":\n case \"TSTupleType\":\n case \"TSOptionalType\":\n case \"TSRestType\":\n case \"TSNamedTupleMember\":\n case \"TSUnionType\":\n case \"TSIntersectionType\":\n case \"TSConditionalType\":\n case \"TSInferType\":\n case \"TSParenthesizedType\":\n case \"TSTypeOperator\":\n case \"TSIndexedAccessType\":\n case \"TSMappedType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n case \"TSExpressionWithTypeArguments\":\n case \"TSInterfaceDeclaration\":\n case \"TSInterfaceBody\":\n case \"TSTypeAliasDeclaration\":\n case \"TSInstantiationExpression\":\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSEnumBody\":\n case \"TSEnumDeclaration\":\n case \"TSEnumMember\":\n case \"TSModuleDeclaration\":\n case \"TSModuleBlock\":\n case \"TSImportType\":\n case \"TSImportEqualsDeclaration\":\n case \"TSExternalModuleReference\":\n case \"TSNonNullExpression\":\n case \"TSExportAssignment\":\n case \"TSNamespaceExportDeclaration\":\n case \"TSTypeAnnotation\":\n case \"TSTypeParameterInstantiation\":\n case \"TSTypeParameterDeclaration\":\n case \"TSTypeParameter\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSTypeElement(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"TSCallSignatureDeclaration\":\n case \"TSConstructSignatureDeclaration\":\n case \"TSPropertySignature\":\n case \"TSMethodSignature\":\n case \"TSIndexSignature\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSType(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSFunctionType\":\n case \"TSConstructorType\":\n case \"TSTypeReference\":\n case \"TSTypePredicate\":\n case \"TSTypeQuery\":\n case \"TSTypeLiteral\":\n case \"TSArrayType\":\n case \"TSTupleType\":\n case \"TSOptionalType\":\n case \"TSRestType\":\n case \"TSUnionType\":\n case \"TSIntersectionType\":\n case \"TSConditionalType\":\n case \"TSInferType\":\n case \"TSParenthesizedType\":\n case \"TSTypeOperator\":\n case \"TSIndexedAccessType\":\n case \"TSMappedType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n case \"TSExpressionWithTypeArguments\":\n case \"TSImportType\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isTSBaseType(node, opts) {\n if (!node) return false;\n switch (node.type) {\n case \"TSAnyKeyword\":\n case \"TSBooleanKeyword\":\n case \"TSBigIntKeyword\":\n case \"TSIntrinsicKeyword\":\n case \"TSNeverKeyword\":\n case \"TSNullKeyword\":\n case \"TSNumberKeyword\":\n case \"TSObjectKeyword\":\n case \"TSStringKeyword\":\n case \"TSSymbolKeyword\":\n case \"TSUndefinedKeyword\":\n case \"TSUnknownKeyword\":\n case \"TSVoidKeyword\":\n case \"TSThisType\":\n case \"TSTemplateLiteralType\":\n case \"TSLiteralType\":\n break;\n default:\n return false;\n }\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isNumberLiteral(node, opts) {\n (0, _deprecationWarning.default)(\"isNumberLiteral\", \"isNumericLiteral\");\n if (!node) return false;\n if (node.type !== \"NumberLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isRegexLiteral(node, opts) {\n (0, _deprecationWarning.default)(\"isRegexLiteral\", \"isRegExpLiteral\");\n if (!node) return false;\n if (node.type !== \"RegexLiteral\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isRestProperty(node, opts) {\n (0, _deprecationWarning.default)(\"isRestProperty\", \"isRestElement\");\n if (!node) return false;\n if (node.type !== \"RestProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isSpreadProperty(node, opts) {\n (0, _deprecationWarning.default)(\"isSpreadProperty\", \"isSpreadElement\");\n if (!node) return false;\n if (node.type !== \"SpreadProperty\") return false;\n return opts == null || (0, _shallowEqual.default)(node, opts);\n}\nfunction isModuleDeclaration(node, opts) {\n (0, _deprecationWarning.default)(\"isModuleDeclaration\", \"isImportOrExportDeclaration\");\n return isImportOrExportDeclaration(node, opts);\n}\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = shallowEqual;\nfunction shallowEqual(actual, expected) {\n const keys = Object.keys(expected);\n for (const key of keys) {\n if (actual[key] !== expected[key]) {\n return false;\n }\n }\n return true;\n}\n\n//# sourceMappingURL=shallowEqual.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = deprecationWarning;\nconst warnings = new Set();\nfunction deprecationWarning(oldName, newName, prefix = \"\", cacheKey = oldName) {\n if (warnings.has(cacheKey)) return;\n warnings.add(cacheKey);\n const {\n internal,\n trace\n } = captureShortStackTrace(1, 2);\n if (internal) {\n return;\n }\n console.warn(`${prefix}\\`${oldName}\\` has been deprecated, please migrate to \\`${newName}\\`\\n${trace}`);\n}\nfunction captureShortStackTrace(skip, length) {\n const {\n stackTraceLimit,\n prepareStackTrace\n } = Error;\n let stackTrace;\n Error.stackTraceLimit = 1 + skip + length;\n Error.prepareStackTrace = function (err, stack) {\n stackTrace = stack;\n };\n new Error().stack;\n Error.stackTraceLimit = stackTraceLimit;\n Error.prepareStackTrace = prepareStackTrace;\n if (!stackTrace) return {\n internal: false,\n trace: \"\"\n };\n const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);\n return {\n internal: /[\\\\/]@babel[\\\\/]/.test(shortStackTrace[1].getFileName()),\n trace: shortStackTrace.map(frame => ` at ${frame}`).join(\"\\n\")\n };\n}\n\n//# sourceMappingURL=deprecationWarning.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isCompatTag;\nfunction isCompatTag(tagName) {\n return !!tagName && /^[a-z]/.test(tagName);\n}\n\n//# sourceMappingURL=isCompatTag.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = buildChildren;\nvar _index = require(\"../../validators/generated/index.js\");\nvar _cleanJSXElementLiteralChild = require(\"../../utils/react/cleanJSXElementLiteralChild.js\");\nfunction buildChildren(node) {\n const elements = [];\n for (let i = 0; i < node.children.length; i++) {\n let child = node.children[i];\n if ((0, _index.isJSXText)(child)) {\n (0, _cleanJSXElementLiteralChild.default)(child, elements);\n continue;\n }\n if ((0, _index.isJSXExpressionContainer)(child)) child = child.expression;\n if ((0, _index.isJSXEmptyExpression)(child)) continue;\n elements.push(child);\n }\n return elements;\n}\n\n//# sourceMappingURL=buildChildren.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = cleanJSXElementLiteralChild;\nvar _index = require(\"../../builders/generated/index.js\");\nvar _index2 = require(\"../../index.js\");\nfunction cleanJSXElementLiteralChild(child, args) {\n const lines = child.value.split(/\\r\\n|\\n|\\r/);\n let lastNonEmptyLine = 0;\n for (let i = 0; i < lines.length; i++) {\n if (/[^ \\t]/.exec(lines[i])) {\n lastNonEmptyLine = i;\n }\n }\n let str = \"\";\n for (let i = 0; i < lines.length; i++) {\n const line = lines[i];\n const isFirstLine = i === 0;\n const isLastLine = i === lines.length - 1;\n const isLastNonEmptyLine = i === lastNonEmptyLine;\n let trimmedLine = line.replace(/\\t/g, \" \");\n if (!isFirstLine) {\n trimmedLine = trimmedLine.replace(/^ +/, \"\");\n }\n if (!isLastLine) {\n trimmedLine = trimmedLine.replace(/ +$/, \"\");\n }\n if (trimmedLine) {\n if (!isLastNonEmptyLine) {\n trimmedLine += \" \";\n }\n str += trimmedLine;\n }\n }\n if (str) args.push((0, _index2.inherits)((0, _index.stringLiteral)(str), child));\n}\n\n//# sourceMappingURL=cleanJSXElementLiteralChild.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nvar _lowercase = require(\"./lowercase.js\");\nObject.keys(_lowercase).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (key in exports && exports[key] === _lowercase[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _lowercase[key];\n }\n });\n});\nvar _uppercase = require(\"./uppercase.js\");\nObject.keys(_uppercase).forEach(function (key) {\n if (key === \"default\" || key === \"__esModule\") return;\n if (key in exports && exports[key] === _uppercase[key]) return;\n Object.defineProperty(exports, key, {\n enumerable: true,\n get: function () {\n return _uppercase[key];\n }\n });\n});\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.anyTypeAnnotation = anyTypeAnnotation;\nexports.argumentPlaceholder = argumentPlaceholder;\nexports.arrayExpression = arrayExpression;\nexports.arrayPattern = arrayPattern;\nexports.arrayTypeAnnotation = arrayTypeAnnotation;\nexports.arrowFunctionExpression = arrowFunctionExpression;\nexports.assignmentExpression = assignmentExpression;\nexports.assignmentPattern = assignmentPattern;\nexports.awaitExpression = awaitExpression;\nexports.bigIntLiteral = bigIntLiteral;\nexports.binaryExpression = binaryExpression;\nexports.bindExpression = bindExpression;\nexports.blockStatement = blockStatement;\nexports.booleanLiteral = booleanLiteral;\nexports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;\nexports.booleanTypeAnnotation = booleanTypeAnnotation;\nexports.breakStatement = breakStatement;\nexports.callExpression = callExpression;\nexports.catchClause = catchClause;\nexports.classAccessorProperty = classAccessorProperty;\nexports.classBody = classBody;\nexports.classDeclaration = classDeclaration;\nexports.classExpression = classExpression;\nexports.classImplements = classImplements;\nexports.classMethod = classMethod;\nexports.classPrivateMethod = classPrivateMethod;\nexports.classPrivateProperty = classPrivateProperty;\nexports.classProperty = classProperty;\nexports.conditionalExpression = conditionalExpression;\nexports.continueStatement = continueStatement;\nexports.debuggerStatement = debuggerStatement;\nexports.decimalLiteral = decimalLiteral;\nexports.declareClass = declareClass;\nexports.declareExportAllDeclaration = declareExportAllDeclaration;\nexports.declareExportDeclaration = declareExportDeclaration;\nexports.declareFunction = declareFunction;\nexports.declareInterface = declareInterface;\nexports.declareModule = declareModule;\nexports.declareModuleExports = declareModuleExports;\nexports.declareOpaqueType = declareOpaqueType;\nexports.declareTypeAlias = declareTypeAlias;\nexports.declareVariable = declareVariable;\nexports.declaredPredicate = declaredPredicate;\nexports.decorator = decorator;\nexports.directive = directive;\nexports.directiveLiteral = directiveLiteral;\nexports.doExpression = doExpression;\nexports.doWhileStatement = doWhileStatement;\nexports.emptyStatement = emptyStatement;\nexports.emptyTypeAnnotation = emptyTypeAnnotation;\nexports.enumBooleanBody = enumBooleanBody;\nexports.enumBooleanMember = enumBooleanMember;\nexports.enumDeclaration = enumDeclaration;\nexports.enumDefaultedMember = enumDefaultedMember;\nexports.enumNumberBody = enumNumberBody;\nexports.enumNumberMember = enumNumberMember;\nexports.enumStringBody = enumStringBody;\nexports.enumStringMember = enumStringMember;\nexports.enumSymbolBody = enumSymbolBody;\nexports.existsTypeAnnotation = existsTypeAnnotation;\nexports.exportAllDeclaration = exportAllDeclaration;\nexports.exportDefaultDeclaration = exportDefaultDeclaration;\nexports.exportDefaultSpecifier = exportDefaultSpecifier;\nexports.exportNamedDeclaration = exportNamedDeclaration;\nexports.exportNamespaceSpecifier = exportNamespaceSpecifier;\nexports.exportSpecifier = exportSpecifier;\nexports.expressionStatement = expressionStatement;\nexports.file = file;\nexports.forInStatement = forInStatement;\nexports.forOfStatement = forOfStatement;\nexports.forStatement = forStatement;\nexports.functionDeclaration = functionDeclaration;\nexports.functionExpression = functionExpression;\nexports.functionTypeAnnotation = functionTypeAnnotation;\nexports.functionTypeParam = functionTypeParam;\nexports.genericTypeAnnotation = genericTypeAnnotation;\nexports.identifier = identifier;\nexports.ifStatement = ifStatement;\nexports.import = _import;\nexports.importAttribute = importAttribute;\nexports.importDeclaration = importDeclaration;\nexports.importDefaultSpecifier = importDefaultSpecifier;\nexports.importExpression = importExpression;\nexports.importNamespaceSpecifier = importNamespaceSpecifier;\nexports.importSpecifier = importSpecifier;\nexports.indexedAccessType = indexedAccessType;\nexports.inferredPredicate = inferredPredicate;\nexports.interfaceDeclaration = interfaceDeclaration;\nexports.interfaceExtends = interfaceExtends;\nexports.interfaceTypeAnnotation = interfaceTypeAnnotation;\nexports.interpreterDirective = interpreterDirective;\nexports.intersectionTypeAnnotation = intersectionTypeAnnotation;\nexports.jSXAttribute = exports.jsxAttribute = jsxAttribute;\nexports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;\nexports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;\nexports.jSXElement = exports.jsxElement = jsxElement;\nexports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;\nexports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;\nexports.jSXFragment = exports.jsxFragment = jsxFragment;\nexports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;\nexports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;\nexports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;\nexports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;\nexports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;\nexports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;\nexports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;\nexports.jSXText = exports.jsxText = jsxText;\nexports.labeledStatement = labeledStatement;\nexports.logicalExpression = logicalExpression;\nexports.memberExpression = memberExpression;\nexports.metaProperty = metaProperty;\nexports.mixedTypeAnnotation = mixedTypeAnnotation;\nexports.moduleExpression = moduleExpression;\nexports.newExpression = newExpression;\nexports.noop = noop;\nexports.nullLiteral = nullLiteral;\nexports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;\nexports.nullableTypeAnnotation = nullableTypeAnnotation;\nexports.numberLiteral = NumberLiteral;\nexports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;\nexports.numberTypeAnnotation = numberTypeAnnotation;\nexports.numericLiteral = numericLiteral;\nexports.objectExpression = objectExpression;\nexports.objectMethod = objectMethod;\nexports.objectPattern = objectPattern;\nexports.objectProperty = objectProperty;\nexports.objectTypeAnnotation = objectTypeAnnotation;\nexports.objectTypeCallProperty = objectTypeCallProperty;\nexports.objectTypeIndexer = objectTypeIndexer;\nexports.objectTypeInternalSlot = objectTypeInternalSlot;\nexports.objectTypeProperty = objectTypeProperty;\nexports.objectTypeSpreadProperty = objectTypeSpreadProperty;\nexports.opaqueType = opaqueType;\nexports.optionalCallExpression = optionalCallExpression;\nexports.optionalIndexedAccessType = optionalIndexedAccessType;\nexports.optionalMemberExpression = optionalMemberExpression;\nexports.parenthesizedExpression = parenthesizedExpression;\nexports.pipelineBareFunction = pipelineBareFunction;\nexports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;\nexports.pipelineTopicExpression = pipelineTopicExpression;\nexports.placeholder = placeholder;\nexports.privateName = privateName;\nexports.program = program;\nexports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;\nexports.recordExpression = recordExpression;\nexports.regExpLiteral = regExpLiteral;\nexports.regexLiteral = RegexLiteral;\nexports.restElement = restElement;\nexports.restProperty = RestProperty;\nexports.returnStatement = returnStatement;\nexports.sequenceExpression = sequenceExpression;\nexports.spreadElement = spreadElement;\nexports.spreadProperty = SpreadProperty;\nexports.staticBlock = staticBlock;\nexports.stringLiteral = stringLiteral;\nexports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;\nexports.stringTypeAnnotation = stringTypeAnnotation;\nexports.super = _super;\nexports.switchCase = switchCase;\nexports.switchStatement = switchStatement;\nexports.symbolTypeAnnotation = symbolTypeAnnotation;\nexports.taggedTemplateExpression = taggedTemplateExpression;\nexports.templateElement = templateElement;\nexports.templateLiteral = templateLiteral;\nexports.thisExpression = thisExpression;\nexports.thisTypeAnnotation = thisTypeAnnotation;\nexports.throwStatement = throwStatement;\nexports.topicReference = topicReference;\nexports.tryStatement = tryStatement;\nexports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;\nexports.tSArrayType = exports.tsArrayType = tsArrayType;\nexports.tSAsExpression = exports.tsAsExpression = tsAsExpression;\nexports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;\nexports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;\nexports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;\nexports.tSConditionalType = exports.tsConditionalType = tsConditionalType;\nexports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;\nexports.tSConstructorType = exports.tsConstructorType = tsConstructorType;\nexports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;\nexports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;\nexports.tSEnumBody = exports.tsEnumBody = tsEnumBody;\nexports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;\nexports.tSEnumMember = exports.tsEnumMember = tsEnumMember;\nexports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;\nexports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;\nexports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;\nexports.tSFunctionType = exports.tsFunctionType = tsFunctionType;\nexports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;\nexports.tSImportType = exports.tsImportType = tsImportType;\nexports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;\nexports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;\nexports.tSInferType = exports.tsInferType = tsInferType;\nexports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression;\nexports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;\nexports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;\nexports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;\nexports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;\nexports.tSLiteralType = exports.tsLiteralType = tsLiteralType;\nexports.tSMappedType = exports.tsMappedType = tsMappedType;\nexports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;\nexports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;\nexports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;\nexports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;\nexports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;\nexports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;\nexports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;\nexports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;\nexports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;\nexports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;\nexports.tSOptionalType = exports.tsOptionalType = tsOptionalType;\nexports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;\nexports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;\nexports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;\nexports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;\nexports.tSRestType = exports.tsRestType = tsRestType;\nexports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression;\nexports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;\nexports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;\nexports.tSTemplateLiteralType = exports.tsTemplateLiteralType = tsTemplateLiteralType;\nexports.tSThisType = exports.tsThisType = tsThisType;\nexports.tSTupleType = exports.tsTupleType = tsTupleType;\nexports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;\nexports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;\nexports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;\nexports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;\nexports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;\nexports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;\nexports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;\nexports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;\nexports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;\nexports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;\nexports.tSTypeReference = exports.tsTypeReference = tsTypeReference;\nexports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;\nexports.tSUnionType = exports.tsUnionType = tsUnionType;\nexports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;\nexports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;\nexports.tupleExpression = tupleExpression;\nexports.tupleTypeAnnotation = tupleTypeAnnotation;\nexports.typeAlias = typeAlias;\nexports.typeAnnotation = typeAnnotation;\nexports.typeCastExpression = typeCastExpression;\nexports.typeParameter = typeParameter;\nexports.typeParameterDeclaration = typeParameterDeclaration;\nexports.typeParameterInstantiation = typeParameterInstantiation;\nexports.typeofTypeAnnotation = typeofTypeAnnotation;\nexports.unaryExpression = unaryExpression;\nexports.unionTypeAnnotation = unionTypeAnnotation;\nexports.updateExpression = updateExpression;\nexports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;\nexports.variableDeclaration = variableDeclaration;\nexports.variableDeclarator = variableDeclarator;\nexports.variance = variance;\nexports.voidPattern = voidPattern;\nexports.voidTypeAnnotation = voidTypeAnnotation;\nexports.whileStatement = whileStatement;\nexports.withStatement = withStatement;\nexports.yieldExpression = yieldExpression;\nvar _validate = require(\"../../validators/validate.js\");\nvar _deprecationWarning = require(\"../../utils/deprecationWarning.js\");\nvar utils = require(\"../../definitions/utils.js\");\nconst {\n validateInternal: validate\n} = _validate;\nconst {\n NODE_FIELDS\n} = utils;\nfunction bigIntLiteral(value) {\n if (typeof value === \"bigint\") {\n value = value.toString();\n }\n const node = {\n type: \"BigIntLiteral\",\n value\n };\n const defs = NODE_FIELDS.BigIntLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction arrayExpression(elements = []) {\n const node = {\n type: \"ArrayExpression\",\n elements\n };\n const defs = NODE_FIELDS.ArrayExpression;\n validate(defs.elements, node, \"elements\", elements, 1);\n return node;\n}\nfunction assignmentExpression(operator, left, right) {\n const node = {\n type: \"AssignmentExpression\",\n operator,\n left,\n right\n };\n const defs = NODE_FIELDS.AssignmentExpression;\n validate(defs.operator, node, \"operator\", operator);\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction binaryExpression(operator, left, right) {\n const node = {\n type: \"BinaryExpression\",\n operator,\n left,\n right\n };\n const defs = NODE_FIELDS.BinaryExpression;\n validate(defs.operator, node, \"operator\", operator);\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction interpreterDirective(value) {\n const node = {\n type: \"InterpreterDirective\",\n value\n };\n const defs = NODE_FIELDS.InterpreterDirective;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction directive(value) {\n const node = {\n type: \"Directive\",\n value\n };\n const defs = NODE_FIELDS.Directive;\n validate(defs.value, node, \"value\", value, 1);\n return node;\n}\nfunction directiveLiteral(value) {\n const node = {\n type: \"DirectiveLiteral\",\n value\n };\n const defs = NODE_FIELDS.DirectiveLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction blockStatement(body, directives = []) {\n const node = {\n type: \"BlockStatement\",\n body,\n directives\n };\n const defs = NODE_FIELDS.BlockStatement;\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.directives, node, \"directives\", directives, 1);\n return node;\n}\nfunction breakStatement(label = null) {\n const node = {\n type: \"BreakStatement\",\n label\n };\n const defs = NODE_FIELDS.BreakStatement;\n validate(defs.label, node, \"label\", label, 1);\n return node;\n}\nfunction callExpression(callee, _arguments) {\n const node = {\n type: \"CallExpression\",\n callee,\n arguments: _arguments\n };\n const defs = NODE_FIELDS.CallExpression;\n validate(defs.callee, node, \"callee\", callee, 1);\n validate(defs.arguments, node, \"arguments\", _arguments, 1);\n return node;\n}\nfunction catchClause(param = null, body) {\n const node = {\n type: \"CatchClause\",\n param,\n body\n };\n const defs = NODE_FIELDS.CatchClause;\n validate(defs.param, node, \"param\", param, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction conditionalExpression(test, consequent, alternate) {\n const node = {\n type: \"ConditionalExpression\",\n test,\n consequent,\n alternate\n };\n const defs = NODE_FIELDS.ConditionalExpression;\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.consequent, node, \"consequent\", consequent, 1);\n validate(defs.alternate, node, \"alternate\", alternate, 1);\n return node;\n}\nfunction continueStatement(label = null) {\n const node = {\n type: \"ContinueStatement\",\n label\n };\n const defs = NODE_FIELDS.ContinueStatement;\n validate(defs.label, node, \"label\", label, 1);\n return node;\n}\nfunction debuggerStatement() {\n return {\n type: \"DebuggerStatement\"\n };\n}\nfunction doWhileStatement(test, body) {\n const node = {\n type: \"DoWhileStatement\",\n test,\n body\n };\n const defs = NODE_FIELDS.DoWhileStatement;\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction emptyStatement() {\n return {\n type: \"EmptyStatement\"\n };\n}\nfunction expressionStatement(expression) {\n const node = {\n type: \"ExpressionStatement\",\n expression\n };\n const defs = NODE_FIELDS.ExpressionStatement;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction file(program, comments = null, tokens = null) {\n const node = {\n type: \"File\",\n program,\n comments,\n tokens\n };\n const defs = NODE_FIELDS.File;\n validate(defs.program, node, \"program\", program, 1);\n validate(defs.comments, node, \"comments\", comments, 1);\n validate(defs.tokens, node, \"tokens\", tokens);\n return node;\n}\nfunction forInStatement(left, right, body) {\n const node = {\n type: \"ForInStatement\",\n left,\n right,\n body\n };\n const defs = NODE_FIELDS.ForInStatement;\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction forStatement(init = null, test = null, update = null, body) {\n const node = {\n type: \"ForStatement\",\n init,\n test,\n update,\n body\n };\n const defs = NODE_FIELDS.ForStatement;\n validate(defs.init, node, \"init\", init, 1);\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.update, node, \"update\", update, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction functionDeclaration(id = null, params, body, generator = false, async = false) {\n const node = {\n type: \"FunctionDeclaration\",\n id,\n params,\n body,\n generator,\n async\n };\n const defs = NODE_FIELDS.FunctionDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.generator, node, \"generator\", generator);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction functionExpression(id = null, params, body, generator = false, async = false) {\n const node = {\n type: \"FunctionExpression\",\n id,\n params,\n body,\n generator,\n async\n };\n const defs = NODE_FIELDS.FunctionExpression;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.generator, node, \"generator\", generator);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction identifier(name) {\n const node = {\n type: \"Identifier\",\n name\n };\n const defs = NODE_FIELDS.Identifier;\n validate(defs.name, node, \"name\", name);\n return node;\n}\nfunction ifStatement(test, consequent, alternate = null) {\n const node = {\n type: \"IfStatement\",\n test,\n consequent,\n alternate\n };\n const defs = NODE_FIELDS.IfStatement;\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.consequent, node, \"consequent\", consequent, 1);\n validate(defs.alternate, node, \"alternate\", alternate, 1);\n return node;\n}\nfunction labeledStatement(label, body) {\n const node = {\n type: \"LabeledStatement\",\n label,\n body\n };\n const defs = NODE_FIELDS.LabeledStatement;\n validate(defs.label, node, \"label\", label, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction stringLiteral(value) {\n const node = {\n type: \"StringLiteral\",\n value\n };\n const defs = NODE_FIELDS.StringLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction numericLiteral(value) {\n const node = {\n type: \"NumericLiteral\",\n value\n };\n const defs = NODE_FIELDS.NumericLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction nullLiteral() {\n return {\n type: \"NullLiteral\"\n };\n}\nfunction booleanLiteral(value) {\n const node = {\n type: \"BooleanLiteral\",\n value\n };\n const defs = NODE_FIELDS.BooleanLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction regExpLiteral(pattern, flags = \"\") {\n const node = {\n type: \"RegExpLiteral\",\n pattern,\n flags\n };\n const defs = NODE_FIELDS.RegExpLiteral;\n validate(defs.pattern, node, \"pattern\", pattern);\n validate(defs.flags, node, \"flags\", flags);\n return node;\n}\nfunction logicalExpression(operator, left, right) {\n const node = {\n type: \"LogicalExpression\",\n operator,\n left,\n right\n };\n const defs = NODE_FIELDS.LogicalExpression;\n validate(defs.operator, node, \"operator\", operator);\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction memberExpression(object, property, computed = false, optional = null) {\n const node = {\n type: \"MemberExpression\",\n object,\n property,\n computed,\n optional\n };\n const defs = NODE_FIELDS.MemberExpression;\n validate(defs.object, node, \"object\", object, 1);\n validate(defs.property, node, \"property\", property, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.optional, node, \"optional\", optional);\n return node;\n}\nfunction newExpression(callee, _arguments) {\n const node = {\n type: \"NewExpression\",\n callee,\n arguments: _arguments\n };\n const defs = NODE_FIELDS.NewExpression;\n validate(defs.callee, node, \"callee\", callee, 1);\n validate(defs.arguments, node, \"arguments\", _arguments, 1);\n return node;\n}\nfunction program(body, directives = [], sourceType = \"script\", interpreter = null) {\n const node = {\n type: \"Program\",\n body,\n directives,\n sourceType,\n interpreter\n };\n const defs = NODE_FIELDS.Program;\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.directives, node, \"directives\", directives, 1);\n validate(defs.sourceType, node, \"sourceType\", sourceType);\n validate(defs.interpreter, node, \"interpreter\", interpreter, 1);\n return node;\n}\nfunction objectExpression(properties) {\n const node = {\n type: \"ObjectExpression\",\n properties\n };\n const defs = NODE_FIELDS.ObjectExpression;\n validate(defs.properties, node, \"properties\", properties, 1);\n return node;\n}\nfunction objectMethod(kind = \"method\", key, params, body, computed = false, generator = false, async = false) {\n const node = {\n type: \"ObjectMethod\",\n kind,\n key,\n params,\n body,\n computed,\n generator,\n async\n };\n const defs = NODE_FIELDS.ObjectMethod;\n validate(defs.kind, node, \"kind\", kind);\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.generator, node, \"generator\", generator);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction objectProperty(key, value, computed = false, shorthand = false, decorators = null) {\n const node = {\n type: \"ObjectProperty\",\n key,\n value,\n computed,\n shorthand,\n decorators\n };\n const defs = NODE_FIELDS.ObjectProperty;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.shorthand, node, \"shorthand\", shorthand);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n return node;\n}\nfunction restElement(argument) {\n const node = {\n type: \"RestElement\",\n argument\n };\n const defs = NODE_FIELDS.RestElement;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction returnStatement(argument = null) {\n const node = {\n type: \"ReturnStatement\",\n argument\n };\n const defs = NODE_FIELDS.ReturnStatement;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction sequenceExpression(expressions) {\n const node = {\n type: \"SequenceExpression\",\n expressions\n };\n const defs = NODE_FIELDS.SequenceExpression;\n validate(defs.expressions, node, \"expressions\", expressions, 1);\n return node;\n}\nfunction parenthesizedExpression(expression) {\n const node = {\n type: \"ParenthesizedExpression\",\n expression\n };\n const defs = NODE_FIELDS.ParenthesizedExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction switchCase(test = null, consequent) {\n const node = {\n type: \"SwitchCase\",\n test,\n consequent\n };\n const defs = NODE_FIELDS.SwitchCase;\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.consequent, node, \"consequent\", consequent, 1);\n return node;\n}\nfunction switchStatement(discriminant, cases) {\n const node = {\n type: \"SwitchStatement\",\n discriminant,\n cases\n };\n const defs = NODE_FIELDS.SwitchStatement;\n validate(defs.discriminant, node, \"discriminant\", discriminant, 1);\n validate(defs.cases, node, \"cases\", cases, 1);\n return node;\n}\nfunction thisExpression() {\n return {\n type: \"ThisExpression\"\n };\n}\nfunction throwStatement(argument) {\n const node = {\n type: \"ThrowStatement\",\n argument\n };\n const defs = NODE_FIELDS.ThrowStatement;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction tryStatement(block, handler = null, finalizer = null) {\n const node = {\n type: \"TryStatement\",\n block,\n handler,\n finalizer\n };\n const defs = NODE_FIELDS.TryStatement;\n validate(defs.block, node, \"block\", block, 1);\n validate(defs.handler, node, \"handler\", handler, 1);\n validate(defs.finalizer, node, \"finalizer\", finalizer, 1);\n return node;\n}\nfunction unaryExpression(operator, argument, prefix = true) {\n const node = {\n type: \"UnaryExpression\",\n operator,\n argument,\n prefix\n };\n const defs = NODE_FIELDS.UnaryExpression;\n validate(defs.operator, node, \"operator\", operator);\n validate(defs.argument, node, \"argument\", argument, 1);\n validate(defs.prefix, node, \"prefix\", prefix);\n return node;\n}\nfunction updateExpression(operator, argument, prefix = false) {\n const node = {\n type: \"UpdateExpression\",\n operator,\n argument,\n prefix\n };\n const defs = NODE_FIELDS.UpdateExpression;\n validate(defs.operator, node, \"operator\", operator);\n validate(defs.argument, node, \"argument\", argument, 1);\n validate(defs.prefix, node, \"prefix\", prefix);\n return node;\n}\nfunction variableDeclaration(kind, declarations) {\n const node = {\n type: \"VariableDeclaration\",\n kind,\n declarations\n };\n const defs = NODE_FIELDS.VariableDeclaration;\n validate(defs.kind, node, \"kind\", kind);\n validate(defs.declarations, node, \"declarations\", declarations, 1);\n return node;\n}\nfunction variableDeclarator(id, init = null) {\n const node = {\n type: \"VariableDeclarator\",\n id,\n init\n };\n const defs = NODE_FIELDS.VariableDeclarator;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.init, node, \"init\", init, 1);\n return node;\n}\nfunction whileStatement(test, body) {\n const node = {\n type: \"WhileStatement\",\n test,\n body\n };\n const defs = NODE_FIELDS.WhileStatement;\n validate(defs.test, node, \"test\", test, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction withStatement(object, body) {\n const node = {\n type: \"WithStatement\",\n object,\n body\n };\n const defs = NODE_FIELDS.WithStatement;\n validate(defs.object, node, \"object\", object, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction assignmentPattern(left, right) {\n const node = {\n type: \"AssignmentPattern\",\n left,\n right\n };\n const defs = NODE_FIELDS.AssignmentPattern;\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction arrayPattern(elements) {\n const node = {\n type: \"ArrayPattern\",\n elements\n };\n const defs = NODE_FIELDS.ArrayPattern;\n validate(defs.elements, node, \"elements\", elements, 1);\n return node;\n}\nfunction arrowFunctionExpression(params, body, async = false) {\n const node = {\n type: \"ArrowFunctionExpression\",\n params,\n body,\n async,\n expression: null\n };\n const defs = NODE_FIELDS.ArrowFunctionExpression;\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction classBody(body) {\n const node = {\n type: \"ClassBody\",\n body\n };\n const defs = NODE_FIELDS.ClassBody;\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction classExpression(id = null, superClass = null, body, decorators = null) {\n const node = {\n type: \"ClassExpression\",\n id,\n superClass,\n body,\n decorators\n };\n const defs = NODE_FIELDS.ClassExpression;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.superClass, node, \"superClass\", superClass, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n return node;\n}\nfunction classDeclaration(id = null, superClass = null, body, decorators = null) {\n const node = {\n type: \"ClassDeclaration\",\n id,\n superClass,\n body,\n decorators\n };\n const defs = NODE_FIELDS.ClassDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.superClass, node, \"superClass\", superClass, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n return node;\n}\nfunction exportAllDeclaration(source, attributes = null) {\n const node = {\n type: \"ExportAllDeclaration\",\n source,\n attributes\n };\n const defs = NODE_FIELDS.ExportAllDeclaration;\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n return node;\n}\nfunction exportDefaultDeclaration(declaration) {\n const node = {\n type: \"ExportDefaultDeclaration\",\n declaration\n };\n const defs = NODE_FIELDS.ExportDefaultDeclaration;\n validate(defs.declaration, node, \"declaration\", declaration, 1);\n return node;\n}\nfunction exportNamedDeclaration(declaration = null, specifiers = [], source = null, attributes = null) {\n const node = {\n type: \"ExportNamedDeclaration\",\n declaration,\n specifiers,\n source,\n attributes\n };\n const defs = NODE_FIELDS.ExportNamedDeclaration;\n validate(defs.declaration, node, \"declaration\", declaration, 1);\n validate(defs.specifiers, node, \"specifiers\", specifiers, 1);\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n return node;\n}\nfunction exportSpecifier(local, exported) {\n const node = {\n type: \"ExportSpecifier\",\n local,\n exported\n };\n const defs = NODE_FIELDS.ExportSpecifier;\n validate(defs.local, node, \"local\", local, 1);\n validate(defs.exported, node, \"exported\", exported, 1);\n return node;\n}\nfunction forOfStatement(left, right, body, _await = false) {\n const node = {\n type: \"ForOfStatement\",\n left,\n right,\n body,\n await: _await\n };\n const defs = NODE_FIELDS.ForOfStatement;\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.await, node, \"await\", _await);\n return node;\n}\nfunction importDeclaration(specifiers, source, attributes = null) {\n const node = {\n type: \"ImportDeclaration\",\n specifiers,\n source,\n attributes\n };\n const defs = NODE_FIELDS.ImportDeclaration;\n validate(defs.specifiers, node, \"specifiers\", specifiers, 1);\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n return node;\n}\nfunction importDefaultSpecifier(local) {\n const node = {\n type: \"ImportDefaultSpecifier\",\n local\n };\n const defs = NODE_FIELDS.ImportDefaultSpecifier;\n validate(defs.local, node, \"local\", local, 1);\n return node;\n}\nfunction importNamespaceSpecifier(local) {\n const node = {\n type: \"ImportNamespaceSpecifier\",\n local\n };\n const defs = NODE_FIELDS.ImportNamespaceSpecifier;\n validate(defs.local, node, \"local\", local, 1);\n return node;\n}\nfunction importSpecifier(local, imported) {\n const node = {\n type: \"ImportSpecifier\",\n local,\n imported\n };\n const defs = NODE_FIELDS.ImportSpecifier;\n validate(defs.local, node, \"local\", local, 1);\n validate(defs.imported, node, \"imported\", imported, 1);\n return node;\n}\nfunction importExpression(source, options = null) {\n const node = {\n type: \"ImportExpression\",\n source,\n options\n };\n const defs = NODE_FIELDS.ImportExpression;\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.options, node, \"options\", options, 1);\n return node;\n}\nfunction metaProperty(meta, property) {\n const node = {\n type: \"MetaProperty\",\n meta,\n property\n };\n const defs = NODE_FIELDS.MetaProperty;\n validate(defs.meta, node, \"meta\", meta, 1);\n validate(defs.property, node, \"property\", property, 1);\n return node;\n}\nfunction classMethod(kind = \"method\", key, params, body, computed = false, _static = false, generator = false, async = false) {\n const node = {\n type: \"ClassMethod\",\n kind,\n key,\n params,\n body,\n computed,\n static: _static,\n generator,\n async\n };\n const defs = NODE_FIELDS.ClassMethod;\n validate(defs.kind, node, \"kind\", kind);\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.static, node, \"static\", _static);\n validate(defs.generator, node, \"generator\", generator);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction objectPattern(properties) {\n const node = {\n type: \"ObjectPattern\",\n properties\n };\n const defs = NODE_FIELDS.ObjectPattern;\n validate(defs.properties, node, \"properties\", properties, 1);\n return node;\n}\nfunction spreadElement(argument) {\n const node = {\n type: \"SpreadElement\",\n argument\n };\n const defs = NODE_FIELDS.SpreadElement;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction _super() {\n return {\n type: \"Super\"\n };\n}\nfunction taggedTemplateExpression(tag, quasi) {\n const node = {\n type: \"TaggedTemplateExpression\",\n tag,\n quasi\n };\n const defs = NODE_FIELDS.TaggedTemplateExpression;\n validate(defs.tag, node, \"tag\", tag, 1);\n validate(defs.quasi, node, \"quasi\", quasi, 1);\n return node;\n}\nfunction templateElement(value, tail = false) {\n const node = {\n type: \"TemplateElement\",\n value,\n tail\n };\n const defs = NODE_FIELDS.TemplateElement;\n validate(defs.value, node, \"value\", value);\n validate(defs.tail, node, \"tail\", tail);\n return node;\n}\nfunction templateLiteral(quasis, expressions) {\n const node = {\n type: \"TemplateLiteral\",\n quasis,\n expressions\n };\n const defs = NODE_FIELDS.TemplateLiteral;\n validate(defs.quasis, node, \"quasis\", quasis, 1);\n validate(defs.expressions, node, \"expressions\", expressions, 1);\n return node;\n}\nfunction yieldExpression(argument = null, delegate = false) {\n const node = {\n type: \"YieldExpression\",\n argument,\n delegate\n };\n const defs = NODE_FIELDS.YieldExpression;\n validate(defs.argument, node, \"argument\", argument, 1);\n validate(defs.delegate, node, \"delegate\", delegate);\n return node;\n}\nfunction awaitExpression(argument) {\n const node = {\n type: \"AwaitExpression\",\n argument\n };\n const defs = NODE_FIELDS.AwaitExpression;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction _import() {\n return {\n type: \"Import\"\n };\n}\nfunction exportNamespaceSpecifier(exported) {\n const node = {\n type: \"ExportNamespaceSpecifier\",\n exported\n };\n const defs = NODE_FIELDS.ExportNamespaceSpecifier;\n validate(defs.exported, node, \"exported\", exported, 1);\n return node;\n}\nfunction optionalMemberExpression(object, property, computed = false, optional) {\n const node = {\n type: \"OptionalMemberExpression\",\n object,\n property,\n computed,\n optional\n };\n const defs = NODE_FIELDS.OptionalMemberExpression;\n validate(defs.object, node, \"object\", object, 1);\n validate(defs.property, node, \"property\", property, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.optional, node, \"optional\", optional);\n return node;\n}\nfunction optionalCallExpression(callee, _arguments, optional) {\n const node = {\n type: \"OptionalCallExpression\",\n callee,\n arguments: _arguments,\n optional\n };\n const defs = NODE_FIELDS.OptionalCallExpression;\n validate(defs.callee, node, \"callee\", callee, 1);\n validate(defs.arguments, node, \"arguments\", _arguments, 1);\n validate(defs.optional, node, \"optional\", optional);\n return node;\n}\nfunction classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {\n const node = {\n type: \"ClassProperty\",\n key,\n value,\n typeAnnotation,\n decorators,\n computed,\n static: _static\n };\n const defs = NODE_FIELDS.ClassProperty;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.static, node, \"static\", _static);\n return node;\n}\nfunction classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {\n const node = {\n type: \"ClassAccessorProperty\",\n key,\n value,\n typeAnnotation,\n decorators,\n computed,\n static: _static\n };\n const defs = NODE_FIELDS.ClassAccessorProperty;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n validate(defs.computed, node, \"computed\", computed);\n validate(defs.static, node, \"static\", _static);\n return node;\n}\nfunction classPrivateProperty(key, value = null, decorators = null, _static = false) {\n const node = {\n type: \"ClassPrivateProperty\",\n key,\n value,\n decorators,\n static: _static\n };\n const defs = NODE_FIELDS.ClassPrivateProperty;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n validate(defs.static, node, \"static\", _static);\n return node;\n}\nfunction classPrivateMethod(kind = \"method\", key, params, body, _static = false) {\n const node = {\n type: \"ClassPrivateMethod\",\n kind,\n key,\n params,\n body,\n static: _static\n };\n const defs = NODE_FIELDS.ClassPrivateMethod;\n validate(defs.kind, node, \"kind\", kind);\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.static, node, \"static\", _static);\n return node;\n}\nfunction privateName(id) {\n const node = {\n type: \"PrivateName\",\n id\n };\n const defs = NODE_FIELDS.PrivateName;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction staticBlock(body) {\n const node = {\n type: \"StaticBlock\",\n body\n };\n const defs = NODE_FIELDS.StaticBlock;\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction importAttribute(key, value) {\n const node = {\n type: \"ImportAttribute\",\n key,\n value\n };\n const defs = NODE_FIELDS.ImportAttribute;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n return node;\n}\nfunction anyTypeAnnotation() {\n return {\n type: \"AnyTypeAnnotation\"\n };\n}\nfunction arrayTypeAnnotation(elementType) {\n const node = {\n type: \"ArrayTypeAnnotation\",\n elementType\n };\n const defs = NODE_FIELDS.ArrayTypeAnnotation;\n validate(defs.elementType, node, \"elementType\", elementType, 1);\n return node;\n}\nfunction booleanTypeAnnotation() {\n return {\n type: \"BooleanTypeAnnotation\"\n };\n}\nfunction booleanLiteralTypeAnnotation(value) {\n const node = {\n type: \"BooleanLiteralTypeAnnotation\",\n value\n };\n const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction nullLiteralTypeAnnotation() {\n return {\n type: \"NullLiteralTypeAnnotation\"\n };\n}\nfunction classImplements(id, typeParameters = null) {\n const node = {\n type: \"ClassImplements\",\n id,\n typeParameters\n };\n const defs = NODE_FIELDS.ClassImplements;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction declareClass(id, typeParameters = null, _extends = null, body) {\n const node = {\n type: \"DeclareClass\",\n id,\n typeParameters,\n extends: _extends,\n body\n };\n const defs = NODE_FIELDS.DeclareClass;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.extends, node, \"extends\", _extends, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction declareFunction(id) {\n const node = {\n type: \"DeclareFunction\",\n id\n };\n const defs = NODE_FIELDS.DeclareFunction;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction declareInterface(id, typeParameters = null, _extends = null, body) {\n const node = {\n type: \"DeclareInterface\",\n id,\n typeParameters,\n extends: _extends,\n body\n };\n const defs = NODE_FIELDS.DeclareInterface;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.extends, node, \"extends\", _extends, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction declareModule(id, body, kind = null) {\n const node = {\n type: \"DeclareModule\",\n id,\n body,\n kind\n };\n const defs = NODE_FIELDS.DeclareModule;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.kind, node, \"kind\", kind);\n return node;\n}\nfunction declareModuleExports(typeAnnotation) {\n const node = {\n type: \"DeclareModuleExports\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.DeclareModuleExports;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction declareTypeAlias(id, typeParameters = null, right) {\n const node = {\n type: \"DeclareTypeAlias\",\n id,\n typeParameters,\n right\n };\n const defs = NODE_FIELDS.DeclareTypeAlias;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction declareOpaqueType(id, typeParameters = null, supertype = null) {\n const node = {\n type: \"DeclareOpaqueType\",\n id,\n typeParameters,\n supertype\n };\n const defs = NODE_FIELDS.DeclareOpaqueType;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.supertype, node, \"supertype\", supertype, 1);\n return node;\n}\nfunction declareVariable(id) {\n const node = {\n type: \"DeclareVariable\",\n id\n };\n const defs = NODE_FIELDS.DeclareVariable;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction declareExportDeclaration(declaration = null, specifiers = null, source = null, attributes = null) {\n const node = {\n type: \"DeclareExportDeclaration\",\n declaration,\n specifiers,\n source,\n attributes\n };\n const defs = NODE_FIELDS.DeclareExportDeclaration;\n validate(defs.declaration, node, \"declaration\", declaration, 1);\n validate(defs.specifiers, node, \"specifiers\", specifiers, 1);\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n return node;\n}\nfunction declareExportAllDeclaration(source, attributes = null) {\n const node = {\n type: \"DeclareExportAllDeclaration\",\n source,\n attributes\n };\n const defs = NODE_FIELDS.DeclareExportAllDeclaration;\n validate(defs.source, node, \"source\", source, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n return node;\n}\nfunction declaredPredicate(value) {\n const node = {\n type: \"DeclaredPredicate\",\n value\n };\n const defs = NODE_FIELDS.DeclaredPredicate;\n validate(defs.value, node, \"value\", value, 1);\n return node;\n}\nfunction existsTypeAnnotation() {\n return {\n type: \"ExistsTypeAnnotation\"\n };\n}\nfunction functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {\n const node = {\n type: \"FunctionTypeAnnotation\",\n typeParameters,\n params,\n rest,\n returnType\n };\n const defs = NODE_FIELDS.FunctionTypeAnnotation;\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.rest, node, \"rest\", rest, 1);\n validate(defs.returnType, node, \"returnType\", returnType, 1);\n return node;\n}\nfunction functionTypeParam(name = null, typeAnnotation) {\n const node = {\n type: \"FunctionTypeParam\",\n name,\n typeAnnotation\n };\n const defs = NODE_FIELDS.FunctionTypeParam;\n validate(defs.name, node, \"name\", name, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction genericTypeAnnotation(id, typeParameters = null) {\n const node = {\n type: \"GenericTypeAnnotation\",\n id,\n typeParameters\n };\n const defs = NODE_FIELDS.GenericTypeAnnotation;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction inferredPredicate() {\n return {\n type: \"InferredPredicate\"\n };\n}\nfunction interfaceExtends(id, typeParameters = null) {\n const node = {\n type: \"InterfaceExtends\",\n id,\n typeParameters\n };\n const defs = NODE_FIELDS.InterfaceExtends;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction interfaceDeclaration(id, typeParameters = null, _extends = null, body) {\n const node = {\n type: \"InterfaceDeclaration\",\n id,\n typeParameters,\n extends: _extends,\n body\n };\n const defs = NODE_FIELDS.InterfaceDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.extends, node, \"extends\", _extends, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction interfaceTypeAnnotation(_extends = null, body) {\n const node = {\n type: \"InterfaceTypeAnnotation\",\n extends: _extends,\n body\n };\n const defs = NODE_FIELDS.InterfaceTypeAnnotation;\n validate(defs.extends, node, \"extends\", _extends, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction intersectionTypeAnnotation(types) {\n const node = {\n type: \"IntersectionTypeAnnotation\",\n types\n };\n const defs = NODE_FIELDS.IntersectionTypeAnnotation;\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction mixedTypeAnnotation() {\n return {\n type: \"MixedTypeAnnotation\"\n };\n}\nfunction emptyTypeAnnotation() {\n return {\n type: \"EmptyTypeAnnotation\"\n };\n}\nfunction nullableTypeAnnotation(typeAnnotation) {\n const node = {\n type: \"NullableTypeAnnotation\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.NullableTypeAnnotation;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction numberLiteralTypeAnnotation(value) {\n const node = {\n type: \"NumberLiteralTypeAnnotation\",\n value\n };\n const defs = NODE_FIELDS.NumberLiteralTypeAnnotation;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction numberTypeAnnotation() {\n return {\n type: \"NumberTypeAnnotation\"\n };\n}\nfunction objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {\n const node = {\n type: \"ObjectTypeAnnotation\",\n properties,\n indexers,\n callProperties,\n internalSlots,\n exact\n };\n const defs = NODE_FIELDS.ObjectTypeAnnotation;\n validate(defs.properties, node, \"properties\", properties, 1);\n validate(defs.indexers, node, \"indexers\", indexers, 1);\n validate(defs.callProperties, node, \"callProperties\", callProperties, 1);\n validate(defs.internalSlots, node, \"internalSlots\", internalSlots, 1);\n validate(defs.exact, node, \"exact\", exact);\n return node;\n}\nfunction objectTypeInternalSlot(id, value, optional, _static, method) {\n const node = {\n type: \"ObjectTypeInternalSlot\",\n id,\n value,\n optional,\n static: _static,\n method\n };\n const defs = NODE_FIELDS.ObjectTypeInternalSlot;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.optional, node, \"optional\", optional);\n validate(defs.static, node, \"static\", _static);\n validate(defs.method, node, \"method\", method);\n return node;\n}\nfunction objectTypeCallProperty(value) {\n const node = {\n type: \"ObjectTypeCallProperty\",\n value,\n static: null\n };\n const defs = NODE_FIELDS.ObjectTypeCallProperty;\n validate(defs.value, node, \"value\", value, 1);\n return node;\n}\nfunction objectTypeIndexer(id = null, key, value, variance = null) {\n const node = {\n type: \"ObjectTypeIndexer\",\n id,\n key,\n value,\n variance,\n static: null\n };\n const defs = NODE_FIELDS.ObjectTypeIndexer;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.variance, node, \"variance\", variance, 1);\n return node;\n}\nfunction objectTypeProperty(key, value, variance = null) {\n const node = {\n type: \"ObjectTypeProperty\",\n key,\n value,\n variance,\n kind: null,\n method: null,\n optional: null,\n proto: null,\n static: null\n };\n const defs = NODE_FIELDS.ObjectTypeProperty;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.value, node, \"value\", value, 1);\n validate(defs.variance, node, \"variance\", variance, 1);\n return node;\n}\nfunction objectTypeSpreadProperty(argument) {\n const node = {\n type: \"ObjectTypeSpreadProperty\",\n argument\n };\n const defs = NODE_FIELDS.ObjectTypeSpreadProperty;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction opaqueType(id, typeParameters = null, supertype = null, impltype) {\n const node = {\n type: \"OpaqueType\",\n id,\n typeParameters,\n supertype,\n impltype\n };\n const defs = NODE_FIELDS.OpaqueType;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.supertype, node, \"supertype\", supertype, 1);\n validate(defs.impltype, node, \"impltype\", impltype, 1);\n return node;\n}\nfunction qualifiedTypeIdentifier(id, qualification) {\n const node = {\n type: \"QualifiedTypeIdentifier\",\n id,\n qualification\n };\n const defs = NODE_FIELDS.QualifiedTypeIdentifier;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.qualification, node, \"qualification\", qualification, 1);\n return node;\n}\nfunction stringLiteralTypeAnnotation(value) {\n const node = {\n type: \"StringLiteralTypeAnnotation\",\n value\n };\n const defs = NODE_FIELDS.StringLiteralTypeAnnotation;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction stringTypeAnnotation() {\n return {\n type: \"StringTypeAnnotation\"\n };\n}\nfunction symbolTypeAnnotation() {\n return {\n type: \"SymbolTypeAnnotation\"\n };\n}\nfunction thisTypeAnnotation() {\n return {\n type: \"ThisTypeAnnotation\"\n };\n}\nfunction tupleTypeAnnotation(types) {\n const node = {\n type: \"TupleTypeAnnotation\",\n types\n };\n const defs = NODE_FIELDS.TupleTypeAnnotation;\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction typeofTypeAnnotation(argument) {\n const node = {\n type: \"TypeofTypeAnnotation\",\n argument\n };\n const defs = NODE_FIELDS.TypeofTypeAnnotation;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction typeAlias(id, typeParameters = null, right) {\n const node = {\n type: \"TypeAlias\",\n id,\n typeParameters,\n right\n };\n const defs = NODE_FIELDS.TypeAlias;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction typeAnnotation(typeAnnotation) {\n const node = {\n type: \"TypeAnnotation\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.TypeAnnotation;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction typeCastExpression(expression, typeAnnotation) {\n const node = {\n type: \"TypeCastExpression\",\n expression,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TypeCastExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction typeParameter(bound = null, _default = null, variance = null) {\n const node = {\n type: \"TypeParameter\",\n bound,\n default: _default,\n variance,\n name: null\n };\n const defs = NODE_FIELDS.TypeParameter;\n validate(defs.bound, node, \"bound\", bound, 1);\n validate(defs.default, node, \"default\", _default, 1);\n validate(defs.variance, node, \"variance\", variance, 1);\n return node;\n}\nfunction typeParameterDeclaration(params) {\n const node = {\n type: \"TypeParameterDeclaration\",\n params\n };\n const defs = NODE_FIELDS.TypeParameterDeclaration;\n validate(defs.params, node, \"params\", params, 1);\n return node;\n}\nfunction typeParameterInstantiation(params) {\n const node = {\n type: \"TypeParameterInstantiation\",\n params\n };\n const defs = NODE_FIELDS.TypeParameterInstantiation;\n validate(defs.params, node, \"params\", params, 1);\n return node;\n}\nfunction unionTypeAnnotation(types) {\n const node = {\n type: \"UnionTypeAnnotation\",\n types\n };\n const defs = NODE_FIELDS.UnionTypeAnnotation;\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction variance(kind) {\n const node = {\n type: \"Variance\",\n kind\n };\n const defs = NODE_FIELDS.Variance;\n validate(defs.kind, node, \"kind\", kind);\n return node;\n}\nfunction voidTypeAnnotation() {\n return {\n type: \"VoidTypeAnnotation\"\n };\n}\nfunction enumDeclaration(id, body) {\n const node = {\n type: \"EnumDeclaration\",\n id,\n body\n };\n const defs = NODE_FIELDS.EnumDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction enumBooleanBody(members) {\n const node = {\n type: \"EnumBooleanBody\",\n members,\n explicitType: null,\n hasUnknownMembers: null\n };\n const defs = NODE_FIELDS.EnumBooleanBody;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction enumNumberBody(members) {\n const node = {\n type: \"EnumNumberBody\",\n members,\n explicitType: null,\n hasUnknownMembers: null\n };\n const defs = NODE_FIELDS.EnumNumberBody;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction enumStringBody(members) {\n const node = {\n type: \"EnumStringBody\",\n members,\n explicitType: null,\n hasUnknownMembers: null\n };\n const defs = NODE_FIELDS.EnumStringBody;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction enumSymbolBody(members) {\n const node = {\n type: \"EnumSymbolBody\",\n members,\n hasUnknownMembers: null\n };\n const defs = NODE_FIELDS.EnumSymbolBody;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction enumBooleanMember(id) {\n const node = {\n type: \"EnumBooleanMember\",\n id,\n init: null\n };\n const defs = NODE_FIELDS.EnumBooleanMember;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction enumNumberMember(id, init) {\n const node = {\n type: \"EnumNumberMember\",\n id,\n init\n };\n const defs = NODE_FIELDS.EnumNumberMember;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.init, node, \"init\", init, 1);\n return node;\n}\nfunction enumStringMember(id, init) {\n const node = {\n type: \"EnumStringMember\",\n id,\n init\n };\n const defs = NODE_FIELDS.EnumStringMember;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.init, node, \"init\", init, 1);\n return node;\n}\nfunction enumDefaultedMember(id) {\n const node = {\n type: \"EnumDefaultedMember\",\n id\n };\n const defs = NODE_FIELDS.EnumDefaultedMember;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction indexedAccessType(objectType, indexType) {\n const node = {\n type: \"IndexedAccessType\",\n objectType,\n indexType\n };\n const defs = NODE_FIELDS.IndexedAccessType;\n validate(defs.objectType, node, \"objectType\", objectType, 1);\n validate(defs.indexType, node, \"indexType\", indexType, 1);\n return node;\n}\nfunction optionalIndexedAccessType(objectType, indexType) {\n const node = {\n type: \"OptionalIndexedAccessType\",\n objectType,\n indexType,\n optional: null\n };\n const defs = NODE_FIELDS.OptionalIndexedAccessType;\n validate(defs.objectType, node, \"objectType\", objectType, 1);\n validate(defs.indexType, node, \"indexType\", indexType, 1);\n return node;\n}\nfunction jsxAttribute(name, value = null) {\n const node = {\n type: \"JSXAttribute\",\n name,\n value\n };\n const defs = NODE_FIELDS.JSXAttribute;\n validate(defs.name, node, \"name\", name, 1);\n validate(defs.value, node, \"value\", value, 1);\n return node;\n}\nfunction jsxClosingElement(name) {\n const node = {\n type: \"JSXClosingElement\",\n name\n };\n const defs = NODE_FIELDS.JSXClosingElement;\n validate(defs.name, node, \"name\", name, 1);\n return node;\n}\nfunction jsxElement(openingElement, closingElement = null, children, selfClosing = null) {\n const node = {\n type: \"JSXElement\",\n openingElement,\n closingElement,\n children,\n selfClosing\n };\n const defs = NODE_FIELDS.JSXElement;\n validate(defs.openingElement, node, \"openingElement\", openingElement, 1);\n validate(defs.closingElement, node, \"closingElement\", closingElement, 1);\n validate(defs.children, node, \"children\", children, 1);\n validate(defs.selfClosing, node, \"selfClosing\", selfClosing);\n return node;\n}\nfunction jsxEmptyExpression() {\n return {\n type: \"JSXEmptyExpression\"\n };\n}\nfunction jsxExpressionContainer(expression) {\n const node = {\n type: \"JSXExpressionContainer\",\n expression\n };\n const defs = NODE_FIELDS.JSXExpressionContainer;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction jsxSpreadChild(expression) {\n const node = {\n type: \"JSXSpreadChild\",\n expression\n };\n const defs = NODE_FIELDS.JSXSpreadChild;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction jsxIdentifier(name) {\n const node = {\n type: \"JSXIdentifier\",\n name\n };\n const defs = NODE_FIELDS.JSXIdentifier;\n validate(defs.name, node, \"name\", name);\n return node;\n}\nfunction jsxMemberExpression(object, property) {\n const node = {\n type: \"JSXMemberExpression\",\n object,\n property\n };\n const defs = NODE_FIELDS.JSXMemberExpression;\n validate(defs.object, node, \"object\", object, 1);\n validate(defs.property, node, \"property\", property, 1);\n return node;\n}\nfunction jsxNamespacedName(namespace, name) {\n const node = {\n type: \"JSXNamespacedName\",\n namespace,\n name\n };\n const defs = NODE_FIELDS.JSXNamespacedName;\n validate(defs.namespace, node, \"namespace\", namespace, 1);\n validate(defs.name, node, \"name\", name, 1);\n return node;\n}\nfunction jsxOpeningElement(name, attributes, selfClosing = false) {\n const node = {\n type: \"JSXOpeningElement\",\n name,\n attributes,\n selfClosing\n };\n const defs = NODE_FIELDS.JSXOpeningElement;\n validate(defs.name, node, \"name\", name, 1);\n validate(defs.attributes, node, \"attributes\", attributes, 1);\n validate(defs.selfClosing, node, \"selfClosing\", selfClosing);\n return node;\n}\nfunction jsxSpreadAttribute(argument) {\n const node = {\n type: \"JSXSpreadAttribute\",\n argument\n };\n const defs = NODE_FIELDS.JSXSpreadAttribute;\n validate(defs.argument, node, \"argument\", argument, 1);\n return node;\n}\nfunction jsxText(value) {\n const node = {\n type: \"JSXText\",\n value\n };\n const defs = NODE_FIELDS.JSXText;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction jsxFragment(openingFragment, closingFragment, children) {\n const node = {\n type: \"JSXFragment\",\n openingFragment,\n closingFragment,\n children\n };\n const defs = NODE_FIELDS.JSXFragment;\n validate(defs.openingFragment, node, \"openingFragment\", openingFragment, 1);\n validate(defs.closingFragment, node, \"closingFragment\", closingFragment, 1);\n validate(defs.children, node, \"children\", children, 1);\n return node;\n}\nfunction jsxOpeningFragment() {\n return {\n type: \"JSXOpeningFragment\"\n };\n}\nfunction jsxClosingFragment() {\n return {\n type: \"JSXClosingFragment\"\n };\n}\nfunction noop() {\n return {\n type: \"Noop\"\n };\n}\nfunction placeholder(expectedNode, name) {\n const node = {\n type: \"Placeholder\",\n expectedNode,\n name\n };\n const defs = NODE_FIELDS.Placeholder;\n validate(defs.expectedNode, node, \"expectedNode\", expectedNode);\n validate(defs.name, node, \"name\", name, 1);\n return node;\n}\nfunction v8IntrinsicIdentifier(name) {\n const node = {\n type: \"V8IntrinsicIdentifier\",\n name\n };\n const defs = NODE_FIELDS.V8IntrinsicIdentifier;\n validate(defs.name, node, \"name\", name);\n return node;\n}\nfunction argumentPlaceholder() {\n return {\n type: \"ArgumentPlaceholder\"\n };\n}\nfunction bindExpression(object, callee) {\n const node = {\n type: \"BindExpression\",\n object,\n callee\n };\n const defs = NODE_FIELDS.BindExpression;\n validate(defs.object, node, \"object\", object, 1);\n validate(defs.callee, node, \"callee\", callee, 1);\n return node;\n}\nfunction decorator(expression) {\n const node = {\n type: \"Decorator\",\n expression\n };\n const defs = NODE_FIELDS.Decorator;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction doExpression(body, async = false) {\n const node = {\n type: \"DoExpression\",\n body,\n async\n };\n const defs = NODE_FIELDS.DoExpression;\n validate(defs.body, node, \"body\", body, 1);\n validate(defs.async, node, \"async\", async);\n return node;\n}\nfunction exportDefaultSpecifier(exported) {\n const node = {\n type: \"ExportDefaultSpecifier\",\n exported\n };\n const defs = NODE_FIELDS.ExportDefaultSpecifier;\n validate(defs.exported, node, \"exported\", exported, 1);\n return node;\n}\nfunction recordExpression(properties) {\n const node = {\n type: \"RecordExpression\",\n properties\n };\n const defs = NODE_FIELDS.RecordExpression;\n validate(defs.properties, node, \"properties\", properties, 1);\n return node;\n}\nfunction tupleExpression(elements = []) {\n const node = {\n type: \"TupleExpression\",\n elements\n };\n const defs = NODE_FIELDS.TupleExpression;\n validate(defs.elements, node, \"elements\", elements, 1);\n return node;\n}\nfunction decimalLiteral(value) {\n const node = {\n type: \"DecimalLiteral\",\n value\n };\n const defs = NODE_FIELDS.DecimalLiteral;\n validate(defs.value, node, \"value\", value);\n return node;\n}\nfunction moduleExpression(body) {\n const node = {\n type: \"ModuleExpression\",\n body\n };\n const defs = NODE_FIELDS.ModuleExpression;\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction topicReference() {\n return {\n type: \"TopicReference\"\n };\n}\nfunction pipelineTopicExpression(expression) {\n const node = {\n type: \"PipelineTopicExpression\",\n expression\n };\n const defs = NODE_FIELDS.PipelineTopicExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction pipelineBareFunction(callee) {\n const node = {\n type: \"PipelineBareFunction\",\n callee\n };\n const defs = NODE_FIELDS.PipelineBareFunction;\n validate(defs.callee, node, \"callee\", callee, 1);\n return node;\n}\nfunction pipelinePrimaryTopicReference() {\n return {\n type: \"PipelinePrimaryTopicReference\"\n };\n}\nfunction voidPattern() {\n return {\n type: \"VoidPattern\"\n };\n}\nfunction tsParameterProperty(parameter) {\n const node = {\n type: \"TSParameterProperty\",\n parameter\n };\n const defs = NODE_FIELDS.TSParameterProperty;\n validate(defs.parameter, node, \"parameter\", parameter, 1);\n return node;\n}\nfunction tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {\n const node = {\n type: \"TSDeclareFunction\",\n id,\n typeParameters,\n params,\n returnType\n };\n const defs = NODE_FIELDS.TSDeclareFunction;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.returnType, node, \"returnType\", returnType, 1);\n return node;\n}\nfunction tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {\n const node = {\n type: \"TSDeclareMethod\",\n decorators,\n key,\n typeParameters,\n params,\n returnType\n };\n const defs = NODE_FIELDS.TSDeclareMethod;\n validate(defs.decorators, node, \"decorators\", decorators, 1);\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.params, node, \"params\", params, 1);\n validate(defs.returnType, node, \"returnType\", returnType, 1);\n return node;\n}\nfunction tsQualifiedName(left, right) {\n const node = {\n type: \"TSQualifiedName\",\n left,\n right\n };\n const defs = NODE_FIELDS.TSQualifiedName;\n validate(defs.left, node, \"left\", left, 1);\n validate(defs.right, node, \"right\", right, 1);\n return node;\n}\nfunction tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {\n const node = {\n type: \"TSCallSignatureDeclaration\",\n typeParameters,\n parameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSCallSignatureDeclaration;\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {\n const node = {\n type: \"TSConstructSignatureDeclaration\",\n typeParameters,\n parameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSConstructSignatureDeclaration;\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsPropertySignature(key, typeAnnotation = null) {\n const node = {\n type: \"TSPropertySignature\",\n key,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSPropertySignature;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {\n const node = {\n type: \"TSMethodSignature\",\n key,\n typeParameters,\n parameters,\n typeAnnotation,\n kind: null\n };\n const defs = NODE_FIELDS.TSMethodSignature;\n validate(defs.key, node, \"key\", key, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsIndexSignature(parameters, typeAnnotation = null) {\n const node = {\n type: \"TSIndexSignature\",\n parameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSIndexSignature;\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsAnyKeyword() {\n return {\n type: \"TSAnyKeyword\"\n };\n}\nfunction tsBooleanKeyword() {\n return {\n type: \"TSBooleanKeyword\"\n };\n}\nfunction tsBigIntKeyword() {\n return {\n type: \"TSBigIntKeyword\"\n };\n}\nfunction tsIntrinsicKeyword() {\n return {\n type: \"TSIntrinsicKeyword\"\n };\n}\nfunction tsNeverKeyword() {\n return {\n type: \"TSNeverKeyword\"\n };\n}\nfunction tsNullKeyword() {\n return {\n type: \"TSNullKeyword\"\n };\n}\nfunction tsNumberKeyword() {\n return {\n type: \"TSNumberKeyword\"\n };\n}\nfunction tsObjectKeyword() {\n return {\n type: \"TSObjectKeyword\"\n };\n}\nfunction tsStringKeyword() {\n return {\n type: \"TSStringKeyword\"\n };\n}\nfunction tsSymbolKeyword() {\n return {\n type: \"TSSymbolKeyword\"\n };\n}\nfunction tsUndefinedKeyword() {\n return {\n type: \"TSUndefinedKeyword\"\n };\n}\nfunction tsUnknownKeyword() {\n return {\n type: \"TSUnknownKeyword\"\n };\n}\nfunction tsVoidKeyword() {\n return {\n type: \"TSVoidKeyword\"\n };\n}\nfunction tsThisType() {\n return {\n type: \"TSThisType\"\n };\n}\nfunction tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {\n const node = {\n type: \"TSFunctionType\",\n typeParameters,\n parameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSFunctionType;\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {\n const node = {\n type: \"TSConstructorType\",\n typeParameters,\n parameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSConstructorType;\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.parameters, node, \"parameters\", parameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsTypeReference(typeName, typeParameters = null) {\n const node = {\n type: \"TSTypeReference\",\n typeName,\n typeParameters\n };\n const defs = NODE_FIELDS.TSTypeReference;\n validate(defs.typeName, node, \"typeName\", typeName, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {\n const node = {\n type: \"TSTypePredicate\",\n parameterName,\n typeAnnotation,\n asserts\n };\n const defs = NODE_FIELDS.TSTypePredicate;\n validate(defs.parameterName, node, \"parameterName\", parameterName, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.asserts, node, \"asserts\", asserts);\n return node;\n}\nfunction tsTypeQuery(exprName, typeParameters = null) {\n const node = {\n type: \"TSTypeQuery\",\n exprName,\n typeParameters\n };\n const defs = NODE_FIELDS.TSTypeQuery;\n validate(defs.exprName, node, \"exprName\", exprName, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction tsTypeLiteral(members) {\n const node = {\n type: \"TSTypeLiteral\",\n members\n };\n const defs = NODE_FIELDS.TSTypeLiteral;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction tsArrayType(elementType) {\n const node = {\n type: \"TSArrayType\",\n elementType\n };\n const defs = NODE_FIELDS.TSArrayType;\n validate(defs.elementType, node, \"elementType\", elementType, 1);\n return node;\n}\nfunction tsTupleType(elementTypes) {\n const node = {\n type: \"TSTupleType\",\n elementTypes\n };\n const defs = NODE_FIELDS.TSTupleType;\n validate(defs.elementTypes, node, \"elementTypes\", elementTypes, 1);\n return node;\n}\nfunction tsOptionalType(typeAnnotation) {\n const node = {\n type: \"TSOptionalType\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSOptionalType;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsRestType(typeAnnotation) {\n const node = {\n type: \"TSRestType\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSRestType;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsNamedTupleMember(label, elementType, optional = false) {\n const node = {\n type: \"TSNamedTupleMember\",\n label,\n elementType,\n optional\n };\n const defs = NODE_FIELDS.TSNamedTupleMember;\n validate(defs.label, node, \"label\", label, 1);\n validate(defs.elementType, node, \"elementType\", elementType, 1);\n validate(defs.optional, node, \"optional\", optional);\n return node;\n}\nfunction tsUnionType(types) {\n const node = {\n type: \"TSUnionType\",\n types\n };\n const defs = NODE_FIELDS.TSUnionType;\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction tsIntersectionType(types) {\n const node = {\n type: \"TSIntersectionType\",\n types\n };\n const defs = NODE_FIELDS.TSIntersectionType;\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction tsConditionalType(checkType, extendsType, trueType, falseType) {\n const node = {\n type: \"TSConditionalType\",\n checkType,\n extendsType,\n trueType,\n falseType\n };\n const defs = NODE_FIELDS.TSConditionalType;\n validate(defs.checkType, node, \"checkType\", checkType, 1);\n validate(defs.extendsType, node, \"extendsType\", extendsType, 1);\n validate(defs.trueType, node, \"trueType\", trueType, 1);\n validate(defs.falseType, node, \"falseType\", falseType, 1);\n return node;\n}\nfunction tsInferType(typeParameter) {\n const node = {\n type: \"TSInferType\",\n typeParameter\n };\n const defs = NODE_FIELDS.TSInferType;\n validate(defs.typeParameter, node, \"typeParameter\", typeParameter, 1);\n return node;\n}\nfunction tsParenthesizedType(typeAnnotation) {\n const node = {\n type: \"TSParenthesizedType\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSParenthesizedType;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsTypeOperator(typeAnnotation, operator = \"keyof\") {\n const node = {\n type: \"TSTypeOperator\",\n typeAnnotation,\n operator\n };\n const defs = NODE_FIELDS.TSTypeOperator;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.operator, node, \"operator\", operator);\n return node;\n}\nfunction tsIndexedAccessType(objectType, indexType) {\n const node = {\n type: \"TSIndexedAccessType\",\n objectType,\n indexType\n };\n const defs = NODE_FIELDS.TSIndexedAccessType;\n validate(defs.objectType, node, \"objectType\", objectType, 1);\n validate(defs.indexType, node, \"indexType\", indexType, 1);\n return node;\n}\nfunction tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {\n const node = {\n type: \"TSMappedType\",\n typeParameter,\n typeAnnotation,\n nameType\n };\n const defs = NODE_FIELDS.TSMappedType;\n validate(defs.typeParameter, node, \"typeParameter\", typeParameter, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.nameType, node, \"nameType\", nameType, 1);\n return node;\n}\nfunction tsTemplateLiteralType(quasis, types) {\n const node = {\n type: \"TSTemplateLiteralType\",\n quasis,\n types\n };\n const defs = NODE_FIELDS.TSTemplateLiteralType;\n validate(defs.quasis, node, \"quasis\", quasis, 1);\n validate(defs.types, node, \"types\", types, 1);\n return node;\n}\nfunction tsLiteralType(literal) {\n const node = {\n type: \"TSLiteralType\",\n literal\n };\n const defs = NODE_FIELDS.TSLiteralType;\n validate(defs.literal, node, \"literal\", literal, 1);\n return node;\n}\nfunction tsExpressionWithTypeArguments(expression, typeParameters = null) {\n const node = {\n type: \"TSExpressionWithTypeArguments\",\n expression,\n typeParameters\n };\n const defs = NODE_FIELDS.TSExpressionWithTypeArguments;\n validate(defs.expression, node, \"expression\", expression, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {\n const node = {\n type: \"TSInterfaceDeclaration\",\n id,\n typeParameters,\n extends: _extends,\n body\n };\n const defs = NODE_FIELDS.TSInterfaceDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.extends, node, \"extends\", _extends, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction tsInterfaceBody(body) {\n const node = {\n type: \"TSInterfaceBody\",\n body\n };\n const defs = NODE_FIELDS.TSInterfaceBody;\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {\n const node = {\n type: \"TSTypeAliasDeclaration\",\n id,\n typeParameters,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSTypeAliasDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsInstantiationExpression(expression, typeParameters = null) {\n const node = {\n type: \"TSInstantiationExpression\",\n expression,\n typeParameters\n };\n const defs = NODE_FIELDS.TSInstantiationExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction tsAsExpression(expression, typeAnnotation) {\n const node = {\n type: \"TSAsExpression\",\n expression,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSAsExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsSatisfiesExpression(expression, typeAnnotation) {\n const node = {\n type: \"TSSatisfiesExpression\",\n expression,\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSSatisfiesExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsTypeAssertion(typeAnnotation, expression) {\n const node = {\n type: \"TSTypeAssertion\",\n typeAnnotation,\n expression\n };\n const defs = NODE_FIELDS.TSTypeAssertion;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction tsEnumBody(members) {\n const node = {\n type: \"TSEnumBody\",\n members\n };\n const defs = NODE_FIELDS.TSEnumBody;\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction tsEnumDeclaration(id, members) {\n const node = {\n type: \"TSEnumDeclaration\",\n id,\n members\n };\n const defs = NODE_FIELDS.TSEnumDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.members, node, \"members\", members, 1);\n return node;\n}\nfunction tsEnumMember(id, initializer = null) {\n const node = {\n type: \"TSEnumMember\",\n id,\n initializer\n };\n const defs = NODE_FIELDS.TSEnumMember;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.initializer, node, \"initializer\", initializer, 1);\n return node;\n}\nfunction tsModuleDeclaration(id, body) {\n const node = {\n type: \"TSModuleDeclaration\",\n id,\n body,\n kind: null\n };\n const defs = NODE_FIELDS.TSModuleDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction tsModuleBlock(body) {\n const node = {\n type: \"TSModuleBlock\",\n body\n };\n const defs = NODE_FIELDS.TSModuleBlock;\n validate(defs.body, node, \"body\", body, 1);\n return node;\n}\nfunction tsImportType(argument, qualifier = null, typeParameters = null) {\n const node = {\n type: \"TSImportType\",\n argument,\n qualifier,\n typeParameters\n };\n const defs = NODE_FIELDS.TSImportType;\n validate(defs.argument, node, \"argument\", argument, 1);\n validate(defs.qualifier, node, \"qualifier\", qualifier, 1);\n validate(defs.typeParameters, node, \"typeParameters\", typeParameters, 1);\n return node;\n}\nfunction tsImportEqualsDeclaration(id, moduleReference) {\n const node = {\n type: \"TSImportEqualsDeclaration\",\n id,\n moduleReference,\n isExport: null\n };\n const defs = NODE_FIELDS.TSImportEqualsDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n validate(defs.moduleReference, node, \"moduleReference\", moduleReference, 1);\n return node;\n}\nfunction tsExternalModuleReference(expression) {\n const node = {\n type: \"TSExternalModuleReference\",\n expression\n };\n const defs = NODE_FIELDS.TSExternalModuleReference;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction tsNonNullExpression(expression) {\n const node = {\n type: \"TSNonNullExpression\",\n expression\n };\n const defs = NODE_FIELDS.TSNonNullExpression;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction tsExportAssignment(expression) {\n const node = {\n type: \"TSExportAssignment\",\n expression\n };\n const defs = NODE_FIELDS.TSExportAssignment;\n validate(defs.expression, node, \"expression\", expression, 1);\n return node;\n}\nfunction tsNamespaceExportDeclaration(id) {\n const node = {\n type: \"TSNamespaceExportDeclaration\",\n id\n };\n const defs = NODE_FIELDS.TSNamespaceExportDeclaration;\n validate(defs.id, node, \"id\", id, 1);\n return node;\n}\nfunction tsTypeAnnotation(typeAnnotation) {\n const node = {\n type: \"TSTypeAnnotation\",\n typeAnnotation\n };\n const defs = NODE_FIELDS.TSTypeAnnotation;\n validate(defs.typeAnnotation, node, \"typeAnnotation\", typeAnnotation, 1);\n return node;\n}\nfunction tsTypeParameterInstantiation(params) {\n const node = {\n type: \"TSTypeParameterInstantiation\",\n params\n };\n const defs = NODE_FIELDS.TSTypeParameterInstantiation;\n validate(defs.params, node, \"params\", params, 1);\n return node;\n}\nfunction tsTypeParameterDeclaration(params) {\n const node = {\n type: \"TSTypeParameterDeclaration\",\n params\n };\n const defs = NODE_FIELDS.TSTypeParameterDeclaration;\n validate(defs.params, node, \"params\", params, 1);\n return node;\n}\nfunction tsTypeParameter(constraint = null, _default = null, name) {\n const node = {\n type: \"TSTypeParameter\",\n constraint,\n default: _default,\n name\n };\n const defs = NODE_FIELDS.TSTypeParameter;\n validate(defs.constraint, node, \"constraint\", constraint, 1);\n validate(defs.default, node, \"default\", _default, 1);\n validate(defs.name, node, \"name\", name);\n return node;\n}\nfunction NumberLiteral(value) {\n (0, _deprecationWarning.default)(\"NumberLiteral\", \"NumericLiteral\", \"The node type \");\n return numericLiteral(value);\n}\nfunction RegexLiteral(pattern, flags = \"\") {\n (0, _deprecationWarning.default)(\"RegexLiteral\", \"RegExpLiteral\", \"The node type \");\n return regExpLiteral(pattern, flags);\n}\nfunction RestProperty(argument) {\n (0, _deprecationWarning.default)(\"RestProperty\", \"RestElement\", \"The node type \");\n return restElement(argument);\n}\nfunction SpreadProperty(argument) {\n (0, _deprecationWarning.default)(\"SpreadProperty\", \"SpreadElement\", \"The node type \");\n return spreadElement(argument);\n}\n\n//# sourceMappingURL=lowercase.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = validate;\nexports.validateChild = validateChild;\nexports.validateField = validateField;\nexports.validateInternal = validateInternal;\nvar _index = require(\"../definitions/index.js\");\nfunction validate(node, key, val) {\n if (!node) return;\n const fields = _index.NODE_FIELDS[node.type];\n if (!fields) return;\n const field = fields[key];\n validateField(node, key, val, field);\n validateChild(node, key, val);\n}\nfunction validateInternal(field, node, key, val, maybeNode) {\n if (!(field != null && field.validate)) return;\n if (field.optional && val == null) return;\n field.validate(node, key, val);\n if (maybeNode) {\n var _NODE_PARENT_VALIDATI;\n const type = val.type;\n if (type == null) return;\n (_NODE_PARENT_VALIDATI = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI.call(_index.NODE_PARENT_VALIDATIONS, node, key, val);\n }\n}\nfunction validateField(node, key, val, field) {\n if (!(field != null && field.validate)) return;\n if (field.optional && val == null) return;\n field.validate(node, key, val);\n}\nfunction validateChild(node, key, val) {\n var _NODE_PARENT_VALIDATI2;\n const type = val == null ? void 0 : val.type;\n if (type == null) return;\n (_NODE_PARENT_VALIDATI2 = _index.NODE_PARENT_VALIDATIONS[type]) == null || _NODE_PARENT_VALIDATI2.call(_index.NODE_PARENT_VALIDATIONS, node, key, val);\n}\n\n//# sourceMappingURL=validate.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nObject.defineProperty(exports, \"ALIAS_KEYS\", {\n enumerable: true,\n get: function () {\n return _utils.ALIAS_KEYS;\n }\n});\nObject.defineProperty(exports, \"BUILDER_KEYS\", {\n enumerable: true,\n get: function () {\n return _utils.BUILDER_KEYS;\n }\n});\nObject.defineProperty(exports, \"DEPRECATED_ALIASES\", {\n enumerable: true,\n get: function () {\n return _deprecatedAliases.DEPRECATED_ALIASES;\n }\n});\nObject.defineProperty(exports, \"DEPRECATED_KEYS\", {\n enumerable: true,\n get: function () {\n return _utils.DEPRECATED_KEYS;\n }\n});\nObject.defineProperty(exports, \"FLIPPED_ALIAS_KEYS\", {\n enumerable: true,\n get: function () {\n return _utils.FLIPPED_ALIAS_KEYS;\n }\n});\nObject.defineProperty(exports, \"NODE_FIELDS\", {\n enumerable: true,\n get: function () {\n return _utils.NODE_FIELDS;\n }\n});\nObject.defineProperty(exports, \"NODE_PARENT_VALIDATIONS\", {\n enumerable: true,\n get: function () {\n return _utils.NODE_PARENT_VALIDATIONS;\n }\n});\nObject.defineProperty(exports, \"NODE_UNION_SHAPES__PRIVATE\", {\n enumerable: true,\n get: function () {\n return _utils.NODE_UNION_SHAPES__PRIVATE;\n }\n});\nObject.defineProperty(exports, \"PLACEHOLDERS\", {\n enumerable: true,\n get: function () {\n return _placeholders.PLACEHOLDERS;\n }\n});\nObject.defineProperty(exports, \"PLACEHOLDERS_ALIAS\", {\n enumerable: true,\n get: function () {\n return _placeholders.PLACEHOLDERS_ALIAS;\n }\n});\nObject.defineProperty(exports, \"PLACEHOLDERS_FLIPPED_ALIAS\", {\n enumerable: true,\n get: function () {\n return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;\n }\n});\nexports.TYPES = void 0;\nObject.defineProperty(exports, \"VISITOR_KEYS\", {\n enumerable: true,\n get: function () {\n return _utils.VISITOR_KEYS;\n }\n});\nrequire(\"./core.js\");\nrequire(\"./flow.js\");\nrequire(\"./jsx.js\");\nrequire(\"./misc.js\");\nrequire(\"./experimental.js\");\nrequire(\"./typescript.js\");\nvar _utils = require(\"./utils.js\");\nvar _placeholders = require(\"./placeholders.js\");\nvar _deprecatedAliases = require(\"./deprecated-aliases.js\");\nObject.keys(_deprecatedAliases.DEPRECATED_ALIASES).forEach(deprecatedAlias => {\n _utils.FLIPPED_ALIAS_KEYS[deprecatedAlias] = _utils.FLIPPED_ALIAS_KEYS[_deprecatedAliases.DEPRECATED_ALIASES[deprecatedAlias]];\n});\nfor (const {\n types,\n set\n} of _utils.allExpandedTypes) {\n for (const type of types) {\n const aliases = _utils.FLIPPED_ALIAS_KEYS[type];\n if (aliases) {\n aliases.forEach(set.add, set);\n } else {\n set.add(type);\n }\n }\n}\nconst TYPES = exports.TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.patternLikeCommon = exports.importAttributes = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyUnionShapeCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0;\nvar _is = require(\"../validators/is.js\");\nvar _isValidIdentifier = require(\"../validators/isValidIdentifier.js\");\nvar _helperValidatorIdentifier = require(\"@babel/helper-validator-identifier\");\nvar _helperStringParser = require(\"@babel/helper-string-parser\");\nvar _index = require(\"../constants/index.js\");\nvar _utils = require(\"./utils.js\");\nconst classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({\n unionShape: {\n discriminator: \"computed\",\n shapes: [{\n name: \"computed\",\n value: [true],\n properties: {\n key: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n }, {\n name: \"nonComputed\",\n value: [false],\n properties: {\n key: {\n validate: allowPrivateName ? (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"PrivateName\") : (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\")\n }\n }\n }]\n }\n});\nexports.classMethodOrPropertyUnionShapeCommon = classMethodOrPropertyUnionShapeCommon;\nconst defineType = (0, _utils.defineAliasedType)(\"Standardized\");\ndefineType(\"ArrayExpression\", {\n fields: {\n elements: {\n validate: (0, _utils.arrayOf)((0, _utils.assertNodeOrValueType)(\"null\", \"Expression\", \"SpreadElement\")),\n default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined\n }\n },\n visitor: [\"elements\"],\n aliases: [\"Expression\"]\n});\ndefineType(\"AssignmentExpression\", {\n fields: {\n operator: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)(\"string\") : Object.assign(function () {\n const identifier = (0, _utils.assertOneOf)(..._index.ASSIGNMENT_OPERATORS);\n const pattern = (0, _utils.assertOneOf)(\"=\");\n return function (node, key, val) {\n const validator = (0, _is.default)(\"Pattern\", node.left) ? pattern : identifier;\n validator(node, key, val);\n };\n }(), {\n oneOf: _index.ASSIGNMENT_OPERATORS\n })\n },\n left: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)(\"LVal\", \"OptionalMemberExpression\") : (0, _utils.assertNodeType)(\"Identifier\", \"MemberExpression\", \"OptionalMemberExpression\", \"ArrayPattern\", \"ObjectPattern\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\")\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n builder: [\"operator\", \"left\", \"right\"],\n visitor: [\"left\", \"right\"],\n aliases: [\"Expression\"]\n});\ndefineType(\"BinaryExpression\", {\n builder: [\"operator\", \"left\", \"right\"],\n fields: {\n operator: {\n validate: (0, _utils.assertOneOf)(..._index.BINARY_OPERATORS)\n },\n left: {\n validate: function () {\n const expression = (0, _utils.assertNodeType)(\"Expression\");\n const inOp = (0, _utils.assertNodeType)(\"Expression\", \"PrivateName\");\n const validator = Object.assign(function (node, key, val) {\n const validator = node.operator === \"in\" ? inOp : expression;\n validator(node, key, val);\n }, {\n oneOfNodeTypes: [\"Expression\", \"PrivateName\"]\n });\n return validator;\n }()\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n visitor: [\"left\", \"right\"],\n aliases: [\"Binary\", \"Expression\"]\n});\ndefineType(\"InterpreterDirective\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n }\n});\ndefineType(\"Directive\", {\n visitor: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertNodeType)(\"DirectiveLiteral\")\n }\n }\n});\ndefineType(\"DirectiveLiteral\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n }\n});\ndefineType(\"BlockStatement\", {\n builder: [\"body\", \"directives\"],\n visitor: [\"directives\", \"body\"],\n fields: {\n directives: {\n validate: (0, _utils.arrayOfType)(\"Directive\"),\n default: []\n },\n body: (0, _utils.validateArrayOfType)(\"Statement\")\n },\n aliases: [\"Scopable\", \"BlockParent\", \"Block\", \"Statement\"]\n});\ndefineType(\"BreakStatement\", {\n visitor: [\"label\"],\n fields: {\n label: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n }\n },\n aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"]\n});\ndefineType(\"CallExpression\", {\n visitor: [\"callee\", \"typeParameters\", \"typeArguments\", \"arguments\"],\n builder: [\"callee\", \"arguments\"],\n aliases: [\"Expression\"],\n fields: Object.assign({\n callee: {\n validate: (0, _utils.assertNodeType)(\"Expression\", \"Super\", \"V8IntrinsicIdentifier\")\n },\n arguments: (0, _utils.validateArrayOfType)(\"Expression\", \"SpreadElement\", \"ArgumentPlaceholder\"),\n typeArguments: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\"),\n optional: true\n }\n }, process.env.BABEL_TYPES_8_BREAKING ? {} : {\n optional: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TSTypeParameterInstantiation\"),\n optional: true\n }\n })\n});\ndefineType(\"CatchClause\", {\n visitor: [\"param\", \"body\"],\n fields: {\n param: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n }\n },\n aliases: [\"Scopable\", \"BlockParent\"]\n});\ndefineType(\"ConditionalExpression\", {\n visitor: [\"test\", \"consequent\", \"alternate\"],\n fields: {\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n consequent: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n alternate: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n aliases: [\"Expression\", \"Conditional\"]\n});\ndefineType(\"ContinueStatement\", {\n visitor: [\"label\"],\n fields: {\n label: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n }\n },\n aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"]\n});\ndefineType(\"DebuggerStatement\", {\n aliases: [\"Statement\"]\n});\ndefineType(\"DoWhileStatement\", {\n builder: [\"test\", \"body\"],\n visitor: [\"body\", \"test\"],\n fields: {\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n },\n aliases: [\"Statement\", \"BlockParent\", \"Loop\", \"While\", \"Scopable\"]\n});\ndefineType(\"EmptyStatement\", {\n aliases: [\"Statement\"]\n});\ndefineType(\"ExpressionStatement\", {\n visitor: [\"expression\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n aliases: [\"Statement\", \"ExpressionWrapper\"]\n});\ndefineType(\"File\", {\n builder: [\"program\", \"comments\", \"tokens\"],\n visitor: [\"program\"],\n fields: {\n program: {\n validate: (0, _utils.assertNodeType)(\"Program\")\n },\n comments: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {\n each: {\n oneOfNodeTypes: [\"CommentBlock\", \"CommentLine\"]\n }\n }) : (0, _utils.assertEach)((0, _utils.assertNodeType)(\"CommentBlock\", \"CommentLine\")),\n optional: true\n },\n tokens: {\n validate: (0, _utils.assertEach)(Object.assign(() => {}, {\n type: \"any\"\n })),\n optional: true\n }\n }\n});\ndefineType(\"ForInStatement\", {\n visitor: [\"left\", \"right\", \"body\"],\n aliases: [\"Scopable\", \"Statement\", \"For\", \"BlockParent\", \"Loop\", \"ForXStatement\"],\n fields: {\n left: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)(\"VariableDeclaration\", \"LVal\") : (0, _utils.assertNodeType)(\"VariableDeclaration\", \"Identifier\", \"MemberExpression\", \"ArrayPattern\", \"ObjectPattern\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\")\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\ndefineType(\"ForStatement\", {\n visitor: [\"init\", \"test\", \"update\", \"body\"],\n aliases: [\"Scopable\", \"Statement\", \"For\", \"BlockParent\", \"Loop\"],\n fields: {\n init: {\n validate: (0, _utils.assertNodeType)(\"VariableDeclaration\", \"Expression\"),\n optional: true\n },\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n update: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\nconst functionCommon = () => ({\n params: (0, _utils.validateArrayOfType)(\"FunctionParameter\"),\n generator: {\n default: false\n },\n async: {\n default: false\n }\n});\nexports.functionCommon = functionCommon;\nconst functionTypeAnnotationCommon = () => ({\n returnType: {\n validate: (0, _utils.assertNodeType)(\"TypeAnnotation\", \"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterDeclaration\", \"TSTypeParameterDeclaration\", \"Noop\"),\n optional: true\n }\n});\nexports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;\nconst functionDeclarationCommon = () => Object.assign({}, functionCommon(), {\n declare: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n id: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n }\n});\nexports.functionDeclarationCommon = functionDeclarationCommon;\ndefineType(\"FunctionDeclaration\", {\n builder: [\"id\", \"params\", \"body\", \"generator\", \"async\"],\n visitor: [\"id\", \"typeParameters\", \"params\", \"predicate\", \"returnType\", \"body\"],\n fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), {\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n },\n predicate: {\n validate: (0, _utils.assertNodeType)(\"DeclaredPredicate\", \"InferredPredicate\"),\n optional: true\n }\n }),\n aliases: [\"Scopable\", \"Function\", \"BlockParent\", \"FunctionParent\", \"Statement\", \"Pureish\", \"Declaration\"],\n validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () {\n const identifier = (0, _utils.assertNodeType)(\"Identifier\");\n return function (parent, key, node) {\n if (!(0, _is.default)(\"ExportDefaultDeclaration\", parent)) {\n identifier(node, \"id\", node.id);\n }\n };\n }()\n});\ndefineType(\"FunctionExpression\", {\n inherits: \"FunctionDeclaration\",\n aliases: [\"Scopable\", \"Function\", \"BlockParent\", \"FunctionParent\", \"Expression\", \"Pureish\"],\n fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {\n id: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n },\n predicate: {\n validate: (0, _utils.assertNodeType)(\"DeclaredPredicate\", \"InferredPredicate\"),\n optional: true\n }\n })\n});\nconst patternLikeCommon = () => ({\n typeAnnotation: {\n validate: (0, _utils.assertNodeType)(\"TypeAnnotation\", \"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n optional: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n }\n});\nexports.patternLikeCommon = patternLikeCommon;\ndefineType(\"Identifier\", {\n builder: [\"name\"],\n visitor: [\"typeAnnotation\", \"decorators\"],\n aliases: [\"Expression\", \"FunctionParameter\", \"PatternLike\", \"LVal\", \"TSEntityName\"],\n fields: Object.assign({}, patternLikeCommon(), {\n name: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)(\"string\"), Object.assign(function (node, key, val) {\n if (!(0, _isValidIdentifier.default)(val, false)) {\n throw new TypeError(`\"${val}\" is not a valid identifier name`);\n }\n }, {\n type: \"string\"\n })) : (0, _utils.assertValueType)(\"string\")\n }\n }),\n validate: process.env.BABEL_TYPES_8_BREAKING ? function (parent, key, node) {\n const match = /\\.(\\w+)$/.exec(key.toString());\n if (!match) return;\n const [, parentKey] = match;\n const nonComp = {\n computed: false\n };\n if (parentKey === \"property\") {\n if ((0, _is.default)(\"MemberExpression\", parent, nonComp)) return;\n if ((0, _is.default)(\"OptionalMemberExpression\", parent, nonComp)) return;\n } else if (parentKey === \"key\") {\n if ((0, _is.default)(\"Property\", parent, nonComp)) return;\n if ((0, _is.default)(\"Method\", parent, nonComp)) return;\n } else if (parentKey === \"exported\") {\n if ((0, _is.default)(\"ExportSpecifier\", parent)) return;\n } else if (parentKey === \"imported\") {\n if ((0, _is.default)(\"ImportSpecifier\", parent, {\n imported: node\n })) return;\n } else if (parentKey === \"meta\") {\n if ((0, _is.default)(\"MetaProperty\", parent, {\n meta: node\n })) return;\n }\n if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== \"this\") {\n throw new TypeError(`\"${node.name}\" is not a valid identifier`);\n }\n } : undefined\n});\ndefineType(\"IfStatement\", {\n visitor: [\"test\", \"consequent\", \"alternate\"],\n aliases: [\"Statement\", \"Conditional\"],\n fields: {\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n consequent: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n },\n alternate: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\ndefineType(\"LabeledStatement\", {\n visitor: [\"label\", \"body\"],\n aliases: [\"Statement\"],\n fields: {\n label: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\ndefineType(\"StringLiteral\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n },\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\ndefineType(\"NumericLiteral\", {\n builder: [\"value\"],\n deprecatedAlias: \"NumberLiteral\",\n fields: {\n value: {\n validate: (0, _utils.chain)((0, _utils.assertValueType)(\"number\"), Object.assign(function (node, key, val) {\n if (1 / val < 0 || !Number.isFinite(val)) {\n const error = new Error(\"NumericLiterals must be non-negative finite numbers. \" + `You can use t.valueToNode(${val}) instead.`);\n }\n }, {\n type: \"number\"\n }))\n }\n },\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\ndefineType(\"NullLiteral\", {\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\ndefineType(\"BooleanLiteral\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"boolean\")\n }\n },\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\ndefineType(\"RegExpLiteral\", {\n builder: [\"pattern\", \"flags\"],\n deprecatedAlias: \"RegexLiteral\",\n aliases: [\"Expression\", \"Pureish\", \"Literal\"],\n fields: {\n pattern: {\n validate: (0, _utils.assertValueType)(\"string\")\n },\n flags: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)(\"string\"), Object.assign(function (node, key, val) {\n const invalid = /[^dgimsuvy]/.exec(val);\n if (invalid) {\n throw new TypeError(`\"${invalid[0]}\" is not a valid RegExp flag`);\n }\n }, {\n type: \"string\"\n })) : (0, _utils.assertValueType)(\"string\"),\n default: \"\"\n }\n }\n});\ndefineType(\"LogicalExpression\", {\n builder: [\"operator\", \"left\", \"right\"],\n visitor: [\"left\", \"right\"],\n aliases: [\"Binary\", \"Expression\"],\n fields: {\n operator: {\n validate: (0, _utils.assertOneOf)(..._index.LOGICAL_OPERATORS)\n },\n left: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"MemberExpression\", {\n builder: [\"object\", \"property\", \"computed\", ...(!process.env.BABEL_TYPES_8_BREAKING ? [\"optional\"] : [])],\n visitor: [\"object\", \"property\"],\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n unionShape: {\n discriminator: \"computed\",\n shapes: [{\n name: \"computed\",\n value: [true],\n properties: {\n property: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n }, {\n name: \"nonComputed\",\n value: [false],\n properties: {\n property: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"PrivateName\")\n }\n }\n }]\n },\n fields: Object.assign({\n object: {\n validate: (0, _utils.assertNodeType)(\"Expression\", \"Super\")\n },\n property: {\n validate: function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\", \"PrivateName\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n const validator = function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n };\n validator.oneOfNodeTypes = [\"Expression\", \"Identifier\", \"PrivateName\"];\n return validator;\n }()\n },\n computed: {\n default: false\n }\n }, !process.env.BABEL_TYPES_8_BREAKING ? {\n optional: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n }\n } : {})\n});\ndefineType(\"NewExpression\", {\n inherits: \"CallExpression\"\n});\ndefineType(\"Program\", {\n visitor: [\"directives\", \"body\"],\n builder: [\"body\", \"directives\", \"sourceType\", \"interpreter\"],\n fields: {\n sourceType: {\n validate: (0, _utils.assertOneOf)(\"script\", \"module\"),\n default: \"script\"\n },\n interpreter: {\n validate: (0, _utils.assertNodeType)(\"InterpreterDirective\"),\n default: null,\n optional: true\n },\n directives: {\n validate: (0, _utils.arrayOfType)(\"Directive\"),\n default: []\n },\n body: (0, _utils.validateArrayOfType)(\"Statement\")\n },\n aliases: [\"Scopable\", \"BlockParent\", \"Block\"]\n});\ndefineType(\"ObjectExpression\", {\n visitor: [\"properties\"],\n aliases: [\"Expression\"],\n fields: {\n properties: (0, _utils.validateArrayOfType)(\"ObjectMethod\", \"ObjectProperty\", \"SpreadElement\")\n }\n});\ndefineType(\"ObjectMethod\", Object.assign({\n builder: [\"kind\", \"key\", \"params\", \"body\", \"computed\", \"generator\", \"async\"],\n visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\", \"body\"]\n}, classMethodOrPropertyUnionShapeCommon(), {\n fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {\n kind: Object.assign({\n validate: (0, _utils.assertOneOf)(\"method\", \"get\", \"set\")\n }, !process.env.BABEL_TYPES_8_BREAKING ? {\n default: \"method\"\n } : {}),\n computed: {\n default: false\n },\n key: {\n validate: function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n const validator = function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n };\n validator.oneOfNodeTypes = [\"Expression\", \"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\"];\n return validator;\n }()\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n }\n }),\n aliases: [\"UserWhitespacable\", \"Function\", \"Scopable\", \"BlockParent\", \"FunctionParent\", \"Method\", \"ObjectMember\"]\n}));\ndefineType(\"ObjectProperty\", {\n builder: [\"key\", \"value\", \"computed\", \"shorthand\", ...(!process.env.BABEL_TYPES_8_BREAKING ? [\"decorators\"] : [])],\n unionShape: {\n discriminator: \"computed\",\n shapes: [{\n name: \"computed\",\n value: [true],\n properties: {\n key: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n }, {\n name: \"nonComputed\",\n value: [false],\n properties: {\n key: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"DecimalLiteral\", \"PrivateName\")\n }\n }\n }]\n },\n fields: {\n computed: {\n default: false\n },\n key: {\n validate: function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"DecimalLiteral\", \"PrivateName\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n const validator = Object.assign(function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n }, {\n oneOfNodeTypes: [\"Expression\", \"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"DecimalLiteral\", \"PrivateName\"]\n });\n return validator;\n }()\n },\n value: {\n validate: (0, _utils.assertNodeType)(\"Expression\", \"PatternLike\")\n },\n shorthand: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)(\"boolean\"), Object.assign(function (node, key, shorthand) {\n if (!shorthand) return;\n if (node.computed) {\n throw new TypeError(\"Property shorthand of ObjectProperty cannot be true if computed is true\");\n }\n if (!(0, _is.default)(\"Identifier\", node.key)) {\n throw new TypeError(\"Property shorthand of ObjectProperty cannot be true if key is not an Identifier\");\n }\n }, {\n type: \"boolean\"\n })) : (0, _utils.assertValueType)(\"boolean\"),\n default: false\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n }\n },\n visitor: [\"decorators\", \"key\", \"value\"],\n aliases: [\"UserWhitespacable\", \"Property\", \"ObjectMember\"],\n validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () {\n const pattern = (0, _utils.assertNodeType)(\"Identifier\", \"Pattern\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSNonNullExpression\", \"TSTypeAssertion\");\n const expression = (0, _utils.assertNodeType)(\"Expression\");\n return function (parent, key, node) {\n const validator = (0, _is.default)(\"ObjectPattern\", parent) ? pattern : expression;\n validator(node, \"value\", node.value);\n };\n }()\n});\ndefineType(\"RestElement\", {\n visitor: [\"argument\", \"typeAnnotation\"],\n builder: [\"argument\"],\n aliases: [\"FunctionParameter\", \"PatternLike\", \"LVal\"],\n deprecatedAlias: \"RestProperty\",\n fields: Object.assign({}, patternLikeCommon(), {\n argument: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\", \"MemberExpression\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\", \"RestElement\", \"AssignmentPattern\") : (0, _utils.assertNodeType)(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\", \"MemberExpression\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\")\n }\n }),\n validate: process.env.BABEL_TYPES_8_BREAKING ? function (parent, key) {\n const match = /(\\w+)\\[(\\d+)\\]/.exec(key.toString());\n if (!match) throw new Error(\"Internal Babel error: malformed key.\");\n const [, listKey, index] = match;\n if (parent[listKey].length > +index + 1) {\n throw new TypeError(`RestElement must be last element of ${listKey}`);\n }\n } : undefined\n});\ndefineType(\"ReturnStatement\", {\n visitor: [\"argument\"],\n aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n fields: {\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n }\n }\n});\ndefineType(\"SequenceExpression\", {\n visitor: [\"expressions\"],\n fields: {\n expressions: (0, _utils.validateArrayOfType)(\"Expression\")\n },\n aliases: [\"Expression\"]\n});\ndefineType(\"ParenthesizedExpression\", {\n visitor: [\"expression\"],\n aliases: [\"Expression\", \"ExpressionWrapper\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"SwitchCase\", {\n visitor: [\"test\", \"consequent\"],\n fields: {\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n consequent: (0, _utils.validateArrayOfType)(\"Statement\")\n }\n});\ndefineType(\"SwitchStatement\", {\n visitor: [\"discriminant\", \"cases\"],\n aliases: [\"Statement\", \"BlockParent\", \"Scopable\"],\n fields: {\n discriminant: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n cases: (0, _utils.validateArrayOfType)(\"SwitchCase\")\n }\n});\ndefineType(\"ThisExpression\", {\n aliases: [\"Expression\"]\n});\ndefineType(\"ThrowStatement\", {\n visitor: [\"argument\"],\n aliases: [\"Statement\", \"Terminatorless\", \"CompletionStatement\"],\n fields: {\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"TryStatement\", {\n visitor: [\"block\", \"handler\", \"finalizer\"],\n aliases: [\"Statement\"],\n fields: {\n block: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)(\"BlockStatement\"), Object.assign(function (node) {\n if (!node.handler && !node.finalizer) {\n throw new TypeError(\"TryStatement expects either a handler or finalizer, or both\");\n }\n }, {\n oneOfNodeTypes: [\"BlockStatement\"]\n })) : (0, _utils.assertNodeType)(\"BlockStatement\")\n },\n handler: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"CatchClause\")\n },\n finalizer: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n }\n }\n});\ndefineType(\"UnaryExpression\", {\n builder: [\"operator\", \"argument\", \"prefix\"],\n fields: {\n prefix: {\n default: true\n },\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n operator: {\n validate: (0, _utils.assertOneOf)(..._index.UNARY_OPERATORS)\n }\n },\n visitor: [\"argument\"],\n aliases: [\"UnaryLike\", \"Expression\"]\n});\ndefineType(\"UpdateExpression\", {\n builder: [\"operator\", \"argument\", \"prefix\"],\n fields: {\n prefix: {\n default: false\n },\n argument: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)(\"Expression\") : (0, _utils.assertNodeType)(\"Identifier\", \"MemberExpression\")\n },\n operator: {\n validate: (0, _utils.assertOneOf)(..._index.UPDATE_OPERATORS)\n }\n },\n visitor: [\"argument\"],\n aliases: [\"Expression\"]\n});\ndefineType(\"VariableDeclaration\", {\n builder: [\"kind\", \"declarations\"],\n visitor: [\"declarations\"],\n aliases: [\"Statement\", \"Declaration\"],\n fields: {\n declare: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n kind: {\n validate: (0, _utils.assertOneOf)(\"var\", \"let\", \"const\", \"using\", \"await using\")\n },\n declarations: (0, _utils.validateArrayOfType)(\"VariableDeclarator\")\n },\n validate: process.env.BABEL_TYPES_8_BREAKING ? (() => {\n const withoutInit = (0, _utils.assertNodeType)(\"Identifier\", \"Placeholder\");\n const constOrLetOrVar = (0, _utils.assertNodeType)(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\", \"Placeholder\");\n const usingOrAwaitUsing = (0, _utils.assertNodeType)(\"Identifier\", \"VoidPattern\", \"Placeholder\");\n return function (parent, key, node) {\n const {\n kind,\n declarations\n } = node;\n const parentIsForX = (0, _is.default)(\"ForXStatement\", parent, {\n left: node\n });\n if (parentIsForX) {\n if (declarations.length !== 1) {\n throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);\n }\n }\n for (const decl of declarations) {\n if (kind === \"const\" || kind === \"let\" || kind === \"var\") {\n if (!parentIsForX && !decl.init) {\n withoutInit(decl, \"id\", decl.id);\n } else {\n constOrLetOrVar(decl, \"id\", decl.id);\n }\n } else {\n usingOrAwaitUsing(decl, \"id\", decl.id);\n }\n }\n };\n })() : undefined\n});\ndefineType(\"VariableDeclarator\", {\n visitor: [\"id\", \"init\"],\n fields: {\n id: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)(\"LVal\", \"VoidPattern\") : (0, _utils.assertNodeType)(\"Identifier\", \"ArrayPattern\", \"ObjectPattern\", \"VoidPattern\")\n },\n definite: {\n optional: true,\n validate: (0, _utils.assertValueType)(\"boolean\")\n },\n init: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"WhileStatement\", {\n visitor: [\"test\", \"body\"],\n aliases: [\"Statement\", \"BlockParent\", \"Loop\", \"While\", \"Scopable\"],\n fields: {\n test: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\ndefineType(\"WithStatement\", {\n visitor: [\"object\", \"body\"],\n aliases: [\"Statement\"],\n fields: {\n object: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n }\n }\n});\ndefineType(\"AssignmentPattern\", {\n visitor: [\"left\", \"right\", \"decorators\"],\n builder: [\"left\", \"right\"],\n aliases: [\"FunctionParameter\", \"Pattern\", \"PatternLike\", \"LVal\"],\n fields: Object.assign({}, patternLikeCommon(), {\n left: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"ObjectPattern\", \"ArrayPattern\", \"MemberExpression\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\")\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n }\n })\n});\ndefineType(\"ArrayPattern\", {\n visitor: [\"elements\", \"typeAnnotation\"],\n builder: [\"elements\"],\n aliases: [\"FunctionParameter\", \"Pattern\", \"PatternLike\", \"LVal\"],\n fields: Object.assign({}, patternLikeCommon(), {\n elements: {\n validate: (0, _utils.chain)((0, _utils.assertValueType)(\"array\"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)(\"null\", \"PatternLike\")))\n }\n })\n});\ndefineType(\"ArrowFunctionExpression\", {\n builder: [\"params\", \"body\", \"async\"],\n visitor: [\"typeParameters\", \"params\", \"predicate\", \"returnType\", \"body\"],\n aliases: [\"Scopable\", \"Function\", \"BlockParent\", \"FunctionParent\", \"Expression\", \"Pureish\"],\n fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {\n expression: {\n validate: (0, _utils.assertValueType)(\"boolean\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\", \"Expression\")\n },\n predicate: {\n validate: (0, _utils.assertNodeType)(\"DeclaredPredicate\", \"InferredPredicate\"),\n optional: true\n }\n })\n});\ndefineType(\"ClassBody\", {\n visitor: [\"body\"],\n fields: {\n body: (0, _utils.validateArrayOfType)(\"ClassMethod\", \"ClassPrivateMethod\", \"ClassProperty\", \"ClassPrivateProperty\", \"ClassAccessorProperty\", \"TSDeclareMethod\", \"TSIndexSignature\", \"StaticBlock\")\n }\n});\ndefineType(\"ClassExpression\", {\n builder: [\"id\", \"superClass\", \"body\", \"decorators\"],\n visitor: [\"decorators\", \"id\", \"typeParameters\", \"superClass\", \"superTypeParameters\", \"mixins\", \"implements\", \"body\"],\n aliases: [\"Scopable\", \"Class\", \"Expression\"],\n fields: {\n id: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n },\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterDeclaration\", \"TSTypeParameterDeclaration\", \"Noop\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"ClassBody\")\n },\n superClass: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n [\"superTypeParameters\"]: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\", \"TSTypeParameterInstantiation\"),\n optional: true\n },\n implements: {\n validate: (0, _utils.arrayOfType)(\"TSExpressionWithTypeArguments\", \"ClassImplements\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n mixins: {\n validate: (0, _utils.assertNodeType)(\"InterfaceExtends\"),\n optional: true\n }\n }\n});\ndefineType(\"ClassDeclaration\", {\n inherits: \"ClassExpression\",\n aliases: [\"Scopable\", \"Class\", \"Statement\", \"Declaration\"],\n fields: {\n id: {\n validate: (0, _utils.assertNodeType)(\"Identifier\"),\n optional: true\n },\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterDeclaration\", \"TSTypeParameterDeclaration\", \"Noop\"),\n optional: true\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"ClassBody\")\n },\n superClass: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n [\"superTypeParameters\"]: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\", \"TSTypeParameterInstantiation\"),\n optional: true\n },\n implements: {\n validate: (0, _utils.arrayOfType)(\"TSExpressionWithTypeArguments\", \"ClassImplements\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n mixins: {\n validate: (0, _utils.assertNodeType)(\"InterfaceExtends\"),\n optional: true\n },\n declare: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n abstract: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n }\n },\n validate: !process.env.BABEL_TYPES_8_BREAKING ? undefined : function () {\n const identifier = (0, _utils.assertNodeType)(\"Identifier\");\n return function (parent, key, node) {\n if (!(0, _is.default)(\"ExportDefaultDeclaration\", parent)) {\n identifier(node, \"id\", node.id);\n }\n };\n }()\n});\nconst importAttributes = exports.importAttributes = {\n attributes: {\n optional: true,\n validate: (0, _utils.arrayOfType)(\"ImportAttribute\")\n }\n};\nimportAttributes.assertions = {\n deprecated: true,\n optional: true,\n validate: (0, _utils.arrayOfType)(\"ImportAttribute\")\n};\ndefineType(\"ExportAllDeclaration\", {\n builder: [\"source\", \"attributes\"],\n visitor: [\"source\", \"attributes\", \"assertions\"],\n aliases: [\"Statement\", \"Declaration\", \"ImportOrExportDeclaration\", \"ExportDeclaration\"],\n fields: Object.assign({\n source: {\n validate: (0, _utils.assertNodeType)(\"StringLiteral\")\n },\n exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(\"type\", \"value\"))\n }, importAttributes)\n});\ndefineType(\"ExportDefaultDeclaration\", {\n visitor: [\"declaration\"],\n aliases: [\"Statement\", \"Declaration\", \"ImportOrExportDeclaration\", \"ExportDeclaration\"],\n fields: {\n declaration: (0, _utils.validateType)(\"TSDeclareFunction\", \"FunctionDeclaration\", \"ClassDeclaration\", \"Expression\"),\n exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(\"value\"))\n }\n});\ndefineType(\"ExportNamedDeclaration\", {\n builder: [\"declaration\", \"specifiers\", \"source\", \"attributes\"],\n visitor: [\"declaration\", \"specifiers\", \"source\", \"attributes\", \"assertions\"],\n aliases: [\"Statement\", \"Declaration\", \"ImportOrExportDeclaration\", \"ExportDeclaration\"],\n fields: Object.assign({\n declaration: {\n optional: true,\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)(\"Declaration\"), Object.assign(function (node, key, val) {\n if (val && node.specifiers.length) {\n throw new TypeError(\"Only declaration or specifiers is allowed on ExportNamedDeclaration\");\n }\n if (val && node.source) {\n throw new TypeError(\"Cannot export a declaration from a source\");\n }\n }, {\n oneOfNodeTypes: [\"Declaration\"]\n })) : (0, _utils.assertNodeType)(\"Declaration\")\n }\n }, importAttributes, {\n specifiers: {\n default: [],\n validate: (0, _utils.arrayOf)(function () {\n const sourced = (0, _utils.assertNodeType)(\"ExportSpecifier\", \"ExportDefaultSpecifier\", \"ExportNamespaceSpecifier\");\n const sourceless = (0, _utils.assertNodeType)(\"ExportSpecifier\");\n if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;\n return Object.assign(function (node, key, val) {\n const validator = node.source ? sourced : sourceless;\n validator(node, key, val);\n }, {\n oneOfNodeTypes: [\"ExportSpecifier\", \"ExportDefaultSpecifier\", \"ExportNamespaceSpecifier\"]\n });\n }())\n },\n source: {\n validate: (0, _utils.assertNodeType)(\"StringLiteral\"),\n optional: true\n },\n exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(\"type\", \"value\"))\n })\n});\ndefineType(\"ExportSpecifier\", {\n visitor: [\"local\", \"exported\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n local: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n },\n exported: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\")\n },\n exportKind: {\n validate: (0, _utils.assertOneOf)(\"type\", \"value\"),\n optional: true\n }\n }\n});\ndefineType(\"ForOfStatement\", {\n visitor: [\"left\", \"right\", \"body\"],\n builder: [\"left\", \"right\", \"body\", \"await\"],\n aliases: [\"Scopable\", \"Statement\", \"For\", \"BlockParent\", \"Loop\", \"ForXStatement\"],\n fields: {\n left: {\n validate: function () {\n if (!process.env.BABEL_TYPES_8_BREAKING) {\n return (0, _utils.assertNodeType)(\"VariableDeclaration\", \"LVal\");\n }\n const declaration = (0, _utils.assertNodeType)(\"VariableDeclaration\");\n const lval = (0, _utils.assertNodeType)(\"Identifier\", \"MemberExpression\", \"ArrayPattern\", \"ObjectPattern\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\");\n return Object.assign(function (node, key, val) {\n if ((0, _is.default)(\"VariableDeclaration\", val)) {\n declaration(node, key, val);\n } else {\n lval(node, key, val);\n }\n }, {\n oneOfNodeTypes: [\"VariableDeclaration\", \"Identifier\", \"MemberExpression\", \"ArrayPattern\", \"ObjectPattern\", \"TSAsExpression\", \"TSSatisfiesExpression\", \"TSTypeAssertion\", \"TSNonNullExpression\"]\n });\n }()\n },\n right: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"Statement\")\n },\n await: {\n default: false\n }\n }\n});\ndefineType(\"ImportDeclaration\", {\n builder: [\"specifiers\", \"source\", \"attributes\"],\n visitor: [\"specifiers\", \"source\", \"attributes\", \"assertions\"],\n aliases: [\"Statement\", \"Declaration\", \"ImportOrExportDeclaration\"],\n fields: Object.assign({}, importAttributes, {\n module: {\n optional: true,\n validate: (0, _utils.assertValueType)(\"boolean\")\n },\n phase: {\n default: null,\n validate: (0, _utils.assertOneOf)(\"source\", \"defer\")\n },\n specifiers: (0, _utils.validateArrayOfType)(\"ImportSpecifier\", \"ImportDefaultSpecifier\", \"ImportNamespaceSpecifier\"),\n source: {\n validate: (0, _utils.assertNodeType)(\"StringLiteral\")\n },\n importKind: {\n validate: (0, _utils.assertOneOf)(\"type\", \"typeof\", \"value\"),\n optional: true\n }\n })\n});\ndefineType(\"ImportDefaultSpecifier\", {\n visitor: [\"local\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n local: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\ndefineType(\"ImportNamespaceSpecifier\", {\n visitor: [\"local\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n local: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\ndefineType(\"ImportSpecifier\", {\n visitor: [\"imported\", \"local\"],\n builder: [\"local\", \"imported\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n local: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n },\n imported: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\")\n },\n importKind: {\n validate: (0, _utils.assertOneOf)(\"type\", \"typeof\", \"value\"),\n optional: true\n }\n }\n});\ndefineType(\"ImportExpression\", {\n visitor: [\"source\", \"options\"],\n aliases: [\"Expression\"],\n fields: {\n phase: {\n default: null,\n validate: (0, _utils.assertOneOf)(\"source\", \"defer\")\n },\n source: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n options: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n }\n }\n});\ndefineType(\"MetaProperty\", {\n visitor: [\"meta\", \"property\"],\n aliases: [\"Expression\"],\n fields: {\n meta: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertNodeType)(\"Identifier\"), Object.assign(function (node, key, val) {\n let property;\n switch (val.name) {\n case \"function\":\n property = \"sent\";\n break;\n case \"new\":\n property = \"target\";\n break;\n case \"import\":\n property = \"meta\";\n break;\n }\n if (!(0, _is.default)(\"Identifier\", node.property, {\n name: property\n })) {\n throw new TypeError(\"Unrecognised MetaProperty\");\n }\n }, {\n oneOfNodeTypes: [\"Identifier\"]\n })) : (0, _utils.assertNodeType)(\"Identifier\")\n },\n property: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\nconst classMethodOrPropertyCommon = () => ({\n abstract: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n accessibility: {\n validate: (0, _utils.assertOneOf)(\"public\", \"private\", \"protected\"),\n optional: true\n },\n static: {\n default: false\n },\n override: {\n default: false\n },\n computed: {\n default: false\n },\n optional: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n key: {\n validate: (0, _utils.chain)(function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n return function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n };\n }(), (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"Expression\"))\n }\n});\nexports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;\nconst classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {\n params: (0, _utils.validateArrayOfType)(\"FunctionParameter\", \"TSParameterProperty\"),\n kind: {\n validate: (0, _utils.assertOneOf)(\"get\", \"set\", \"method\", \"constructor\"),\n default: \"method\"\n },\n access: {\n validate: (0, _utils.chain)((0, _utils.assertValueType)(\"string\"), (0, _utils.assertOneOf)(\"public\", \"private\", \"protected\")),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n }\n});\nexports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;\ndefineType(\"ClassMethod\", Object.assign({\n aliases: [\"Function\", \"Scopable\", \"BlockParent\", \"FunctionParent\", \"Method\"],\n builder: [\"kind\", \"key\", \"params\", \"body\", \"computed\", \"static\", \"generator\", \"async\"],\n visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\", \"body\"]\n}, classMethodOrPropertyUnionShapeCommon(), {\n fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n }\n })\n}));\ndefineType(\"ObjectPattern\", {\n visitor: [\"decorators\", \"properties\", \"typeAnnotation\"],\n builder: [\"properties\"],\n aliases: [\"FunctionParameter\", \"Pattern\", \"PatternLike\", \"LVal\"],\n fields: Object.assign({}, patternLikeCommon(), {\n properties: (0, _utils.validateArrayOfType)(\"RestElement\", \"ObjectProperty\")\n })\n});\ndefineType(\"SpreadElement\", {\n visitor: [\"argument\"],\n aliases: [\"UnaryLike\"],\n deprecatedAlias: \"SpreadProperty\",\n fields: {\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"Super\", {\n aliases: [\"Expression\"]\n});\ndefineType(\"TaggedTemplateExpression\", {\n visitor: [\"tag\", \"typeParameters\", \"quasi\"],\n builder: [\"tag\", \"quasi\"],\n aliases: [\"Expression\"],\n fields: {\n tag: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n quasi: {\n validate: (0, _utils.assertNodeType)(\"TemplateLiteral\")\n },\n [\"typeParameters\"]: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\", \"TSTypeParameterInstantiation\"),\n optional: true\n }\n }\n});\ndefineType(\"TemplateElement\", {\n builder: [\"value\", \"tail\"],\n fields: {\n value: {\n validate: (0, _utils.chain)((0, _utils.assertShape)({\n raw: {\n validate: (0, _utils.assertValueType)(\"string\")\n },\n cooked: {\n validate: (0, _utils.assertValueType)(\"string\"),\n optional: true\n }\n }), function templateElementCookedValidator(node) {\n const raw = node.value.raw;\n let unterminatedCalled = false;\n const error = () => {\n throw new Error(\"Internal @babel/types error.\");\n };\n const {\n str,\n firstInvalidLoc\n } = (0, _helperStringParser.readStringContents)(\"template\", raw, 0, 0, 0, {\n unterminated() {\n unterminatedCalled = true;\n },\n strictNumericEscape: error,\n invalidEscapeSequence: error,\n numericSeparatorInEscapeSequence: error,\n unexpectedNumericSeparator: error,\n invalidDigit: error,\n invalidCodePoint: error\n });\n if (!unterminatedCalled) throw new Error(\"Invalid raw\");\n node.value.cooked = firstInvalidLoc ? null : str;\n })\n },\n tail: {\n default: false\n }\n }\n});\ndefineType(\"TemplateLiteral\", {\n visitor: [\"quasis\", \"expressions\"],\n aliases: [\"Expression\", \"Literal\"],\n fields: {\n quasis: (0, _utils.validateArrayOfType)(\"TemplateElement\"),\n expressions: {\n validate: (0, _utils.chain)((0, _utils.assertValueType)(\"array\"), (0, _utils.assertEach)((0, _utils.assertNodeType)(\"Expression\", \"TSType\")), function (node, key, val) {\n if (node.quasis.length !== val.length + 1) {\n throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);\n }\n })\n }\n }\n});\ndefineType(\"YieldExpression\", {\n builder: [\"argument\", \"delegate\"],\n visitor: [\"argument\"],\n aliases: [\"Expression\", \"Terminatorless\"],\n fields: {\n delegate: {\n validate: process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.chain)((0, _utils.assertValueType)(\"boolean\"), Object.assign(function (node, key, val) {\n if (val && !node.argument) {\n throw new TypeError(\"Property delegate of YieldExpression cannot be true if there is no argument\");\n }\n }, {\n type: \"boolean\"\n })) : (0, _utils.assertValueType)(\"boolean\"),\n default: false\n },\n argument: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"AwaitExpression\", {\n builder: [\"argument\"],\n visitor: [\"argument\"],\n aliases: [\"Expression\", \"Terminatorless\"],\n fields: {\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"Import\", {\n aliases: [\"Expression\"]\n});\ndefineType(\"BigIntLiteral\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n },\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\ndefineType(\"ExportNamespaceSpecifier\", {\n visitor: [\"exported\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n exported: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\ndefineType(\"OptionalMemberExpression\", {\n builder: [\"object\", \"property\", \"computed\", \"optional\"],\n visitor: [\"object\", \"property\"],\n aliases: [\"Expression\"],\n fields: {\n object: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n property: {\n validate: function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n const validator = Object.assign(function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n }, {\n oneOfNodeTypes: [\"Expression\", \"Identifier\"]\n });\n return validator;\n }()\n },\n computed: {\n default: false\n },\n optional: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)(\"boolean\") : (0, _utils.chain)((0, _utils.assertValueType)(\"boolean\"), (0, _utils.assertOptionalChainStart)())\n }\n }\n});\ndefineType(\"OptionalCallExpression\", {\n visitor: [\"callee\", \"typeParameters\", \"typeArguments\", \"arguments\"],\n builder: [\"callee\", \"arguments\", \"optional\"],\n aliases: [\"Expression\"],\n fields: Object.assign({\n callee: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n arguments: (0, _utils.validateArrayOfType)(\"Expression\", \"SpreadElement\", \"ArgumentPlaceholder\"),\n optional: {\n validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)(\"boolean\") : (0, _utils.chain)((0, _utils.assertValueType)(\"boolean\"), (0, _utils.assertOptionalChainStart)())\n },\n typeArguments: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\"),\n optional: true\n }\n }, {\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TSTypeParameterInstantiation\"),\n optional: true\n }\n })\n});\ndefineType(\"ClassProperty\", Object.assign({\n visitor: [\"decorators\", \"variance\", \"key\", \"typeAnnotation\", \"value\"],\n builder: [\"key\", \"value\", \"typeAnnotation\", \"decorators\", \"computed\", \"static\"],\n aliases: [\"Property\"]\n}, classMethodOrPropertyUnionShapeCommon(), {\n fields: Object.assign({}, classMethodOrPropertyCommon(), {\n value: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n definite: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n typeAnnotation: {\n validate: (0, _utils.assertNodeType)(\"TypeAnnotation\", \"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n readonly: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n declare: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n variance: {\n validate: (0, _utils.assertNodeType)(\"Variance\"),\n optional: true\n }\n })\n}));\ndefineType(\"ClassAccessorProperty\", Object.assign({\n visitor: [\"decorators\", \"key\", \"typeAnnotation\", \"value\"],\n builder: [\"key\", \"value\", \"typeAnnotation\", \"decorators\", \"computed\", \"static\"],\n aliases: [\"Property\", \"Accessor\"]\n}, classMethodOrPropertyUnionShapeCommon(true), {\n fields: Object.assign({}, classMethodOrPropertyCommon(), {\n key: {\n validate: (0, _utils.chain)(function () {\n const normal = (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"PrivateName\");\n const computed = (0, _utils.assertNodeType)(\"Expression\");\n return function (node, key, val) {\n const validator = node.computed ? computed : normal;\n validator(node, key, val);\n };\n }(), (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\", \"NumericLiteral\", \"BigIntLiteral\", \"Expression\", \"PrivateName\"))\n },\n value: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n definite: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n typeAnnotation: {\n validate: (0, _utils.assertNodeType)(\"TypeAnnotation\", \"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n readonly: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n declare: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n variance: {\n validate: (0, _utils.assertNodeType)(\"Variance\"),\n optional: true\n }\n })\n}));\ndefineType(\"ClassPrivateProperty\", {\n visitor: [\"decorators\", \"variance\", \"key\", \"typeAnnotation\", \"value\"],\n builder: [\"key\", \"value\", \"decorators\", \"static\"],\n aliases: [\"Property\", \"Private\"],\n fields: {\n key: {\n validate: (0, _utils.assertNodeType)(\"PrivateName\")\n },\n value: {\n validate: (0, _utils.assertNodeType)(\"Expression\"),\n optional: true\n },\n typeAnnotation: {\n validate: (0, _utils.assertNodeType)(\"TypeAnnotation\", \"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n },\n static: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n default: false\n },\n readonly: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n optional: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n definite: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n variance: {\n validate: (0, _utils.assertNodeType)(\"Variance\"),\n optional: true\n }\n }\n});\ndefineType(\"ClassPrivateMethod\", {\n builder: [\"kind\", \"key\", \"params\", \"body\", \"static\"],\n visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\", \"body\"],\n aliases: [\"Function\", \"Scopable\", \"BlockParent\", \"FunctionParent\", \"Method\", \"Private\"],\n fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {\n kind: {\n validate: (0, _utils.assertOneOf)(\"get\", \"set\", \"method\"),\n default: \"method\"\n },\n key: {\n validate: (0, _utils.assertNodeType)(\"PrivateName\")\n },\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n }\n })\n});\ndefineType(\"PrivateName\", {\n visitor: [\"id\"],\n aliases: [\"Private\"],\n fields: {\n id: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\ndefineType(\"StaticBlock\", {\n visitor: [\"body\"],\n fields: {\n body: (0, _utils.validateArrayOfType)(\"Statement\")\n },\n aliases: [\"Scopable\", \"BlockParent\", \"FunctionParent\"]\n});\ndefineType(\"ImportAttribute\", {\n visitor: [\"key\", \"value\"],\n fields: {\n key: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"StringLiteral\")\n },\n value: {\n validate: (0, _utils.assertNodeType)(\"StringLiteral\")\n }\n }\n});\n\n//# sourceMappingURL=core.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = is;\nvar _shallowEqual = require(\"../utils/shallowEqual.js\");\nvar _isType = require(\"./isType.js\");\nvar _isPlaceholderType = require(\"./isPlaceholderType.js\");\nvar _index = require(\"../definitions/index.js\");\nfunction is(type, node, opts) {\n if (!node) return false;\n const matches = (0, _isType.default)(node.type, type);\n if (!matches) {\n if (!opts && node.type === \"Placeholder\" && type in _index.FLIPPED_ALIAS_KEYS) {\n return (0, _isPlaceholderType.default)(node.expectedNode, type);\n }\n return false;\n }\n if (opts === undefined) {\n return true;\n } else {\n return (0, _shallowEqual.default)(node, opts);\n }\n}\n\n//# sourceMappingURL=is.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isType;\nvar _index = require(\"../definitions/index.js\");\nfunction isType(nodeType, targetType) {\n if (nodeType === targetType) return true;\n if (nodeType == null) return false;\n if (_index.ALIAS_KEYS[targetType]) return false;\n const aliases = _index.FLIPPED_ALIAS_KEYS[targetType];\n if (aliases != null && aliases.includes(nodeType)) return true;\n return false;\n}\n\n//# sourceMappingURL=isType.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isPlaceholderType;\nvar _index = require(\"../definitions/index.js\");\nfunction isPlaceholderType(placeholderType, targetType) {\n if (placeholderType === targetType) return true;\n const aliases = _index.PLACEHOLDERS_ALIAS[placeholderType];\n if (aliases != null && aliases.includes(targetType)) return true;\n return false;\n}\n\n//# sourceMappingURL=isPlaceholderType.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isValidIdentifier;\nvar _helperValidatorIdentifier = require(\"@babel/helper-validator-identifier\");\nfunction isValidIdentifier(name, reserved = true) {\n if (typeof name !== \"string\") return false;\n if (reserved) {\n if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) {\n return false;\n }\n }\n return (0, _helperValidatorIdentifier.isIdentifierName)(name);\n}\n\n//# sourceMappingURL=isValidIdentifier.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;\nconst STATEMENT_OR_BLOCK_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = [\"consequent\", \"body\", \"alternate\"];\nconst FLATTENABLE_KEYS = exports.FLATTENABLE_KEYS = [\"body\", \"expressions\"];\nconst FOR_INIT_KEYS = exports.FOR_INIT_KEYS = [\"left\", \"init\"];\nconst COMMENT_KEYS = exports.COMMENT_KEYS = [\"leadingComments\", \"trailingComments\", \"innerComments\"];\nconst LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = [\"||\", \"&&\", \"??\"];\nconst UPDATE_OPERATORS = exports.UPDATE_OPERATORS = [\"++\", \"--\"];\nconst BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = [\">\", \"<\", \">=\", \"<=\"];\nconst EQUALITY_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = [\"==\", \"===\", \"!=\", \"!==\"];\nconst COMPARISON_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, \"in\", \"instanceof\"];\nconst BOOLEAN_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];\nconst NUMBER_BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = [\"-\", \"/\", \"%\", \"*\", \"**\", \"&\", \"|\", \">>\", \">>>\", \"<<\", \"^\"];\nconst BINARY_OPERATORS = exports.BINARY_OPERATORS = [\"+\", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, \"|>\"];\nconst ASSIGNMENT_OPERATORS = exports.ASSIGNMENT_OPERATORS = [\"=\", \"+=\", ...NUMBER_BINARY_OPERATORS.map(op => op + \"=\"), ...LOGICAL_OPERATORS.map(op => op + \"=\")];\nconst BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = [\"delete\", \"!\"];\nconst NUMBER_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = [\"+\", \"-\", \"~\"];\nconst STRING_UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = [\"typeof\"];\nconst UNARY_OPERATORS = exports.UNARY_OPERATORS = [\"void\", \"throw\", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];\nconst INHERIT_KEYS = exports.INHERIT_KEYS = {\n optional: [\"typeAnnotation\", \"typeParameters\", \"returnType\"],\n force: [\"start\", \"loc\", \"end\"]\n};\nexports.BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\nexports.NOT_LOCAL_BINDING = Symbol.for(\"should not be considered a local binding\");\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.allExpandedTypes = exports.VISITOR_KEYS = exports.NODE_UNION_SHAPES__PRIVATE = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0;\nexports.arrayOf = arrayOf;\nexports.arrayOfType = arrayOfType;\nexports.assertEach = assertEach;\nexports.assertNodeOrValueType = assertNodeOrValueType;\nexports.assertNodeType = assertNodeType;\nexports.assertOneOf = assertOneOf;\nexports.assertOptionalChainStart = assertOptionalChainStart;\nexports.assertShape = assertShape;\nexports.assertValueType = assertValueType;\nexports.chain = chain;\nexports.default = defineType;\nexports.defineAliasedType = defineAliasedType;\nexports.validate = validate;\nexports.validateArrayOfType = validateArrayOfType;\nexports.validateOptional = validateOptional;\nexports.validateOptionalType = validateOptionalType;\nexports.validateType = validateType;\nvar _is = require(\"../validators/is.js\");\nvar _validate = require(\"../validators/validate.js\");\nconst VISITOR_KEYS = exports.VISITOR_KEYS = {};\nconst ALIAS_KEYS = exports.ALIAS_KEYS = {};\nconst FLIPPED_ALIAS_KEYS = exports.FLIPPED_ALIAS_KEYS = {};\nconst NODE_FIELDS = exports.NODE_FIELDS = {};\nconst BUILDER_KEYS = exports.BUILDER_KEYS = {};\nconst DEPRECATED_KEYS = exports.DEPRECATED_KEYS = {};\nconst NODE_PARENT_VALIDATIONS = exports.NODE_PARENT_VALIDATIONS = {};\nconst NODE_UNION_SHAPES__PRIVATE = exports.NODE_UNION_SHAPES__PRIVATE = {};\nfunction getType(val) {\n if (Array.isArray(val)) {\n return \"array\";\n } else if (val === null) {\n return \"null\";\n } else {\n return typeof val;\n }\n}\nfunction validate(validate) {\n return {\n validate\n };\n}\nfunction validateType(...typeNames) {\n return validate(assertNodeType(...typeNames));\n}\nfunction validateOptional(validate) {\n return {\n validate,\n optional: true\n };\n}\nfunction validateOptionalType(...typeNames) {\n return {\n validate: assertNodeType(...typeNames),\n optional: true\n };\n}\nfunction arrayOf(elementType) {\n return chain(assertValueType(\"array\"), assertEach(elementType));\n}\nfunction arrayOfType(...typeNames) {\n return arrayOf(assertNodeType(...typeNames));\n}\nfunction validateArrayOfType(...typeNames) {\n return validate(arrayOfType(...typeNames));\n}\nfunction assertEach(callback) {\n const childValidator = process.env.BABEL_TYPES_8_BREAKING ? _validate.validateChild : () => {};\n function validator(node, key, val) {\n if (!Array.isArray(val)) return;\n let i = 0;\n const subKey = {\n toString() {\n return `${key}[${i}]`;\n }\n };\n for (; i < val.length; i++) {\n const v = val[i];\n callback(node, subKey, v);\n childValidator(node, subKey, v);\n }\n }\n validator.each = callback;\n return validator;\n}\nfunction assertOneOf(...values) {\n function validate(node, key, val) {\n if (!values.includes(val)) {\n throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);\n }\n }\n validate.oneOf = values;\n return validate;\n}\nconst allExpandedTypes = exports.allExpandedTypes = [];\nfunction assertNodeType(...types) {\n const expandedTypes = new Set();\n allExpandedTypes.push({\n types,\n set: expandedTypes\n });\n function validate(node, key, val) {\n const valType = val == null ? void 0 : val.type;\n if (valType != null) {\n if (expandedTypes.has(valType)) {\n (0, _validate.validateChild)(node, key, val);\n return;\n }\n if (valType === \"Placeholder\") {\n for (const type of types) {\n if ((0, _is.default)(type, val)) {\n (0, _validate.validateChild)(node, key, val);\n return;\n }\n }\n }\n }\n throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(valType)}`);\n }\n validate.oneOfNodeTypes = types;\n return validate;\n}\nfunction assertNodeOrValueType(...types) {\n function validate(node, key, val) {\n const primitiveType = getType(val);\n for (const type of types) {\n if (primitiveType === type || (0, _is.default)(type, val)) {\n (0, _validate.validateChild)(node, key, val);\n return;\n }\n }\n throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);\n }\n validate.oneOfNodeOrValueTypes = types;\n return validate;\n}\nfunction assertValueType(type) {\n function validate(node, key, val) {\n if (getType(val) === type) {\n return;\n }\n throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);\n }\n validate.type = type;\n return validate;\n}\nfunction assertShape(shape) {\n const keys = Object.keys(shape);\n function validate(node, key, val) {\n const errors = [];\n for (const property of keys) {\n try {\n (0, _validate.validateField)(node, property, val[property], shape[property]);\n } catch (error) {\n if (error instanceof TypeError) {\n errors.push(error.message);\n continue;\n }\n throw error;\n }\n }\n if (errors.length) {\n throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\\n${errors.join(\"\\n\")}`);\n }\n }\n validate.shapeOf = shape;\n return validate;\n}\nfunction assertOptionalChainStart() {\n function validate(node) {\n var _current;\n let current = node;\n while (node) {\n const {\n type\n } = current;\n if (type === \"OptionalCallExpression\") {\n if (current.optional) return;\n current = current.callee;\n continue;\n }\n if (type === \"OptionalMemberExpression\") {\n if (current.optional) return;\n current = current.object;\n continue;\n }\n break;\n }\n throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);\n }\n return validate;\n}\nfunction chain(...fns) {\n function validate(...args) {\n for (const fn of fns) {\n fn(...args);\n }\n }\n validate.chainOf = fns;\n if (fns.length >= 2 && \"type\" in fns[0] && fns[0].type === \"array\" && !(\"each\" in fns[1])) {\n throw new Error(`An assertValueType(\"array\") validator can only be followed by an assertEach(...) validator.`);\n }\n return validate;\n}\nconst validTypeOpts = new Set([\"aliases\", \"builder\", \"deprecatedAlias\", \"fields\", \"inherits\", \"visitor\", \"validate\", \"unionShape\"]);\nconst validFieldKeys = new Set([\"default\", \"optional\", \"deprecated\", \"validate\"]);\nconst store = {};\nfunction defineAliasedType(...aliases) {\n return (type, opts = {}) => {\n let defined = opts.aliases;\n if (!defined) {\n var _store$opts$inherits$;\n if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice();\n defined != null ? defined : defined = [];\n opts.aliases = defined;\n }\n const additional = aliases.filter(a => !defined.includes(a));\n defined.unshift(...additional);\n defineType(type, opts);\n };\n}\nfunction defineType(type, opts = {}) {\n const inherits = opts.inherits && store[opts.inherits] || {};\n let fields = opts.fields;\n if (!fields) {\n fields = {};\n if (inherits.fields) {\n const keys = Object.getOwnPropertyNames(inherits.fields);\n for (const key of keys) {\n const field = inherits.fields[key];\n const def = field.default;\n if (Array.isArray(def) ? def.length > 0 : def && typeof def === \"object\") {\n throw new Error(\"field defaults can only be primitives or empty arrays currently\");\n }\n fields[key] = {\n default: Array.isArray(def) ? [] : def,\n optional: field.optional,\n deprecated: field.deprecated,\n validate: field.validate\n };\n }\n }\n }\n const visitor = opts.visitor || inherits.visitor || [];\n const aliases = opts.aliases || inherits.aliases || [];\n const builder = opts.builder || inherits.builder || opts.visitor || [];\n for (const k of Object.keys(opts)) {\n if (!validTypeOpts.has(k)) {\n throw new Error(`Unknown type option \"${k}\" on ${type}`);\n }\n }\n if (opts.deprecatedAlias) {\n DEPRECATED_KEYS[opts.deprecatedAlias] = type;\n }\n for (const key of visitor.concat(builder)) {\n fields[key] = fields[key] || {};\n }\n for (const key of Object.keys(fields)) {\n const field = fields[key];\n if (field.default !== undefined && !builder.includes(key)) {\n field.optional = true;\n }\n if (field.default === undefined) {\n field.default = null;\n } else if (!field.validate && field.default != null) {\n field.validate = assertValueType(getType(field.default));\n }\n for (const k of Object.keys(field)) {\n if (!validFieldKeys.has(k)) {\n throw new Error(`Unknown field key \"${k}\" on ${type}.${key}`);\n }\n }\n }\n VISITOR_KEYS[type] = opts.visitor = visitor;\n BUILDER_KEYS[type] = opts.builder = builder;\n NODE_FIELDS[type] = opts.fields = fields;\n ALIAS_KEYS[type] = opts.aliases = aliases;\n aliases.forEach(alias => {\n FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];\n FLIPPED_ALIAS_KEYS[alias].push(type);\n });\n if (opts.validate) {\n NODE_PARENT_VALIDATIONS[type] = opts.validate;\n }\n if (opts.unionShape) {\n NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape;\n }\n store[type] = opts;\n}\n\n//# sourceMappingURL=utils.js.map\n","\n\nvar _core = require(\"./core.js\");\nvar _utils = require(\"./utils.js\");\nconst defineType = (0, _utils.defineAliasedType)(\"Flow\");\nconst defineInterfaceishType = name => {\n const isDeclareClass = name === \"DeclareClass\";\n defineType(name, {\n builder: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n visitor: [\"id\", \"typeParameters\", \"extends\", ...(isDeclareClass ? [\"mixins\", \"implements\"] : []), \"body\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: Object.assign({\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"InterfaceExtends\"))\n }, isDeclareClass ? {\n mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"InterfaceExtends\")),\n implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"ClassImplements\"))\n } : {}, {\n body: (0, _utils.validateType)(\"ObjectTypeAnnotation\")\n })\n });\n};\ndefineType(\"AnyTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"ArrayTypeAnnotation\", {\n visitor: [\"elementType\"],\n aliases: [\"FlowType\"],\n fields: {\n elementType: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"BooleanTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"BooleanLiteralTypeAnnotation\", {\n builder: [\"value\"],\n aliases: [\"FlowType\"],\n fields: {\n value: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"NullLiteralTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"ClassImplements\", {\n visitor: [\"id\", \"typeParameters\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterInstantiation\")\n }\n});\ndefineInterfaceishType(\"DeclareClass\");\ndefineType(\"DeclareFunction\", {\n builder: [\"id\"],\n visitor: [\"id\", \"predicate\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n predicate: (0, _utils.validateOptionalType)(\"DeclaredPredicate\")\n }\n});\ndefineInterfaceishType(\"DeclareInterface\");\ndefineType(\"DeclareModule\", {\n builder: [\"id\", \"body\", \"kind\"],\n visitor: [\"id\", \"body\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\", \"StringLiteral\"),\n body: (0, _utils.validateType)(\"BlockStatement\"),\n kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(\"CommonJS\", \"ES\"))\n }\n});\ndefineType(\"DeclareModuleExports\", {\n visitor: [\"typeAnnotation\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"TypeAnnotation\")\n }\n});\ndefineType(\"DeclareTypeAlias\", {\n visitor: [\"id\", \"typeParameters\", \"right\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n right: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"DeclareOpaqueType\", {\n visitor: [\"id\", \"typeParameters\", \"supertype\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n supertype: (0, _utils.validateOptionalType)(\"FlowType\"),\n impltype: (0, _utils.validateOptionalType)(\"FlowType\")\n }\n});\ndefineType(\"DeclareVariable\", {\n visitor: [\"id\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\")\n }\n});\ndefineType(\"DeclareExportDeclaration\", {\n visitor: [\"declaration\", \"specifiers\", \"source\", \"attributes\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: Object.assign({\n declaration: (0, _utils.validateOptionalType)(\"Flow\"),\n specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"ExportSpecifier\", \"ExportNamespaceSpecifier\")),\n source: (0, _utils.validateOptionalType)(\"StringLiteral\"),\n default: (0, _utils.validateOptional)((0, _utils.assertValueType)(\"boolean\"))\n }, _core.importAttributes)\n});\ndefineType(\"DeclareExportAllDeclaration\", {\n visitor: [\"source\", \"attributes\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: Object.assign({\n source: (0, _utils.validateType)(\"StringLiteral\"),\n exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(\"type\", \"value\"))\n }, _core.importAttributes)\n});\ndefineType(\"DeclaredPredicate\", {\n visitor: [\"value\"],\n aliases: [\"FlowPredicate\"],\n fields: {\n value: (0, _utils.validateType)(\"Flow\")\n }\n});\ndefineType(\"ExistsTypeAnnotation\", {\n aliases: [\"FlowType\"]\n});\ndefineType(\"FunctionTypeAnnotation\", {\n builder: [\"typeParameters\", \"params\", \"rest\", \"returnType\"],\n visitor: [\"typeParameters\", \"this\", \"params\", \"rest\", \"returnType\"],\n aliases: [\"FlowType\"],\n fields: {\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n params: (0, _utils.validateArrayOfType)(\"FunctionTypeParam\"),\n rest: (0, _utils.validateOptionalType)(\"FunctionTypeParam\"),\n this: (0, _utils.validateOptionalType)(\"FunctionTypeParam\"),\n returnType: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"FunctionTypeParam\", {\n visitor: [\"name\", \"typeAnnotation\"],\n fields: {\n name: (0, _utils.validateOptionalType)(\"Identifier\"),\n typeAnnotation: (0, _utils.validateType)(\"FlowType\"),\n optional: (0, _utils.validateOptional)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"GenericTypeAnnotation\", {\n visitor: [\"id\", \"typeParameters\"],\n aliases: [\"FlowType\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\", \"QualifiedTypeIdentifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterInstantiation\")\n }\n});\ndefineType(\"InferredPredicate\", {\n aliases: [\"FlowPredicate\"]\n});\ndefineType(\"InterfaceExtends\", {\n visitor: [\"id\", \"typeParameters\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\", \"QualifiedTypeIdentifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterInstantiation\")\n }\n});\ndefineInterfaceishType(\"InterfaceDeclaration\");\ndefineType(\"InterfaceTypeAnnotation\", {\n visitor: [\"extends\", \"body\"],\n aliases: [\"FlowType\"],\n fields: {\n extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"InterfaceExtends\")),\n body: (0, _utils.validateType)(\"ObjectTypeAnnotation\")\n }\n});\ndefineType(\"IntersectionTypeAnnotation\", {\n visitor: [\"types\"],\n aliases: [\"FlowType\"],\n fields: {\n types: (0, _utils.validate)((0, _utils.arrayOfType)(\"FlowType\"))\n }\n});\ndefineType(\"MixedTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"EmptyTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"NullableTypeAnnotation\", {\n visitor: [\"typeAnnotation\"],\n aliases: [\"FlowType\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"NumberLiteralTypeAnnotation\", {\n builder: [\"value\"],\n aliases: [\"FlowType\"],\n fields: {\n value: (0, _utils.validate)((0, _utils.assertValueType)(\"number\"))\n }\n});\ndefineType(\"NumberTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"ObjectTypeAnnotation\", {\n visitor: [\"properties\", \"indexers\", \"callProperties\", \"internalSlots\"],\n aliases: [\"FlowType\"],\n builder: [\"properties\", \"indexers\", \"callProperties\", \"internalSlots\", \"exact\"],\n fields: {\n properties: (0, _utils.validate)((0, _utils.arrayOfType)(\"ObjectTypeProperty\", \"ObjectTypeSpreadProperty\")),\n indexers: {\n validate: (0, _utils.arrayOfType)(\"ObjectTypeIndexer\"),\n optional: true,\n default: []\n },\n callProperties: {\n validate: (0, _utils.arrayOfType)(\"ObjectTypeCallProperty\"),\n optional: true,\n default: []\n },\n internalSlots: {\n validate: (0, _utils.arrayOfType)(\"ObjectTypeInternalSlot\"),\n optional: true,\n default: []\n },\n exact: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n default: false\n },\n inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"ObjectTypeInternalSlot\", {\n visitor: [\"id\", \"value\"],\n builder: [\"id\", \"value\", \"optional\", \"static\", \"method\"],\n aliases: [\"UserWhitespacable\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n value: (0, _utils.validateType)(\"FlowType\"),\n optional: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n static: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n method: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"ObjectTypeCallProperty\", {\n visitor: [\"value\"],\n aliases: [\"UserWhitespacable\"],\n fields: {\n value: (0, _utils.validateType)(\"FlowType\"),\n static: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"ObjectTypeIndexer\", {\n visitor: [\"variance\", \"id\", \"key\", \"value\"],\n builder: [\"id\", \"key\", \"value\", \"variance\"],\n aliases: [\"UserWhitespacable\"],\n fields: {\n id: (0, _utils.validateOptionalType)(\"Identifier\"),\n key: (0, _utils.validateType)(\"FlowType\"),\n value: (0, _utils.validateType)(\"FlowType\"),\n static: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n variance: (0, _utils.validateOptionalType)(\"Variance\")\n }\n});\ndefineType(\"ObjectTypeProperty\", {\n visitor: [\"key\", \"value\", \"variance\"],\n aliases: [\"UserWhitespacable\"],\n fields: {\n key: (0, _utils.validateType)(\"Identifier\", \"StringLiteral\"),\n value: (0, _utils.validateType)(\"FlowType\"),\n kind: (0, _utils.validate)((0, _utils.assertOneOf)(\"init\", \"get\", \"set\")),\n static: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n proto: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n optional: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n variance: (0, _utils.validateOptionalType)(\"Variance\"),\n method: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"ObjectTypeSpreadProperty\", {\n visitor: [\"argument\"],\n aliases: [\"UserWhitespacable\"],\n fields: {\n argument: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"OpaqueType\", {\n visitor: [\"id\", \"typeParameters\", \"supertype\", \"impltype\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n supertype: (0, _utils.validateOptionalType)(\"FlowType\"),\n impltype: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"QualifiedTypeIdentifier\", {\n visitor: [\"qualification\", \"id\"],\n builder: [\"id\", \"qualification\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n qualification: (0, _utils.validateType)(\"Identifier\", \"QualifiedTypeIdentifier\")\n }\n});\ndefineType(\"StringLiteralTypeAnnotation\", {\n builder: [\"value\"],\n aliases: [\"FlowType\"],\n fields: {\n value: (0, _utils.validate)((0, _utils.assertValueType)(\"string\"))\n }\n});\ndefineType(\"StringTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"SymbolTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"ThisTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"TupleTypeAnnotation\", {\n visitor: [\"types\"],\n aliases: [\"FlowType\"],\n fields: {\n types: (0, _utils.validate)((0, _utils.arrayOfType)(\"FlowType\"))\n }\n});\ndefineType(\"TypeofTypeAnnotation\", {\n visitor: [\"argument\"],\n aliases: [\"FlowType\"],\n fields: {\n argument: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"TypeAlias\", {\n visitor: [\"id\", \"typeParameters\", \"right\"],\n aliases: [\"FlowDeclaration\", \"Statement\", \"Declaration\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TypeParameterDeclaration\"),\n right: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"TypeAnnotation\", {\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"TypeCastExpression\", {\n visitor: [\"expression\", \"typeAnnotation\"],\n aliases: [\"ExpressionWrapper\", \"Expression\"],\n fields: {\n expression: (0, _utils.validateType)(\"Expression\"),\n typeAnnotation: (0, _utils.validateType)(\"TypeAnnotation\")\n }\n});\ndefineType(\"TypeParameter\", {\n visitor: [\"bound\", \"default\", \"variance\"],\n fields: {\n name: (0, _utils.validate)((0, _utils.assertValueType)(\"string\")),\n bound: (0, _utils.validateOptionalType)(\"TypeAnnotation\"),\n default: (0, _utils.validateOptionalType)(\"FlowType\"),\n variance: (0, _utils.validateOptionalType)(\"Variance\")\n }\n});\ndefineType(\"TypeParameterDeclaration\", {\n visitor: [\"params\"],\n fields: {\n params: (0, _utils.validate)((0, _utils.arrayOfType)(\"TypeParameter\"))\n }\n});\ndefineType(\"TypeParameterInstantiation\", {\n visitor: [\"params\"],\n fields: {\n params: (0, _utils.validate)((0, _utils.arrayOfType)(\"FlowType\"))\n }\n});\ndefineType(\"UnionTypeAnnotation\", {\n visitor: [\"types\"],\n aliases: [\"FlowType\"],\n fields: {\n types: (0, _utils.validate)((0, _utils.arrayOfType)(\"FlowType\"))\n }\n});\ndefineType(\"Variance\", {\n builder: [\"kind\"],\n fields: {\n kind: (0, _utils.validate)((0, _utils.assertOneOf)(\"minus\", \"plus\"))\n }\n});\ndefineType(\"VoidTypeAnnotation\", {\n aliases: [\"FlowType\", \"FlowBaseAnnotation\"]\n});\ndefineType(\"EnumDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"body\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n body: (0, _utils.validateType)(\"EnumBooleanBody\", \"EnumNumberBody\", \"EnumStringBody\", \"EnumSymbolBody\")\n }\n});\ndefineType(\"EnumBooleanBody\", {\n aliases: [\"EnumBody\"],\n visitor: [\"members\"],\n fields: {\n explicitType: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n members: (0, _utils.validateArrayOfType)(\"EnumBooleanMember\"),\n hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"EnumNumberBody\", {\n aliases: [\"EnumBody\"],\n visitor: [\"members\"],\n fields: {\n explicitType: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n members: (0, _utils.validateArrayOfType)(\"EnumNumberMember\"),\n hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"EnumStringBody\", {\n aliases: [\"EnumBody\"],\n visitor: [\"members\"],\n fields: {\n explicitType: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\")),\n members: (0, _utils.validateArrayOfType)(\"EnumStringMember\", \"EnumDefaultedMember\"),\n hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"EnumSymbolBody\", {\n aliases: [\"EnumBody\"],\n visitor: [\"members\"],\n fields: {\n members: (0, _utils.validateArrayOfType)(\"EnumDefaultedMember\"),\n hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\ndefineType(\"EnumBooleanMember\", {\n aliases: [\"EnumMember\"],\n builder: [\"id\"],\n visitor: [\"id\", \"init\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n init: (0, _utils.validateType)(\"BooleanLiteral\")\n }\n});\ndefineType(\"EnumNumberMember\", {\n aliases: [\"EnumMember\"],\n visitor: [\"id\", \"init\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n init: (0, _utils.validateType)(\"NumericLiteral\")\n }\n});\ndefineType(\"EnumStringMember\", {\n aliases: [\"EnumMember\"],\n visitor: [\"id\", \"init\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\"),\n init: (0, _utils.validateType)(\"StringLiteral\")\n }\n});\ndefineType(\"EnumDefaultedMember\", {\n aliases: [\"EnumMember\"],\n visitor: [\"id\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\")\n }\n});\ndefineType(\"IndexedAccessType\", {\n visitor: [\"objectType\", \"indexType\"],\n aliases: [\"FlowType\"],\n fields: {\n objectType: (0, _utils.validateType)(\"FlowType\"),\n indexType: (0, _utils.validateType)(\"FlowType\")\n }\n});\ndefineType(\"OptionalIndexedAccessType\", {\n visitor: [\"objectType\", \"indexType\"],\n aliases: [\"FlowType\"],\n fields: {\n objectType: (0, _utils.validateType)(\"FlowType\"),\n indexType: (0, _utils.validateType)(\"FlowType\"),\n optional: (0, _utils.validate)((0, _utils.assertValueType)(\"boolean\"))\n }\n});\n\n//# sourceMappingURL=flow.js.map\n","\n\nvar _utils = require(\"./utils.js\");\nconst defineType = (0, _utils.defineAliasedType)(\"JSX\");\ndefineType(\"JSXAttribute\", {\n visitor: [\"name\", \"value\"],\n aliases: [\"Immutable\"],\n fields: {\n name: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\", \"JSXNamespacedName\")\n },\n value: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"JSXElement\", \"JSXFragment\", \"StringLiteral\", \"JSXExpressionContainer\")\n }\n }\n});\ndefineType(\"JSXClosingElement\", {\n visitor: [\"name\"],\n aliases: [\"Immutable\"],\n fields: {\n name: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\", \"JSXMemberExpression\", \"JSXNamespacedName\")\n }\n }\n});\ndefineType(\"JSXElement\", {\n builder: [\"openingElement\", \"closingElement\", \"children\", \"selfClosing\"],\n visitor: [\"openingElement\", \"children\", \"closingElement\"],\n aliases: [\"Immutable\", \"Expression\"],\n fields: Object.assign({\n openingElement: {\n validate: (0, _utils.assertNodeType)(\"JSXOpeningElement\")\n },\n closingElement: {\n optional: true,\n validate: (0, _utils.assertNodeType)(\"JSXClosingElement\")\n },\n children: (0, _utils.validateArrayOfType)(\"JSXText\", \"JSXExpressionContainer\", \"JSXSpreadChild\", \"JSXElement\", \"JSXFragment\")\n }, {\n selfClosing: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n }\n })\n});\ndefineType(\"JSXEmptyExpression\", {});\ndefineType(\"JSXExpressionContainer\", {\n visitor: [\"expression\"],\n aliases: [\"Immutable\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\", \"JSXEmptyExpression\")\n }\n }\n});\ndefineType(\"JSXSpreadChild\", {\n visitor: [\"expression\"],\n aliases: [\"Immutable\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"JSXIdentifier\", {\n builder: [\"name\"],\n fields: {\n name: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n }\n});\ndefineType(\"JSXMemberExpression\", {\n visitor: [\"object\", \"property\"],\n fields: {\n object: {\n validate: (0, _utils.assertNodeType)(\"JSXMemberExpression\", \"JSXIdentifier\")\n },\n property: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\")\n }\n }\n});\ndefineType(\"JSXNamespacedName\", {\n visitor: [\"namespace\", \"name\"],\n fields: {\n namespace: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\")\n },\n name: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\")\n }\n }\n});\ndefineType(\"JSXOpeningElement\", {\n builder: [\"name\", \"attributes\", \"selfClosing\"],\n visitor: [\"name\", \"typeParameters\", \"typeArguments\", \"attributes\"],\n aliases: [\"Immutable\"],\n fields: Object.assign({\n name: {\n validate: (0, _utils.assertNodeType)(\"JSXIdentifier\", \"JSXMemberExpression\", \"JSXNamespacedName\")\n },\n selfClosing: {\n default: false\n },\n attributes: (0, _utils.validateArrayOfType)(\"JSXAttribute\", \"JSXSpreadAttribute\"),\n typeArguments: {\n validate: (0, _utils.assertNodeType)(\"TypeParameterInstantiation\"),\n optional: true\n }\n }, {\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TSTypeParameterInstantiation\"),\n optional: true\n }\n })\n});\ndefineType(\"JSXSpreadAttribute\", {\n visitor: [\"argument\"],\n fields: {\n argument: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\ndefineType(\"JSXText\", {\n aliases: [\"Immutable\"],\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n }\n});\ndefineType(\"JSXFragment\", {\n builder: [\"openingFragment\", \"closingFragment\", \"children\"],\n visitor: [\"openingFragment\", \"children\", \"closingFragment\"],\n aliases: [\"Immutable\", \"Expression\"],\n fields: {\n openingFragment: {\n validate: (0, _utils.assertNodeType)(\"JSXOpeningFragment\")\n },\n closingFragment: {\n validate: (0, _utils.assertNodeType)(\"JSXClosingFragment\")\n },\n children: (0, _utils.validateArrayOfType)(\"JSXText\", \"JSXExpressionContainer\", \"JSXSpreadChild\", \"JSXElement\", \"JSXFragment\")\n }\n});\ndefineType(\"JSXOpeningFragment\", {\n aliases: [\"Immutable\"]\n});\ndefineType(\"JSXClosingFragment\", {\n aliases: [\"Immutable\"]\n});\n\n//# sourceMappingURL=jsx.js.map\n","\n\nvar _utils = require(\"./utils.js\");\nvar _placeholders = require(\"./placeholders.js\");\nvar _core = require(\"./core.js\");\nconst defineType = (0, _utils.defineAliasedType)(\"Miscellaneous\");\ndefineType(\"Noop\", {\n visitor: []\n});\ndefineType(\"Placeholder\", {\n visitor: [],\n builder: [\"expectedNode\", \"name\"],\n fields: Object.assign({\n name: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n },\n expectedNode: {\n validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)\n }\n }, (0, _core.patternLikeCommon)())\n});\ndefineType(\"V8IntrinsicIdentifier\", {\n builder: [\"name\"],\n fields: {\n name: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n }\n});\n\n//# sourceMappingURL=misc.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;\nvar _utils = require(\"./utils.js\");\nconst PLACEHOLDERS = exports.PLACEHOLDERS = [\"Identifier\", \"StringLiteral\", \"Expression\", \"Statement\", \"Declaration\", \"BlockStatement\", \"ClassBody\", \"Pattern\"];\nconst PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS_ALIAS = {\n Declaration: [\"Statement\"],\n Pattern: [\"PatternLike\", \"LVal\"]\n};\nfor (const type of PLACEHOLDERS) {\n const alias = _utils.ALIAS_KEYS[type];\n if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;\n}\nconst PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_FLIPPED_ALIAS = {};\nObject.keys(PLACEHOLDERS_ALIAS).forEach(type => {\n PLACEHOLDERS_ALIAS[type].forEach(alias => {\n if (!hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {\n PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];\n }\n PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);\n });\n});\n\n//# sourceMappingURL=placeholders.js.map\n","\n\nvar _utils = require(\"./utils.js\");\n(0, _utils.default)(\"ArgumentPlaceholder\", {});\n(0, _utils.default)(\"BindExpression\", {\n visitor: [\"object\", \"callee\"],\n aliases: [\"Expression\"],\n fields: !process.env.BABEL_TYPES_8_BREAKING ? {\n object: {\n validate: Object.assign(() => {}, {\n oneOfNodeTypes: [\"Expression\"]\n })\n },\n callee: {\n validate: Object.assign(() => {}, {\n oneOfNodeTypes: [\"Expression\"]\n })\n }\n } : {\n object: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n },\n callee: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\n(0, _utils.default)(\"Decorator\", {\n visitor: [\"expression\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n }\n});\n(0, _utils.default)(\"DoExpression\", {\n visitor: [\"body\"],\n builder: [\"body\", \"async\"],\n aliases: [\"Expression\"],\n fields: {\n body: {\n validate: (0, _utils.assertNodeType)(\"BlockStatement\")\n },\n async: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n default: false\n }\n }\n});\n(0, _utils.default)(\"ExportDefaultSpecifier\", {\n visitor: [\"exported\"],\n aliases: [\"ModuleSpecifier\"],\n fields: {\n exported: {\n validate: (0, _utils.assertNodeType)(\"Identifier\")\n }\n }\n});\n(0, _utils.default)(\"RecordExpression\", {\n visitor: [\"properties\"],\n aliases: [\"Expression\"],\n fields: {\n properties: (0, _utils.validateArrayOfType)(\"ObjectProperty\", \"SpreadElement\")\n }\n});\n(0, _utils.default)(\"TupleExpression\", {\n fields: {\n elements: {\n validate: (0, _utils.arrayOfType)(\"Expression\", \"SpreadElement\"),\n default: []\n }\n },\n visitor: [\"elements\"],\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"DecimalLiteral\", {\n builder: [\"value\"],\n fields: {\n value: {\n validate: (0, _utils.assertValueType)(\"string\")\n }\n },\n aliases: [\"Expression\", \"Pureish\", \"Literal\", \"Immutable\"]\n});\n(0, _utils.default)(\"ModuleExpression\", {\n visitor: [\"body\"],\n fields: {\n body: {\n validate: (0, _utils.assertNodeType)(\"Program\")\n }\n },\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"TopicReference\", {\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"PipelineTopicExpression\", {\n builder: [\"expression\"],\n visitor: [\"expression\"],\n fields: {\n expression: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"PipelineBareFunction\", {\n builder: [\"callee\"],\n visitor: [\"callee\"],\n fields: {\n callee: {\n validate: (0, _utils.assertNodeType)(\"Expression\")\n }\n },\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"PipelinePrimaryTopicReference\", {\n aliases: [\"Expression\"]\n});\n(0, _utils.default)(\"VoidPattern\", {\n aliases: [\"Pattern\", \"PatternLike\", \"FunctionParameter\"]\n});\n\n//# sourceMappingURL=experimental.js.map\n","\n\nvar _utils = require(\"./utils.js\");\nvar _core = require(\"./core.js\");\nvar _is = require(\"../validators/is.js\");\nconst defineType = (0, _utils.defineAliasedType)(\"TypeScript\");\nconst bool = (0, _utils.assertValueType)(\"boolean\");\nconst tSFunctionTypeAnnotationCommon = () => ({\n returnType: {\n validate: (0, _utils.assertNodeType)(\"TSTypeAnnotation\", \"Noop\"),\n optional: true\n },\n typeParameters: {\n validate: (0, _utils.assertNodeType)(\"TSTypeParameterDeclaration\", \"Noop\"),\n optional: true\n }\n});\ndefineType(\"TSParameterProperty\", {\n aliases: [\"LVal\"],\n visitor: [\"parameter\"],\n fields: {\n accessibility: {\n validate: (0, _utils.assertOneOf)(\"public\", \"private\", \"protected\"),\n optional: true\n },\n readonly: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n parameter: {\n validate: (0, _utils.assertNodeType)(\"Identifier\", \"AssignmentPattern\")\n },\n override: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n decorators: {\n validate: (0, _utils.arrayOfType)(\"Decorator\"),\n optional: true\n }\n }\n});\ndefineType(\"TSDeclareFunction\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"params\", \"returnType\"],\n fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())\n});\ndefineType(\"TSDeclareMethod\", Object.assign({\n visitor: [\"decorators\", \"key\", \"typeParameters\", \"params\", \"returnType\"]\n}, (0, _core.classMethodOrPropertyUnionShapeCommon)(), {\n fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())\n}));\ndefineType(\"TSQualifiedName\", {\n aliases: [\"TSEntityName\"],\n visitor: [\"left\", \"right\"],\n fields: {\n left: (0, _utils.validateType)(\"TSEntityName\"),\n right: (0, _utils.validateType)(\"Identifier\")\n }\n});\nconst signatureDeclarationCommon = () => ({\n typeParameters: (0, _utils.validateOptionalType)(\"TSTypeParameterDeclaration\"),\n [\"parameters\"]: (0, _utils.validateArrayOfType)(\"ArrayPattern\", \"Identifier\", \"ObjectPattern\", \"RestElement\"),\n [\"typeAnnotation\"]: (0, _utils.validateOptionalType)(\"TSTypeAnnotation\")\n});\nconst callConstructSignatureDeclaration = {\n aliases: [\"TSTypeElement\"],\n visitor: [\"typeParameters\", \"parameters\", \"typeAnnotation\"],\n fields: signatureDeclarationCommon()\n};\ndefineType(\"TSCallSignatureDeclaration\", callConstructSignatureDeclaration);\ndefineType(\"TSConstructSignatureDeclaration\", callConstructSignatureDeclaration);\nconst namedTypeElementCommon = () => ({\n key: (0, _utils.validateType)(\"Expression\"),\n computed: {\n default: false\n },\n optional: (0, _utils.validateOptional)(bool)\n});\ndefineType(\"TSPropertySignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\"key\", \"typeAnnotation\"],\n fields: Object.assign({}, namedTypeElementCommon(), {\n readonly: (0, _utils.validateOptional)(bool),\n typeAnnotation: (0, _utils.validateOptionalType)(\"TSTypeAnnotation\"),\n kind: {\n optional: true,\n validate: (0, _utils.assertOneOf)(\"get\", \"set\")\n }\n })\n});\ndefineType(\"TSMethodSignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\"key\", \"typeParameters\", \"parameters\", \"typeAnnotation\"],\n fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {\n kind: {\n validate: (0, _utils.assertOneOf)(\"method\", \"get\", \"set\")\n }\n })\n});\ndefineType(\"TSIndexSignature\", {\n aliases: [\"TSTypeElement\"],\n visitor: [\"parameters\", \"typeAnnotation\"],\n fields: {\n readonly: (0, _utils.validateOptional)(bool),\n static: (0, _utils.validateOptional)(bool),\n parameters: (0, _utils.validateArrayOfType)(\"Identifier\"),\n typeAnnotation: (0, _utils.validateOptionalType)(\"TSTypeAnnotation\")\n }\n});\nconst tsKeywordTypes = [\"TSAnyKeyword\", \"TSBooleanKeyword\", \"TSBigIntKeyword\", \"TSIntrinsicKeyword\", \"TSNeverKeyword\", \"TSNullKeyword\", \"TSNumberKeyword\", \"TSObjectKeyword\", \"TSStringKeyword\", \"TSSymbolKeyword\", \"TSUndefinedKeyword\", \"TSUnknownKeyword\", \"TSVoidKeyword\"];\nfor (const type of tsKeywordTypes) {\n defineType(type, {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [],\n fields: {}\n });\n}\ndefineType(\"TSThisType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [],\n fields: {}\n});\nconst fnOrCtrBase = {\n aliases: [\"TSType\"],\n visitor: [\"typeParameters\", \"parameters\", \"typeAnnotation\"]\n};\ndefineType(\"TSFunctionType\", Object.assign({}, fnOrCtrBase, {\n fields: signatureDeclarationCommon()\n}));\ndefineType(\"TSConstructorType\", Object.assign({}, fnOrCtrBase, {\n fields: Object.assign({}, signatureDeclarationCommon(), {\n abstract: (0, _utils.validateOptional)(bool)\n })\n}));\ndefineType(\"TSTypeReference\", {\n aliases: [\"TSType\"],\n visitor: [\"typeName\", \"typeParameters\"],\n fields: {\n typeName: (0, _utils.validateType)(\"TSEntityName\"),\n [\"typeParameters\"]: (0, _utils.validateOptionalType)(\"TSTypeParameterInstantiation\")\n }\n});\ndefineType(\"TSTypePredicate\", {\n aliases: [\"TSType\"],\n visitor: [\"parameterName\", \"typeAnnotation\"],\n builder: [\"parameterName\", \"typeAnnotation\", \"asserts\"],\n fields: {\n parameterName: (0, _utils.validateType)(\"Identifier\", \"TSThisType\"),\n typeAnnotation: (0, _utils.validateOptionalType)(\"TSTypeAnnotation\"),\n asserts: (0, _utils.validateOptional)(bool)\n }\n});\ndefineType(\"TSTypeQuery\", {\n aliases: [\"TSType\"],\n visitor: [\"exprName\", \"typeParameters\"],\n fields: {\n exprName: (0, _utils.validateType)(\"TSEntityName\", \"TSImportType\"),\n [\"typeParameters\"]: (0, _utils.validateOptionalType)(\"TSTypeParameterInstantiation\")\n }\n});\ndefineType(\"TSTypeLiteral\", {\n aliases: [\"TSType\"],\n visitor: [\"members\"],\n fields: {\n members: (0, _utils.validateArrayOfType)(\"TSTypeElement\")\n }\n});\ndefineType(\"TSArrayType\", {\n aliases: [\"TSType\"],\n visitor: [\"elementType\"],\n fields: {\n elementType: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSTupleType\", {\n aliases: [\"TSType\"],\n visitor: [\"elementTypes\"],\n fields: {\n elementTypes: (0, _utils.validateArrayOfType)(\"TSType\", \"TSNamedTupleMember\")\n }\n});\ndefineType(\"TSOptionalType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSRestType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSNamedTupleMember\", {\n visitor: [\"label\", \"elementType\"],\n builder: [\"label\", \"elementType\", \"optional\"],\n fields: {\n label: (0, _utils.validateType)(\"Identifier\"),\n optional: {\n validate: bool,\n default: false\n },\n elementType: (0, _utils.validateType)(\"TSType\")\n }\n});\nconst unionOrIntersection = {\n aliases: [\"TSType\"],\n visitor: [\"types\"],\n fields: {\n types: (0, _utils.validateArrayOfType)(\"TSType\")\n }\n};\ndefineType(\"TSUnionType\", unionOrIntersection);\ndefineType(\"TSIntersectionType\", unionOrIntersection);\ndefineType(\"TSConditionalType\", {\n aliases: [\"TSType\"],\n visitor: [\"checkType\", \"extendsType\", \"trueType\", \"falseType\"],\n fields: {\n checkType: (0, _utils.validateType)(\"TSType\"),\n extendsType: (0, _utils.validateType)(\"TSType\"),\n trueType: (0, _utils.validateType)(\"TSType\"),\n falseType: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSInferType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeParameter\"],\n fields: {\n typeParameter: (0, _utils.validateType)(\"TSTypeParameter\")\n }\n});\ndefineType(\"TSParenthesizedType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSTypeOperator\", {\n aliases: [\"TSType\"],\n visitor: [\"typeAnnotation\"],\n builder: [\"typeAnnotation\", \"operator\"],\n fields: {\n operator: {\n validate: (0, _utils.assertValueType)(\"string\"),\n default: \"keyof\"\n },\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSIndexedAccessType\", {\n aliases: [\"TSType\"],\n visitor: [\"objectType\", \"indexType\"],\n fields: {\n objectType: (0, _utils.validateType)(\"TSType\"),\n indexType: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSMappedType\", {\n aliases: [\"TSType\"],\n visitor: [\"typeParameter\", \"nameType\", \"typeAnnotation\"],\n builder: [\"typeParameter\", \"typeAnnotation\", \"nameType\"],\n fields: Object.assign({}, {\n typeParameter: (0, _utils.validateType)(\"TSTypeParameter\")\n }, {\n readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, \"+\", \"-\")),\n optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, \"+\", \"-\")),\n typeAnnotation: (0, _utils.validateOptionalType)(\"TSType\"),\n nameType: (0, _utils.validateOptionalType)(\"TSType\")\n })\n});\ndefineType(\"TSTemplateLiteralType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [\"quasis\", \"types\"],\n fields: {\n quasis: (0, _utils.validateArrayOfType)(\"TemplateElement\"),\n types: {\n validate: (0, _utils.chain)((0, _utils.assertValueType)(\"array\"), (0, _utils.assertEach)((0, _utils.assertNodeType)(\"TSType\")), function (node, key, val) {\n if (node.quasis.length !== val.length + 1) {\n throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of types.\\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);\n }\n })\n }\n }\n});\ndefineType(\"TSLiteralType\", {\n aliases: [\"TSType\", \"TSBaseType\"],\n visitor: [\"literal\"],\n fields: {\n literal: {\n validate: function () {\n const unaryExpression = (0, _utils.assertNodeType)(\"NumericLiteral\", \"BigIntLiteral\");\n const unaryOperator = (0, _utils.assertOneOf)(\"-\");\n const literal = (0, _utils.assertNodeType)(\"NumericLiteral\", \"StringLiteral\", \"BooleanLiteral\", \"BigIntLiteral\", \"TemplateLiteral\");\n const validator = function validator(parent, key, node) {\n if ((0, _is.default)(\"UnaryExpression\", node)) {\n unaryOperator(node, \"operator\", node.operator);\n unaryExpression(node, \"argument\", node.argument);\n } else {\n literal(parent, key, node);\n }\n };\n validator.oneOfNodeTypes = [\"NumericLiteral\", \"StringLiteral\", \"BooleanLiteral\", \"BigIntLiteral\", \"TemplateLiteral\", \"UnaryExpression\"];\n return validator;\n }()\n }\n }\n});\ndefineType(\"TSExpressionWithTypeArguments\", {\n aliases: [\"TSType\"],\n visitor: [\"expression\", \"typeParameters\"],\n fields: {\n expression: (0, _utils.validateType)(\"TSEntityName\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TSTypeParameterInstantiation\")\n }\n});\ndefineType(\"TSInterfaceDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"extends\", \"body\"],\n fields: {\n declare: (0, _utils.validateOptional)(bool),\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TSTypeParameterDeclaration\"),\n extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)(\"TSExpressionWithTypeArguments\")),\n body: (0, _utils.validateType)(\"TSInterfaceBody\")\n }\n});\ndefineType(\"TSInterfaceBody\", {\n visitor: [\"body\"],\n fields: {\n body: (0, _utils.validateArrayOfType)(\"TSTypeElement\")\n }\n});\ndefineType(\"TSTypeAliasDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"typeParameters\", \"typeAnnotation\"],\n fields: {\n declare: (0, _utils.validateOptional)(bool),\n id: (0, _utils.validateType)(\"Identifier\"),\n typeParameters: (0, _utils.validateOptionalType)(\"TSTypeParameterDeclaration\"),\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n});\ndefineType(\"TSInstantiationExpression\", {\n aliases: [\"Expression\"],\n visitor: [\"expression\", \"typeParameters\"],\n fields: {\n expression: (0, _utils.validateType)(\"Expression\"),\n [\"typeParameters\"]: (0, _utils.validateOptionalType)(\"TSTypeParameterInstantiation\")\n }\n});\nconst TSTypeExpression = {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"expression\", \"typeAnnotation\"],\n fields: {\n expression: (0, _utils.validateType)(\"Expression\"),\n typeAnnotation: (0, _utils.validateType)(\"TSType\")\n }\n};\ndefineType(\"TSAsExpression\", TSTypeExpression);\ndefineType(\"TSSatisfiesExpression\", TSTypeExpression);\ndefineType(\"TSTypeAssertion\", {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"typeAnnotation\", \"expression\"],\n fields: {\n typeAnnotation: (0, _utils.validateType)(\"TSType\"),\n expression: (0, _utils.validateType)(\"Expression\")\n }\n});\ndefineType(\"TSEnumBody\", {\n visitor: [\"members\"],\n fields: {\n members: (0, _utils.validateArrayOfType)(\"TSEnumMember\")\n }\n});\ndefineType(\"TSEnumDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"members\"],\n fields: {\n declare: (0, _utils.validateOptional)(bool),\n const: (0, _utils.validateOptional)(bool),\n id: (0, _utils.validateType)(\"Identifier\"),\n members: (0, _utils.validateArrayOfType)(\"TSEnumMember\"),\n initializer: (0, _utils.validateOptionalType)(\"Expression\"),\n body: (0, _utils.validateOptionalType)(\"TSEnumBody\")\n }\n});\ndefineType(\"TSEnumMember\", {\n visitor: [\"id\", \"initializer\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\", \"StringLiteral\"),\n initializer: (0, _utils.validateOptionalType)(\"Expression\")\n }\n});\ndefineType(\"TSModuleDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"body\"],\n fields: Object.assign({\n kind: {\n validate: (0, _utils.assertOneOf)(\"global\", \"module\", \"namespace\")\n },\n declare: (0, _utils.validateOptional)(bool)\n }, {\n global: (0, _utils.validateOptional)(bool)\n }, {\n id: (0, _utils.validateType)(\"Identifier\", \"StringLiteral\"),\n body: (0, _utils.validateType)(\"TSModuleBlock\", \"TSModuleDeclaration\")\n })\n});\ndefineType(\"TSModuleBlock\", {\n aliases: [\"Scopable\", \"Block\", \"BlockParent\", \"FunctionParent\"],\n visitor: [\"body\"],\n fields: {\n body: (0, _utils.validateArrayOfType)(\"Statement\")\n }\n});\ndefineType(\"TSImportType\", {\n aliases: [\"TSType\"],\n builder: [\"argument\", \"qualifier\", \"typeParameters\"],\n visitor: [\"argument\", \"options\", \"qualifier\", \"typeParameters\"],\n fields: Object.assign({}, {\n argument: (0, _utils.validateType)(\"StringLiteral\")\n }, {\n qualifier: (0, _utils.validateOptionalType)(\"TSEntityName\")\n }, {\n typeParameters: (0, _utils.validateOptionalType)(\"TSTypeParameterInstantiation\")\n }, {\n options: {\n validate: (0, _utils.assertNodeType)(\"ObjectExpression\"),\n optional: true\n }\n })\n});\ndefineType(\"TSImportEqualsDeclaration\", {\n aliases: [\"Statement\", \"Declaration\"],\n visitor: [\"id\", \"moduleReference\"],\n fields: Object.assign({}, {\n isExport: (0, _utils.validate)(bool)\n }, {\n id: (0, _utils.validateType)(\"Identifier\"),\n moduleReference: (0, _utils.validateType)(\"TSEntityName\", \"TSExternalModuleReference\"),\n importKind: {\n validate: (0, _utils.assertOneOf)(\"type\", \"value\"),\n optional: true\n }\n })\n});\ndefineType(\"TSExternalModuleReference\", {\n visitor: [\"expression\"],\n fields: {\n expression: (0, _utils.validateType)(\"StringLiteral\")\n }\n});\ndefineType(\"TSNonNullExpression\", {\n aliases: [\"Expression\", \"LVal\", \"PatternLike\"],\n visitor: [\"expression\"],\n fields: {\n expression: (0, _utils.validateType)(\"Expression\")\n }\n});\ndefineType(\"TSExportAssignment\", {\n aliases: [\"Statement\"],\n visitor: [\"expression\"],\n fields: {\n expression: (0, _utils.validateType)(\"Expression\")\n }\n});\ndefineType(\"TSNamespaceExportDeclaration\", {\n aliases: [\"Statement\"],\n visitor: [\"id\"],\n fields: {\n id: (0, _utils.validateType)(\"Identifier\")\n }\n});\ndefineType(\"TSTypeAnnotation\", {\n visitor: [\"typeAnnotation\"],\n fields: {\n typeAnnotation: {\n validate: (0, _utils.assertNodeType)(\"TSType\")\n }\n }\n});\ndefineType(\"TSTypeParameterInstantiation\", {\n visitor: [\"params\"],\n fields: {\n params: (0, _utils.validateArrayOfType)(\"TSType\")\n }\n});\ndefineType(\"TSTypeParameterDeclaration\", {\n visitor: [\"params\"],\n fields: {\n params: (0, _utils.validateArrayOfType)(\"TSTypeParameter\")\n }\n});\ndefineType(\"TSTypeParameter\", {\n builder: [\"constraint\", \"default\", \"name\"],\n visitor: [\"constraint\", \"default\"],\n fields: {\n name: {\n validate: (0, _utils.assertValueType)(\"string\")\n },\n in: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n out: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n const: {\n validate: (0, _utils.assertValueType)(\"boolean\"),\n optional: true\n },\n constraint: {\n validate: (0, _utils.assertNodeType)(\"TSType\"),\n optional: true\n },\n default: {\n validate: (0, _utils.assertNodeType)(\"TSType\"),\n optional: true\n }\n }\n});\n\n//# sourceMappingURL=typescript.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.DEPRECATED_ALIASES = void 0;\nconst DEPRECATED_ALIASES = exports.DEPRECATED_ALIASES = {\n ModuleDeclaration: \"ImportOrExportDeclaration\"\n};\n\n//# sourceMappingURL=deprecated-aliases.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.JSXIdentifier = exports.JSXFragment = exports.JSXExpressionContainer = exports.JSXEmptyExpression = exports.JSXElement = exports.JSXClosingFragment = exports.JSXClosingElement = exports.JSXAttribute = exports.IntersectionTypeAnnotation = exports.InterpreterDirective = exports.InterfaceTypeAnnotation = exports.InterfaceExtends = exports.InterfaceDeclaration = exports.InferredPredicate = exports.IndexedAccessType = exports.ImportSpecifier = exports.ImportNamespaceSpecifier = exports.ImportExpression = exports.ImportDefaultSpecifier = exports.ImportDeclaration = exports.ImportAttribute = exports.Import = exports.IfStatement = exports.Identifier = exports.GenericTypeAnnotation = exports.FunctionTypeParam = exports.FunctionTypeAnnotation = exports.FunctionExpression = exports.FunctionDeclaration = exports.ForStatement = exports.ForOfStatement = exports.ForInStatement = exports.File = exports.ExpressionStatement = exports.ExportSpecifier = exports.ExportNamespaceSpecifier = exports.ExportNamedDeclaration = exports.ExportDefaultSpecifier = exports.ExportDefaultDeclaration = exports.ExportAllDeclaration = exports.ExistsTypeAnnotation = exports.EnumSymbolBody = exports.EnumStringMember = exports.EnumStringBody = exports.EnumNumberMember = exports.EnumNumberBody = exports.EnumDefaultedMember = exports.EnumDeclaration = exports.EnumBooleanMember = exports.EnumBooleanBody = exports.EmptyTypeAnnotation = exports.EmptyStatement = exports.DoWhileStatement = exports.DoExpression = exports.DirectiveLiteral = exports.Directive = exports.Decorator = exports.DeclaredPredicate = exports.DeclareVariable = exports.DeclareTypeAlias = exports.DeclareOpaqueType = exports.DeclareModuleExports = exports.DeclareModule = exports.DeclareInterface = exports.DeclareFunction = exports.DeclareExportDeclaration = exports.DeclareExportAllDeclaration = exports.DeclareClass = exports.DecimalLiteral = exports.DebuggerStatement = exports.ContinueStatement = exports.ConditionalExpression = exports.ClassProperty = exports.ClassPrivateProperty = exports.ClassPrivateMethod = exports.ClassMethod = exports.ClassImplements = exports.ClassExpression = exports.ClassDeclaration = exports.ClassBody = exports.ClassAccessorProperty = exports.CatchClause = exports.CallExpression = exports.BreakStatement = exports.BooleanTypeAnnotation = exports.BooleanLiteralTypeAnnotation = exports.BooleanLiteral = exports.BlockStatement = exports.BindExpression = exports.BinaryExpression = exports.BigIntLiteral = exports.AwaitExpression = exports.AssignmentPattern = exports.AssignmentExpression = exports.ArrowFunctionExpression = exports.ArrayTypeAnnotation = exports.ArrayPattern = exports.ArrayExpression = exports.ArgumentPlaceholder = exports.AnyTypeAnnotation = void 0;\nexports.TSNumberKeyword = exports.TSNullKeyword = exports.TSNonNullExpression = exports.TSNeverKeyword = exports.TSNamespaceExportDeclaration = exports.TSNamedTupleMember = exports.TSModuleDeclaration = exports.TSModuleBlock = exports.TSMethodSignature = exports.TSMappedType = exports.TSLiteralType = exports.TSIntrinsicKeyword = exports.TSIntersectionType = exports.TSInterfaceDeclaration = exports.TSInterfaceBody = exports.TSInstantiationExpression = exports.TSInferType = exports.TSIndexedAccessType = exports.TSIndexSignature = exports.TSImportType = exports.TSImportEqualsDeclaration = exports.TSFunctionType = exports.TSExternalModuleReference = exports.TSExpressionWithTypeArguments = exports.TSExportAssignment = exports.TSEnumMember = exports.TSEnumDeclaration = exports.TSEnumBody = exports.TSDeclareMethod = exports.TSDeclareFunction = exports.TSConstructorType = exports.TSConstructSignatureDeclaration = exports.TSConditionalType = exports.TSCallSignatureDeclaration = exports.TSBooleanKeyword = exports.TSBigIntKeyword = exports.TSAsExpression = exports.TSArrayType = exports.TSAnyKeyword = exports.SymbolTypeAnnotation = exports.SwitchStatement = exports.SwitchCase = exports.Super = exports.StringTypeAnnotation = exports.StringLiteralTypeAnnotation = exports.StringLiteral = exports.StaticBlock = exports.SpreadProperty = exports.SpreadElement = exports.SequenceExpression = exports.ReturnStatement = exports.RestProperty = exports.RestElement = exports.RegexLiteral = exports.RegExpLiteral = exports.RecordExpression = exports.QualifiedTypeIdentifier = exports.Program = exports.PrivateName = exports.Placeholder = exports.PipelineTopicExpression = exports.PipelinePrimaryTopicReference = exports.PipelineBareFunction = exports.ParenthesizedExpression = exports.OptionalMemberExpression = exports.OptionalIndexedAccessType = exports.OptionalCallExpression = exports.OpaqueType = exports.ObjectTypeSpreadProperty = exports.ObjectTypeProperty = exports.ObjectTypeInternalSlot = exports.ObjectTypeIndexer = exports.ObjectTypeCallProperty = exports.ObjectTypeAnnotation = exports.ObjectProperty = exports.ObjectPattern = exports.ObjectMethod = exports.ObjectExpression = exports.NumericLiteral = exports.NumberTypeAnnotation = exports.NumberLiteralTypeAnnotation = exports.NumberLiteral = exports.NullableTypeAnnotation = exports.NullLiteralTypeAnnotation = exports.NullLiteral = exports.Noop = exports.NewExpression = exports.ModuleExpression = exports.MixedTypeAnnotation = exports.MetaProperty = exports.MemberExpression = exports.LogicalExpression = exports.LabeledStatement = exports.JSXText = exports.JSXSpreadChild = exports.JSXSpreadAttribute = exports.JSXOpeningFragment = exports.JSXOpeningElement = exports.JSXNamespacedName = exports.JSXMemberExpression = void 0;\nexports.YieldExpression = exports.WithStatement = exports.WhileStatement = exports.VoidTypeAnnotation = exports.VoidPattern = exports.Variance = exports.VariableDeclarator = exports.VariableDeclaration = exports.V8IntrinsicIdentifier = exports.UpdateExpression = exports.UnionTypeAnnotation = exports.UnaryExpression = exports.TypeofTypeAnnotation = exports.TypeParameterInstantiation = exports.TypeParameterDeclaration = exports.TypeParameter = exports.TypeCastExpression = exports.TypeAnnotation = exports.TypeAlias = exports.TupleTypeAnnotation = exports.TupleExpression = exports.TryStatement = exports.TopicReference = exports.ThrowStatement = exports.ThisTypeAnnotation = exports.ThisExpression = exports.TemplateLiteral = exports.TemplateElement = exports.TaggedTemplateExpression = exports.TSVoidKeyword = exports.TSUnknownKeyword = exports.TSUnionType = exports.TSUndefinedKeyword = exports.TSTypeReference = exports.TSTypeQuery = exports.TSTypePredicate = exports.TSTypeParameterInstantiation = exports.TSTypeParameterDeclaration = exports.TSTypeParameter = exports.TSTypeOperator = exports.TSTypeLiteral = exports.TSTypeAssertion = exports.TSTypeAnnotation = exports.TSTypeAliasDeclaration = exports.TSTupleType = exports.TSThisType = exports.TSTemplateLiteralType = exports.TSSymbolKeyword = exports.TSStringKeyword = exports.TSSatisfiesExpression = exports.TSRestType = exports.TSQualifiedName = exports.TSPropertySignature = exports.TSParenthesizedType = exports.TSParameterProperty = exports.TSOptionalType = exports.TSObjectKeyword = void 0;\nvar b = require(\"./lowercase.js\");\nvar _deprecationWarning = require(\"../../utils/deprecationWarning.js\");\nfunction alias(lowercase) {\n return b[lowercase];\n}\nconst ArrayExpression = exports.ArrayExpression = alias(\"arrayExpression\"),\n AssignmentExpression = exports.AssignmentExpression = alias(\"assignmentExpression\"),\n BinaryExpression = exports.BinaryExpression = alias(\"binaryExpression\"),\n InterpreterDirective = exports.InterpreterDirective = alias(\"interpreterDirective\"),\n Directive = exports.Directive = alias(\"directive\"),\n DirectiveLiteral = exports.DirectiveLiteral = alias(\"directiveLiteral\"),\n BlockStatement = exports.BlockStatement = alias(\"blockStatement\"),\n BreakStatement = exports.BreakStatement = alias(\"breakStatement\"),\n CallExpression = exports.CallExpression = alias(\"callExpression\"),\n CatchClause = exports.CatchClause = alias(\"catchClause\"),\n ConditionalExpression = exports.ConditionalExpression = alias(\"conditionalExpression\"),\n ContinueStatement = exports.ContinueStatement = alias(\"continueStatement\"),\n DebuggerStatement = exports.DebuggerStatement = alias(\"debuggerStatement\"),\n DoWhileStatement = exports.DoWhileStatement = alias(\"doWhileStatement\"),\n EmptyStatement = exports.EmptyStatement = alias(\"emptyStatement\"),\n ExpressionStatement = exports.ExpressionStatement = alias(\"expressionStatement\"),\n File = exports.File = alias(\"file\"),\n ForInStatement = exports.ForInStatement = alias(\"forInStatement\"),\n ForStatement = exports.ForStatement = alias(\"forStatement\"),\n FunctionDeclaration = exports.FunctionDeclaration = alias(\"functionDeclaration\"),\n FunctionExpression = exports.FunctionExpression = alias(\"functionExpression\"),\n Identifier = exports.Identifier = alias(\"identifier\"),\n IfStatement = exports.IfStatement = alias(\"ifStatement\"),\n LabeledStatement = exports.LabeledStatement = alias(\"labeledStatement\"),\n StringLiteral = exports.StringLiteral = alias(\"stringLiteral\"),\n NumericLiteral = exports.NumericLiteral = alias(\"numericLiteral\"),\n NullLiteral = exports.NullLiteral = alias(\"nullLiteral\"),\n BooleanLiteral = exports.BooleanLiteral = alias(\"booleanLiteral\"),\n RegExpLiteral = exports.RegExpLiteral = alias(\"regExpLiteral\"),\n LogicalExpression = exports.LogicalExpression = alias(\"logicalExpression\"),\n MemberExpression = exports.MemberExpression = alias(\"memberExpression\"),\n NewExpression = exports.NewExpression = alias(\"newExpression\"),\n Program = exports.Program = alias(\"program\"),\n ObjectExpression = exports.ObjectExpression = alias(\"objectExpression\"),\n ObjectMethod = exports.ObjectMethod = alias(\"objectMethod\"),\n ObjectProperty = exports.ObjectProperty = alias(\"objectProperty\"),\n RestElement = exports.RestElement = alias(\"restElement\"),\n ReturnStatement = exports.ReturnStatement = alias(\"returnStatement\"),\n SequenceExpression = exports.SequenceExpression = alias(\"sequenceExpression\"),\n ParenthesizedExpression = exports.ParenthesizedExpression = alias(\"parenthesizedExpression\"),\n SwitchCase = exports.SwitchCase = alias(\"switchCase\"),\n SwitchStatement = exports.SwitchStatement = alias(\"switchStatement\"),\n ThisExpression = exports.ThisExpression = alias(\"thisExpression\"),\n ThrowStatement = exports.ThrowStatement = alias(\"throwStatement\"),\n TryStatement = exports.TryStatement = alias(\"tryStatement\"),\n UnaryExpression = exports.UnaryExpression = alias(\"unaryExpression\"),\n UpdateExpression = exports.UpdateExpression = alias(\"updateExpression\"),\n VariableDeclaration = exports.VariableDeclaration = alias(\"variableDeclaration\"),\n VariableDeclarator = exports.VariableDeclarator = alias(\"variableDeclarator\"),\n WhileStatement = exports.WhileStatement = alias(\"whileStatement\"),\n WithStatement = exports.WithStatement = alias(\"withStatement\"),\n AssignmentPattern = exports.AssignmentPattern = alias(\"assignmentPattern\"),\n ArrayPattern = exports.ArrayPattern = alias(\"arrayPattern\"),\n ArrowFunctionExpression = exports.ArrowFunctionExpression = alias(\"arrowFunctionExpression\"),\n ClassBody = exports.ClassBody = alias(\"classBody\"),\n ClassExpression = exports.ClassExpression = alias(\"classExpression\"),\n ClassDeclaration = exports.ClassDeclaration = alias(\"classDeclaration\"),\n ExportAllDeclaration = exports.ExportAllDeclaration = alias(\"exportAllDeclaration\"),\n ExportDefaultDeclaration = exports.ExportDefaultDeclaration = alias(\"exportDefaultDeclaration\"),\n ExportNamedDeclaration = exports.ExportNamedDeclaration = alias(\"exportNamedDeclaration\"),\n ExportSpecifier = exports.ExportSpecifier = alias(\"exportSpecifier\"),\n ForOfStatement = exports.ForOfStatement = alias(\"forOfStatement\"),\n ImportDeclaration = exports.ImportDeclaration = alias(\"importDeclaration\"),\n ImportDefaultSpecifier = exports.ImportDefaultSpecifier = alias(\"importDefaultSpecifier\"),\n ImportNamespaceSpecifier = exports.ImportNamespaceSpecifier = alias(\"importNamespaceSpecifier\"),\n ImportSpecifier = exports.ImportSpecifier = alias(\"importSpecifier\"),\n ImportExpression = exports.ImportExpression = alias(\"importExpression\"),\n MetaProperty = exports.MetaProperty = alias(\"metaProperty\"),\n ClassMethod = exports.ClassMethod = alias(\"classMethod\"),\n ObjectPattern = exports.ObjectPattern = alias(\"objectPattern\"),\n SpreadElement = exports.SpreadElement = alias(\"spreadElement\"),\n Super = exports.Super = alias(\"super\"),\n TaggedTemplateExpression = exports.TaggedTemplateExpression = alias(\"taggedTemplateExpression\"),\n TemplateElement = exports.TemplateElement = alias(\"templateElement\"),\n TemplateLiteral = exports.TemplateLiteral = alias(\"templateLiteral\"),\n YieldExpression = exports.YieldExpression = alias(\"yieldExpression\"),\n AwaitExpression = exports.AwaitExpression = alias(\"awaitExpression\"),\n Import = exports.Import = alias(\"import\"),\n BigIntLiteral = exports.BigIntLiteral = alias(\"bigIntLiteral\"),\n ExportNamespaceSpecifier = exports.ExportNamespaceSpecifier = alias(\"exportNamespaceSpecifier\"),\n OptionalMemberExpression = exports.OptionalMemberExpression = alias(\"optionalMemberExpression\"),\n OptionalCallExpression = exports.OptionalCallExpression = alias(\"optionalCallExpression\"),\n ClassProperty = exports.ClassProperty = alias(\"classProperty\"),\n ClassAccessorProperty = exports.ClassAccessorProperty = alias(\"classAccessorProperty\"),\n ClassPrivateProperty = exports.ClassPrivateProperty = alias(\"classPrivateProperty\"),\n ClassPrivateMethod = exports.ClassPrivateMethod = alias(\"classPrivateMethod\"),\n PrivateName = exports.PrivateName = alias(\"privateName\"),\n StaticBlock = exports.StaticBlock = alias(\"staticBlock\"),\n ImportAttribute = exports.ImportAttribute = alias(\"importAttribute\"),\n AnyTypeAnnotation = exports.AnyTypeAnnotation = alias(\"anyTypeAnnotation\"),\n ArrayTypeAnnotation = exports.ArrayTypeAnnotation = alias(\"arrayTypeAnnotation\"),\n BooleanTypeAnnotation = exports.BooleanTypeAnnotation = alias(\"booleanTypeAnnotation\"),\n BooleanLiteralTypeAnnotation = exports.BooleanLiteralTypeAnnotation = alias(\"booleanLiteralTypeAnnotation\"),\n NullLiteralTypeAnnotation = exports.NullLiteralTypeAnnotation = alias(\"nullLiteralTypeAnnotation\"),\n ClassImplements = exports.ClassImplements = alias(\"classImplements\"),\n DeclareClass = exports.DeclareClass = alias(\"declareClass\"),\n DeclareFunction = exports.DeclareFunction = alias(\"declareFunction\"),\n DeclareInterface = exports.DeclareInterface = alias(\"declareInterface\"),\n DeclareModule = exports.DeclareModule = alias(\"declareModule\"),\n DeclareModuleExports = exports.DeclareModuleExports = alias(\"declareModuleExports\"),\n DeclareTypeAlias = exports.DeclareTypeAlias = alias(\"declareTypeAlias\"),\n DeclareOpaqueType = exports.DeclareOpaqueType = alias(\"declareOpaqueType\"),\n DeclareVariable = exports.DeclareVariable = alias(\"declareVariable\"),\n DeclareExportDeclaration = exports.DeclareExportDeclaration = alias(\"declareExportDeclaration\"),\n DeclareExportAllDeclaration = exports.DeclareExportAllDeclaration = alias(\"declareExportAllDeclaration\"),\n DeclaredPredicate = exports.DeclaredPredicate = alias(\"declaredPredicate\"),\n ExistsTypeAnnotation = exports.ExistsTypeAnnotation = alias(\"existsTypeAnnotation\"),\n FunctionTypeAnnotation = exports.FunctionTypeAnnotation = alias(\"functionTypeAnnotation\"),\n FunctionTypeParam = exports.FunctionTypeParam = alias(\"functionTypeParam\"),\n GenericTypeAnnotation = exports.GenericTypeAnnotation = alias(\"genericTypeAnnotation\"),\n InferredPredicate = exports.InferredPredicate = alias(\"inferredPredicate\"),\n InterfaceExtends = exports.InterfaceExtends = alias(\"interfaceExtends\"),\n InterfaceDeclaration = exports.InterfaceDeclaration = alias(\"interfaceDeclaration\"),\n InterfaceTypeAnnotation = exports.InterfaceTypeAnnotation = alias(\"interfaceTypeAnnotation\"),\n IntersectionTypeAnnotation = exports.IntersectionTypeAnnotation = alias(\"intersectionTypeAnnotation\"),\n MixedTypeAnnotation = exports.MixedTypeAnnotation = alias(\"mixedTypeAnnotation\"),\n EmptyTypeAnnotation = exports.EmptyTypeAnnotation = alias(\"emptyTypeAnnotation\"),\n NullableTypeAnnotation = exports.NullableTypeAnnotation = alias(\"nullableTypeAnnotation\"),\n NumberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = alias(\"numberLiteralTypeAnnotation\"),\n NumberTypeAnnotation = exports.NumberTypeAnnotation = alias(\"numberTypeAnnotation\"),\n ObjectTypeAnnotation = exports.ObjectTypeAnnotation = alias(\"objectTypeAnnotation\"),\n ObjectTypeInternalSlot = exports.ObjectTypeInternalSlot = alias(\"objectTypeInternalSlot\"),\n ObjectTypeCallProperty = exports.ObjectTypeCallProperty = alias(\"objectTypeCallProperty\"),\n ObjectTypeIndexer = exports.ObjectTypeIndexer = alias(\"objectTypeIndexer\"),\n ObjectTypeProperty = exports.ObjectTypeProperty = alias(\"objectTypeProperty\"),\n ObjectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = alias(\"objectTypeSpreadProperty\"),\n OpaqueType = exports.OpaqueType = alias(\"opaqueType\"),\n QualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = alias(\"qualifiedTypeIdentifier\"),\n StringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = alias(\"stringLiteralTypeAnnotation\"),\n StringTypeAnnotation = exports.StringTypeAnnotation = alias(\"stringTypeAnnotation\"),\n SymbolTypeAnnotation = exports.SymbolTypeAnnotation = alias(\"symbolTypeAnnotation\"),\n ThisTypeAnnotation = exports.ThisTypeAnnotation = alias(\"thisTypeAnnotation\"),\n TupleTypeAnnotation = exports.TupleTypeAnnotation = alias(\"tupleTypeAnnotation\"),\n TypeofTypeAnnotation = exports.TypeofTypeAnnotation = alias(\"typeofTypeAnnotation\"),\n TypeAlias = exports.TypeAlias = alias(\"typeAlias\"),\n TypeAnnotation = exports.TypeAnnotation = alias(\"typeAnnotation\"),\n TypeCastExpression = exports.TypeCastExpression = alias(\"typeCastExpression\"),\n TypeParameter = exports.TypeParameter = alias(\"typeParameter\"),\n TypeParameterDeclaration = exports.TypeParameterDeclaration = alias(\"typeParameterDeclaration\"),\n TypeParameterInstantiation = exports.TypeParameterInstantiation = alias(\"typeParameterInstantiation\"),\n UnionTypeAnnotation = exports.UnionTypeAnnotation = alias(\"unionTypeAnnotation\"),\n Variance = exports.Variance = alias(\"variance\"),\n VoidTypeAnnotation = exports.VoidTypeAnnotation = alias(\"voidTypeAnnotation\"),\n EnumDeclaration = exports.EnumDeclaration = alias(\"enumDeclaration\"),\n EnumBooleanBody = exports.EnumBooleanBody = alias(\"enumBooleanBody\"),\n EnumNumberBody = exports.EnumNumberBody = alias(\"enumNumberBody\"),\n EnumStringBody = exports.EnumStringBody = alias(\"enumStringBody\"),\n EnumSymbolBody = exports.EnumSymbolBody = alias(\"enumSymbolBody\"),\n EnumBooleanMember = exports.EnumBooleanMember = alias(\"enumBooleanMember\"),\n EnumNumberMember = exports.EnumNumberMember = alias(\"enumNumberMember\"),\n EnumStringMember = exports.EnumStringMember = alias(\"enumStringMember\"),\n EnumDefaultedMember = exports.EnumDefaultedMember = alias(\"enumDefaultedMember\"),\n IndexedAccessType = exports.IndexedAccessType = alias(\"indexedAccessType\"),\n OptionalIndexedAccessType = exports.OptionalIndexedAccessType = alias(\"optionalIndexedAccessType\"),\n JSXAttribute = exports.JSXAttribute = alias(\"jsxAttribute\"),\n JSXClosingElement = exports.JSXClosingElement = alias(\"jsxClosingElement\"),\n JSXElement = exports.JSXElement = alias(\"jsxElement\"),\n JSXEmptyExpression = exports.JSXEmptyExpression = alias(\"jsxEmptyExpression\"),\n JSXExpressionContainer = exports.JSXExpressionContainer = alias(\"jsxExpressionContainer\"),\n JSXSpreadChild = exports.JSXSpreadChild = alias(\"jsxSpreadChild\"),\n JSXIdentifier = exports.JSXIdentifier = alias(\"jsxIdentifier\"),\n JSXMemberExpression = exports.JSXMemberExpression = alias(\"jsxMemberExpression\"),\n JSXNamespacedName = exports.JSXNamespacedName = alias(\"jsxNamespacedName\"),\n JSXOpeningElement = exports.JSXOpeningElement = alias(\"jsxOpeningElement\"),\n JSXSpreadAttribute = exports.JSXSpreadAttribute = alias(\"jsxSpreadAttribute\"),\n JSXText = exports.JSXText = alias(\"jsxText\"),\n JSXFragment = exports.JSXFragment = alias(\"jsxFragment\"),\n JSXOpeningFragment = exports.JSXOpeningFragment = alias(\"jsxOpeningFragment\"),\n JSXClosingFragment = exports.JSXClosingFragment = alias(\"jsxClosingFragment\"),\n Noop = exports.Noop = alias(\"noop\"),\n Placeholder = exports.Placeholder = alias(\"placeholder\"),\n V8IntrinsicIdentifier = exports.V8IntrinsicIdentifier = alias(\"v8IntrinsicIdentifier\"),\n ArgumentPlaceholder = exports.ArgumentPlaceholder = alias(\"argumentPlaceholder\"),\n BindExpression = exports.BindExpression = alias(\"bindExpression\"),\n Decorator = exports.Decorator = alias(\"decorator\"),\n DoExpression = exports.DoExpression = alias(\"doExpression\"),\n ExportDefaultSpecifier = exports.ExportDefaultSpecifier = alias(\"exportDefaultSpecifier\"),\n RecordExpression = exports.RecordExpression = alias(\"recordExpression\"),\n TupleExpression = exports.TupleExpression = alias(\"tupleExpression\"),\n DecimalLiteral = exports.DecimalLiteral = alias(\"decimalLiteral\"),\n ModuleExpression = exports.ModuleExpression = alias(\"moduleExpression\"),\n TopicReference = exports.TopicReference = alias(\"topicReference\"),\n PipelineTopicExpression = exports.PipelineTopicExpression = alias(\"pipelineTopicExpression\"),\n PipelineBareFunction = exports.PipelineBareFunction = alias(\"pipelineBareFunction\"),\n PipelinePrimaryTopicReference = exports.PipelinePrimaryTopicReference = alias(\"pipelinePrimaryTopicReference\"),\n VoidPattern = exports.VoidPattern = alias(\"voidPattern\"),\n TSParameterProperty = exports.TSParameterProperty = alias(\"tsParameterProperty\"),\n TSDeclareFunction = exports.TSDeclareFunction = alias(\"tsDeclareFunction\"),\n TSDeclareMethod = exports.TSDeclareMethod = alias(\"tsDeclareMethod\"),\n TSQualifiedName = exports.TSQualifiedName = alias(\"tsQualifiedName\"),\n TSCallSignatureDeclaration = exports.TSCallSignatureDeclaration = alias(\"tsCallSignatureDeclaration\"),\n TSConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = alias(\"tsConstructSignatureDeclaration\"),\n TSPropertySignature = exports.TSPropertySignature = alias(\"tsPropertySignature\"),\n TSMethodSignature = exports.TSMethodSignature = alias(\"tsMethodSignature\"),\n TSIndexSignature = exports.TSIndexSignature = alias(\"tsIndexSignature\"),\n TSAnyKeyword = exports.TSAnyKeyword = alias(\"tsAnyKeyword\"),\n TSBooleanKeyword = exports.TSBooleanKeyword = alias(\"tsBooleanKeyword\"),\n TSBigIntKeyword = exports.TSBigIntKeyword = alias(\"tsBigIntKeyword\"),\n TSIntrinsicKeyword = exports.TSIntrinsicKeyword = alias(\"tsIntrinsicKeyword\"),\n TSNeverKeyword = exports.TSNeverKeyword = alias(\"tsNeverKeyword\"),\n TSNullKeyword = exports.TSNullKeyword = alias(\"tsNullKeyword\"),\n TSNumberKeyword = exports.TSNumberKeyword = alias(\"tsNumberKeyword\"),\n TSObjectKeyword = exports.TSObjectKeyword = alias(\"tsObjectKeyword\"),\n TSStringKeyword = exports.TSStringKeyword = alias(\"tsStringKeyword\"),\n TSSymbolKeyword = exports.TSSymbolKeyword = alias(\"tsSymbolKeyword\"),\n TSUndefinedKeyword = exports.TSUndefinedKeyword = alias(\"tsUndefinedKeyword\"),\n TSUnknownKeyword = exports.TSUnknownKeyword = alias(\"tsUnknownKeyword\"),\n TSVoidKeyword = exports.TSVoidKeyword = alias(\"tsVoidKeyword\"),\n TSThisType = exports.TSThisType = alias(\"tsThisType\"),\n TSFunctionType = exports.TSFunctionType = alias(\"tsFunctionType\"),\n TSConstructorType = exports.TSConstructorType = alias(\"tsConstructorType\"),\n TSTypeReference = exports.TSTypeReference = alias(\"tsTypeReference\"),\n TSTypePredicate = exports.TSTypePredicate = alias(\"tsTypePredicate\"),\n TSTypeQuery = exports.TSTypeQuery = alias(\"tsTypeQuery\"),\n TSTypeLiteral = exports.TSTypeLiteral = alias(\"tsTypeLiteral\"),\n TSArrayType = exports.TSArrayType = alias(\"tsArrayType\"),\n TSTupleType = exports.TSTupleType = alias(\"tsTupleType\"),\n TSOptionalType = exports.TSOptionalType = alias(\"tsOptionalType\"),\n TSRestType = exports.TSRestType = alias(\"tsRestType\"),\n TSNamedTupleMember = exports.TSNamedTupleMember = alias(\"tsNamedTupleMember\"),\n TSUnionType = exports.TSUnionType = alias(\"tsUnionType\"),\n TSIntersectionType = exports.TSIntersectionType = alias(\"tsIntersectionType\"),\n TSConditionalType = exports.TSConditionalType = alias(\"tsConditionalType\"),\n TSInferType = exports.TSInferType = alias(\"tsInferType\"),\n TSParenthesizedType = exports.TSParenthesizedType = alias(\"tsParenthesizedType\"),\n TSTypeOperator = exports.TSTypeOperator = alias(\"tsTypeOperator\"),\n TSIndexedAccessType = exports.TSIndexedAccessType = alias(\"tsIndexedAccessType\"),\n TSMappedType = exports.TSMappedType = alias(\"tsMappedType\"),\n TSTemplateLiteralType = exports.TSTemplateLiteralType = alias(\"tsTemplateLiteralType\"),\n TSLiteralType = exports.TSLiteralType = alias(\"tsLiteralType\"),\n TSExpressionWithTypeArguments = exports.TSExpressionWithTypeArguments = alias(\"tsExpressionWithTypeArguments\"),\n TSInterfaceDeclaration = exports.TSInterfaceDeclaration = alias(\"tsInterfaceDeclaration\"),\n TSInterfaceBody = exports.TSInterfaceBody = alias(\"tsInterfaceBody\"),\n TSTypeAliasDeclaration = exports.TSTypeAliasDeclaration = alias(\"tsTypeAliasDeclaration\"),\n TSInstantiationExpression = exports.TSInstantiationExpression = alias(\"tsInstantiationExpression\"),\n TSAsExpression = exports.TSAsExpression = alias(\"tsAsExpression\"),\n TSSatisfiesExpression = exports.TSSatisfiesExpression = alias(\"tsSatisfiesExpression\"),\n TSTypeAssertion = exports.TSTypeAssertion = alias(\"tsTypeAssertion\"),\n TSEnumBody = exports.TSEnumBody = alias(\"tsEnumBody\"),\n TSEnumDeclaration = exports.TSEnumDeclaration = alias(\"tsEnumDeclaration\"),\n TSEnumMember = exports.TSEnumMember = alias(\"tsEnumMember\"),\n TSModuleDeclaration = exports.TSModuleDeclaration = alias(\"tsModuleDeclaration\"),\n TSModuleBlock = exports.TSModuleBlock = alias(\"tsModuleBlock\"),\n TSImportType = exports.TSImportType = alias(\"tsImportType\"),\n TSImportEqualsDeclaration = exports.TSImportEqualsDeclaration = alias(\"tsImportEqualsDeclaration\"),\n TSExternalModuleReference = exports.TSExternalModuleReference = alias(\"tsExternalModuleReference\"),\n TSNonNullExpression = exports.TSNonNullExpression = alias(\"tsNonNullExpression\"),\n TSExportAssignment = exports.TSExportAssignment = alias(\"tsExportAssignment\"),\n TSNamespaceExportDeclaration = exports.TSNamespaceExportDeclaration = alias(\"tsNamespaceExportDeclaration\"),\n TSTypeAnnotation = exports.TSTypeAnnotation = alias(\"tsTypeAnnotation\"),\n TSTypeParameterInstantiation = exports.TSTypeParameterInstantiation = alias(\"tsTypeParameterInstantiation\"),\n TSTypeParameterDeclaration = exports.TSTypeParameterDeclaration = alias(\"tsTypeParameterDeclaration\"),\n TSTypeParameter = exports.TSTypeParameter = alias(\"tsTypeParameter\");\nconst NumberLiteral = exports.NumberLiteral = b.numberLiteral,\n RegexLiteral = exports.RegexLiteral = b.regexLiteral,\n RestProperty = exports.RestProperty = b.restProperty,\n SpreadProperty = exports.SpreadProperty = b.spreadProperty;\n\n//# sourceMappingURL=uppercase.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = assertNode;\nvar _isNode = require(\"../validators/isNode.js\");\nfunction assertNode(node) {\n if (!(0, _isNode.default)(node)) {\n var _node$type;\n const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);\n throw new TypeError(`Not a valid node of type \"${type}\"`);\n }\n}\n\n//# sourceMappingURL=assertNode.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isNode;\nvar _index = require(\"../definitions/index.js\");\nfunction isNode(node) {\n return !!(node && _index.VISITOR_KEYS[node.type]);\n}\n\n//# sourceMappingURL=isNode.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.assertAccessor = assertAccessor;\nexports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;\nexports.assertArgumentPlaceholder = assertArgumentPlaceholder;\nexports.assertArrayExpression = assertArrayExpression;\nexports.assertArrayPattern = assertArrayPattern;\nexports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;\nexports.assertArrowFunctionExpression = assertArrowFunctionExpression;\nexports.assertAssignmentExpression = assertAssignmentExpression;\nexports.assertAssignmentPattern = assertAssignmentPattern;\nexports.assertAwaitExpression = assertAwaitExpression;\nexports.assertBigIntLiteral = assertBigIntLiteral;\nexports.assertBinary = assertBinary;\nexports.assertBinaryExpression = assertBinaryExpression;\nexports.assertBindExpression = assertBindExpression;\nexports.assertBlock = assertBlock;\nexports.assertBlockParent = assertBlockParent;\nexports.assertBlockStatement = assertBlockStatement;\nexports.assertBooleanLiteral = assertBooleanLiteral;\nexports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;\nexports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;\nexports.assertBreakStatement = assertBreakStatement;\nexports.assertCallExpression = assertCallExpression;\nexports.assertCatchClause = assertCatchClause;\nexports.assertClass = assertClass;\nexports.assertClassAccessorProperty = assertClassAccessorProperty;\nexports.assertClassBody = assertClassBody;\nexports.assertClassDeclaration = assertClassDeclaration;\nexports.assertClassExpression = assertClassExpression;\nexports.assertClassImplements = assertClassImplements;\nexports.assertClassMethod = assertClassMethod;\nexports.assertClassPrivateMethod = assertClassPrivateMethod;\nexports.assertClassPrivateProperty = assertClassPrivateProperty;\nexports.assertClassProperty = assertClassProperty;\nexports.assertCompletionStatement = assertCompletionStatement;\nexports.assertConditional = assertConditional;\nexports.assertConditionalExpression = assertConditionalExpression;\nexports.assertContinueStatement = assertContinueStatement;\nexports.assertDebuggerStatement = assertDebuggerStatement;\nexports.assertDecimalLiteral = assertDecimalLiteral;\nexports.assertDeclaration = assertDeclaration;\nexports.assertDeclareClass = assertDeclareClass;\nexports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;\nexports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;\nexports.assertDeclareFunction = assertDeclareFunction;\nexports.assertDeclareInterface = assertDeclareInterface;\nexports.assertDeclareModule = assertDeclareModule;\nexports.assertDeclareModuleExports = assertDeclareModuleExports;\nexports.assertDeclareOpaqueType = assertDeclareOpaqueType;\nexports.assertDeclareTypeAlias = assertDeclareTypeAlias;\nexports.assertDeclareVariable = assertDeclareVariable;\nexports.assertDeclaredPredicate = assertDeclaredPredicate;\nexports.assertDecorator = assertDecorator;\nexports.assertDirective = assertDirective;\nexports.assertDirectiveLiteral = assertDirectiveLiteral;\nexports.assertDoExpression = assertDoExpression;\nexports.assertDoWhileStatement = assertDoWhileStatement;\nexports.assertEmptyStatement = assertEmptyStatement;\nexports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;\nexports.assertEnumBody = assertEnumBody;\nexports.assertEnumBooleanBody = assertEnumBooleanBody;\nexports.assertEnumBooleanMember = assertEnumBooleanMember;\nexports.assertEnumDeclaration = assertEnumDeclaration;\nexports.assertEnumDefaultedMember = assertEnumDefaultedMember;\nexports.assertEnumMember = assertEnumMember;\nexports.assertEnumNumberBody = assertEnumNumberBody;\nexports.assertEnumNumberMember = assertEnumNumberMember;\nexports.assertEnumStringBody = assertEnumStringBody;\nexports.assertEnumStringMember = assertEnumStringMember;\nexports.assertEnumSymbolBody = assertEnumSymbolBody;\nexports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;\nexports.assertExportAllDeclaration = assertExportAllDeclaration;\nexports.assertExportDeclaration = assertExportDeclaration;\nexports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;\nexports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;\nexports.assertExportNamedDeclaration = assertExportNamedDeclaration;\nexports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;\nexports.assertExportSpecifier = assertExportSpecifier;\nexports.assertExpression = assertExpression;\nexports.assertExpressionStatement = assertExpressionStatement;\nexports.assertExpressionWrapper = assertExpressionWrapper;\nexports.assertFile = assertFile;\nexports.assertFlow = assertFlow;\nexports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;\nexports.assertFlowDeclaration = assertFlowDeclaration;\nexports.assertFlowPredicate = assertFlowPredicate;\nexports.assertFlowType = assertFlowType;\nexports.assertFor = assertFor;\nexports.assertForInStatement = assertForInStatement;\nexports.assertForOfStatement = assertForOfStatement;\nexports.assertForStatement = assertForStatement;\nexports.assertForXStatement = assertForXStatement;\nexports.assertFunction = assertFunction;\nexports.assertFunctionDeclaration = assertFunctionDeclaration;\nexports.assertFunctionExpression = assertFunctionExpression;\nexports.assertFunctionParameter = assertFunctionParameter;\nexports.assertFunctionParent = assertFunctionParent;\nexports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;\nexports.assertFunctionTypeParam = assertFunctionTypeParam;\nexports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;\nexports.assertIdentifier = assertIdentifier;\nexports.assertIfStatement = assertIfStatement;\nexports.assertImmutable = assertImmutable;\nexports.assertImport = assertImport;\nexports.assertImportAttribute = assertImportAttribute;\nexports.assertImportDeclaration = assertImportDeclaration;\nexports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;\nexports.assertImportExpression = assertImportExpression;\nexports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;\nexports.assertImportOrExportDeclaration = assertImportOrExportDeclaration;\nexports.assertImportSpecifier = assertImportSpecifier;\nexports.assertIndexedAccessType = assertIndexedAccessType;\nexports.assertInferredPredicate = assertInferredPredicate;\nexports.assertInterfaceDeclaration = assertInterfaceDeclaration;\nexports.assertInterfaceExtends = assertInterfaceExtends;\nexports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;\nexports.assertInterpreterDirective = assertInterpreterDirective;\nexports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;\nexports.assertJSX = assertJSX;\nexports.assertJSXAttribute = assertJSXAttribute;\nexports.assertJSXClosingElement = assertJSXClosingElement;\nexports.assertJSXClosingFragment = assertJSXClosingFragment;\nexports.assertJSXElement = assertJSXElement;\nexports.assertJSXEmptyExpression = assertJSXEmptyExpression;\nexports.assertJSXExpressionContainer = assertJSXExpressionContainer;\nexports.assertJSXFragment = assertJSXFragment;\nexports.assertJSXIdentifier = assertJSXIdentifier;\nexports.assertJSXMemberExpression = assertJSXMemberExpression;\nexports.assertJSXNamespacedName = assertJSXNamespacedName;\nexports.assertJSXOpeningElement = assertJSXOpeningElement;\nexports.assertJSXOpeningFragment = assertJSXOpeningFragment;\nexports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;\nexports.assertJSXSpreadChild = assertJSXSpreadChild;\nexports.assertJSXText = assertJSXText;\nexports.assertLVal = assertLVal;\nexports.assertLabeledStatement = assertLabeledStatement;\nexports.assertLiteral = assertLiteral;\nexports.assertLogicalExpression = assertLogicalExpression;\nexports.assertLoop = assertLoop;\nexports.assertMemberExpression = assertMemberExpression;\nexports.assertMetaProperty = assertMetaProperty;\nexports.assertMethod = assertMethod;\nexports.assertMiscellaneous = assertMiscellaneous;\nexports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;\nexports.assertModuleDeclaration = assertModuleDeclaration;\nexports.assertModuleExpression = assertModuleExpression;\nexports.assertModuleSpecifier = assertModuleSpecifier;\nexports.assertNewExpression = assertNewExpression;\nexports.assertNoop = assertNoop;\nexports.assertNullLiteral = assertNullLiteral;\nexports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;\nexports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;\nexports.assertNumberLiteral = assertNumberLiteral;\nexports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;\nexports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;\nexports.assertNumericLiteral = assertNumericLiteral;\nexports.assertObjectExpression = assertObjectExpression;\nexports.assertObjectMember = assertObjectMember;\nexports.assertObjectMethod = assertObjectMethod;\nexports.assertObjectPattern = assertObjectPattern;\nexports.assertObjectProperty = assertObjectProperty;\nexports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;\nexports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;\nexports.assertObjectTypeIndexer = assertObjectTypeIndexer;\nexports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;\nexports.assertObjectTypeProperty = assertObjectTypeProperty;\nexports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;\nexports.assertOpaqueType = assertOpaqueType;\nexports.assertOptionalCallExpression = assertOptionalCallExpression;\nexports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;\nexports.assertOptionalMemberExpression = assertOptionalMemberExpression;\nexports.assertParenthesizedExpression = assertParenthesizedExpression;\nexports.assertPattern = assertPattern;\nexports.assertPatternLike = assertPatternLike;\nexports.assertPipelineBareFunction = assertPipelineBareFunction;\nexports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;\nexports.assertPipelineTopicExpression = assertPipelineTopicExpression;\nexports.assertPlaceholder = assertPlaceholder;\nexports.assertPrivate = assertPrivate;\nexports.assertPrivateName = assertPrivateName;\nexports.assertProgram = assertProgram;\nexports.assertProperty = assertProperty;\nexports.assertPureish = assertPureish;\nexports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;\nexports.assertRecordExpression = assertRecordExpression;\nexports.assertRegExpLiteral = assertRegExpLiteral;\nexports.assertRegexLiteral = assertRegexLiteral;\nexports.assertRestElement = assertRestElement;\nexports.assertRestProperty = assertRestProperty;\nexports.assertReturnStatement = assertReturnStatement;\nexports.assertScopable = assertScopable;\nexports.assertSequenceExpression = assertSequenceExpression;\nexports.assertSpreadElement = assertSpreadElement;\nexports.assertSpreadProperty = assertSpreadProperty;\nexports.assertStandardized = assertStandardized;\nexports.assertStatement = assertStatement;\nexports.assertStaticBlock = assertStaticBlock;\nexports.assertStringLiteral = assertStringLiteral;\nexports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;\nexports.assertStringTypeAnnotation = assertStringTypeAnnotation;\nexports.assertSuper = assertSuper;\nexports.assertSwitchCase = assertSwitchCase;\nexports.assertSwitchStatement = assertSwitchStatement;\nexports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;\nexports.assertTSAnyKeyword = assertTSAnyKeyword;\nexports.assertTSArrayType = assertTSArrayType;\nexports.assertTSAsExpression = assertTSAsExpression;\nexports.assertTSBaseType = assertTSBaseType;\nexports.assertTSBigIntKeyword = assertTSBigIntKeyword;\nexports.assertTSBooleanKeyword = assertTSBooleanKeyword;\nexports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;\nexports.assertTSConditionalType = assertTSConditionalType;\nexports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;\nexports.assertTSConstructorType = assertTSConstructorType;\nexports.assertTSDeclareFunction = assertTSDeclareFunction;\nexports.assertTSDeclareMethod = assertTSDeclareMethod;\nexports.assertTSEntityName = assertTSEntityName;\nexports.assertTSEnumBody = assertTSEnumBody;\nexports.assertTSEnumDeclaration = assertTSEnumDeclaration;\nexports.assertTSEnumMember = assertTSEnumMember;\nexports.assertTSExportAssignment = assertTSExportAssignment;\nexports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;\nexports.assertTSExternalModuleReference = assertTSExternalModuleReference;\nexports.assertTSFunctionType = assertTSFunctionType;\nexports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;\nexports.assertTSImportType = assertTSImportType;\nexports.assertTSIndexSignature = assertTSIndexSignature;\nexports.assertTSIndexedAccessType = assertTSIndexedAccessType;\nexports.assertTSInferType = assertTSInferType;\nexports.assertTSInstantiationExpression = assertTSInstantiationExpression;\nexports.assertTSInterfaceBody = assertTSInterfaceBody;\nexports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;\nexports.assertTSIntersectionType = assertTSIntersectionType;\nexports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;\nexports.assertTSLiteralType = assertTSLiteralType;\nexports.assertTSMappedType = assertTSMappedType;\nexports.assertTSMethodSignature = assertTSMethodSignature;\nexports.assertTSModuleBlock = assertTSModuleBlock;\nexports.assertTSModuleDeclaration = assertTSModuleDeclaration;\nexports.assertTSNamedTupleMember = assertTSNamedTupleMember;\nexports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;\nexports.assertTSNeverKeyword = assertTSNeverKeyword;\nexports.assertTSNonNullExpression = assertTSNonNullExpression;\nexports.assertTSNullKeyword = assertTSNullKeyword;\nexports.assertTSNumberKeyword = assertTSNumberKeyword;\nexports.assertTSObjectKeyword = assertTSObjectKeyword;\nexports.assertTSOptionalType = assertTSOptionalType;\nexports.assertTSParameterProperty = assertTSParameterProperty;\nexports.assertTSParenthesizedType = assertTSParenthesizedType;\nexports.assertTSPropertySignature = assertTSPropertySignature;\nexports.assertTSQualifiedName = assertTSQualifiedName;\nexports.assertTSRestType = assertTSRestType;\nexports.assertTSSatisfiesExpression = assertTSSatisfiesExpression;\nexports.assertTSStringKeyword = assertTSStringKeyword;\nexports.assertTSSymbolKeyword = assertTSSymbolKeyword;\nexports.assertTSTemplateLiteralType = assertTSTemplateLiteralType;\nexports.assertTSThisType = assertTSThisType;\nexports.assertTSTupleType = assertTSTupleType;\nexports.assertTSType = assertTSType;\nexports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;\nexports.assertTSTypeAnnotation = assertTSTypeAnnotation;\nexports.assertTSTypeAssertion = assertTSTypeAssertion;\nexports.assertTSTypeElement = assertTSTypeElement;\nexports.assertTSTypeLiteral = assertTSTypeLiteral;\nexports.assertTSTypeOperator = assertTSTypeOperator;\nexports.assertTSTypeParameter = assertTSTypeParameter;\nexports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;\nexports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;\nexports.assertTSTypePredicate = assertTSTypePredicate;\nexports.assertTSTypeQuery = assertTSTypeQuery;\nexports.assertTSTypeReference = assertTSTypeReference;\nexports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;\nexports.assertTSUnionType = assertTSUnionType;\nexports.assertTSUnknownKeyword = assertTSUnknownKeyword;\nexports.assertTSVoidKeyword = assertTSVoidKeyword;\nexports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;\nexports.assertTemplateElement = assertTemplateElement;\nexports.assertTemplateLiteral = assertTemplateLiteral;\nexports.assertTerminatorless = assertTerminatorless;\nexports.assertThisExpression = assertThisExpression;\nexports.assertThisTypeAnnotation = assertThisTypeAnnotation;\nexports.assertThrowStatement = assertThrowStatement;\nexports.assertTopicReference = assertTopicReference;\nexports.assertTryStatement = assertTryStatement;\nexports.assertTupleExpression = assertTupleExpression;\nexports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;\nexports.assertTypeAlias = assertTypeAlias;\nexports.assertTypeAnnotation = assertTypeAnnotation;\nexports.assertTypeCastExpression = assertTypeCastExpression;\nexports.assertTypeParameter = assertTypeParameter;\nexports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;\nexports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;\nexports.assertTypeScript = assertTypeScript;\nexports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;\nexports.assertUnaryExpression = assertUnaryExpression;\nexports.assertUnaryLike = assertUnaryLike;\nexports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;\nexports.assertUpdateExpression = assertUpdateExpression;\nexports.assertUserWhitespacable = assertUserWhitespacable;\nexports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;\nexports.assertVariableDeclaration = assertVariableDeclaration;\nexports.assertVariableDeclarator = assertVariableDeclarator;\nexports.assertVariance = assertVariance;\nexports.assertVoidPattern = assertVoidPattern;\nexports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;\nexports.assertWhile = assertWhile;\nexports.assertWhileStatement = assertWhileStatement;\nexports.assertWithStatement = assertWithStatement;\nexports.assertYieldExpression = assertYieldExpression;\nvar _is = require(\"../../validators/is.js\");\nvar _deprecationWarning = require(\"../../utils/deprecationWarning.js\");\nfunction assert(type, node, opts) {\n if (!(0, _is.default)(type, node, opts)) {\n throw new Error(`Expected type \"${type}\" with option ${JSON.stringify(opts)}, ` + `but instead got \"${node.type}\".`);\n }\n}\nfunction assertArrayExpression(node, opts) {\n assert(\"ArrayExpression\", node, opts);\n}\nfunction assertAssignmentExpression(node, opts) {\n assert(\"AssignmentExpression\", node, opts);\n}\nfunction assertBinaryExpression(node, opts) {\n assert(\"BinaryExpression\", node, opts);\n}\nfunction assertInterpreterDirective(node, opts) {\n assert(\"InterpreterDirective\", node, opts);\n}\nfunction assertDirective(node, opts) {\n assert(\"Directive\", node, opts);\n}\nfunction assertDirectiveLiteral(node, opts) {\n assert(\"DirectiveLiteral\", node, opts);\n}\nfunction assertBlockStatement(node, opts) {\n assert(\"BlockStatement\", node, opts);\n}\nfunction assertBreakStatement(node, opts) {\n assert(\"BreakStatement\", node, opts);\n}\nfunction assertCallExpression(node, opts) {\n assert(\"CallExpression\", node, opts);\n}\nfunction assertCatchClause(node, opts) {\n assert(\"CatchClause\", node, opts);\n}\nfunction assertConditionalExpression(node, opts) {\n assert(\"ConditionalExpression\", node, opts);\n}\nfunction assertContinueStatement(node, opts) {\n assert(\"ContinueStatement\", node, opts);\n}\nfunction assertDebuggerStatement(node, opts) {\n assert(\"DebuggerStatement\", node, opts);\n}\nfunction assertDoWhileStatement(node, opts) {\n assert(\"DoWhileStatement\", node, opts);\n}\nfunction assertEmptyStatement(node, opts) {\n assert(\"EmptyStatement\", node, opts);\n}\nfunction assertExpressionStatement(node, opts) {\n assert(\"ExpressionStatement\", node, opts);\n}\nfunction assertFile(node, opts) {\n assert(\"File\", node, opts);\n}\nfunction assertForInStatement(node, opts) {\n assert(\"ForInStatement\", node, opts);\n}\nfunction assertForStatement(node, opts) {\n assert(\"ForStatement\", node, opts);\n}\nfunction assertFunctionDeclaration(node, opts) {\n assert(\"FunctionDeclaration\", node, opts);\n}\nfunction assertFunctionExpression(node, opts) {\n assert(\"FunctionExpression\", node, opts);\n}\nfunction assertIdentifier(node, opts) {\n assert(\"Identifier\", node, opts);\n}\nfunction assertIfStatement(node, opts) {\n assert(\"IfStatement\", node, opts);\n}\nfunction assertLabeledStatement(node, opts) {\n assert(\"LabeledStatement\", node, opts);\n}\nfunction assertStringLiteral(node, opts) {\n assert(\"StringLiteral\", node, opts);\n}\nfunction assertNumericLiteral(node, opts) {\n assert(\"NumericLiteral\", node, opts);\n}\nfunction assertNullLiteral(node, opts) {\n assert(\"NullLiteral\", node, opts);\n}\nfunction assertBooleanLiteral(node, opts) {\n assert(\"BooleanLiteral\", node, opts);\n}\nfunction assertRegExpLiteral(node, opts) {\n assert(\"RegExpLiteral\", node, opts);\n}\nfunction assertLogicalExpression(node, opts) {\n assert(\"LogicalExpression\", node, opts);\n}\nfunction assertMemberExpression(node, opts) {\n assert(\"MemberExpression\", node, opts);\n}\nfunction assertNewExpression(node, opts) {\n assert(\"NewExpression\", node, opts);\n}\nfunction assertProgram(node, opts) {\n assert(\"Program\", node, opts);\n}\nfunction assertObjectExpression(node, opts) {\n assert(\"ObjectExpression\", node, opts);\n}\nfunction assertObjectMethod(node, opts) {\n assert(\"ObjectMethod\", node, opts);\n}\nfunction assertObjectProperty(node, opts) {\n assert(\"ObjectProperty\", node, opts);\n}\nfunction assertRestElement(node, opts) {\n assert(\"RestElement\", node, opts);\n}\nfunction assertReturnStatement(node, opts) {\n assert(\"ReturnStatement\", node, opts);\n}\nfunction assertSequenceExpression(node, opts) {\n assert(\"SequenceExpression\", node, opts);\n}\nfunction assertParenthesizedExpression(node, opts) {\n assert(\"ParenthesizedExpression\", node, opts);\n}\nfunction assertSwitchCase(node, opts) {\n assert(\"SwitchCase\", node, opts);\n}\nfunction assertSwitchStatement(node, opts) {\n assert(\"SwitchStatement\", node, opts);\n}\nfunction assertThisExpression(node, opts) {\n assert(\"ThisExpression\", node, opts);\n}\nfunction assertThrowStatement(node, opts) {\n assert(\"ThrowStatement\", node, opts);\n}\nfunction assertTryStatement(node, opts) {\n assert(\"TryStatement\", node, opts);\n}\nfunction assertUnaryExpression(node, opts) {\n assert(\"UnaryExpression\", node, opts);\n}\nfunction assertUpdateExpression(node, opts) {\n assert(\"UpdateExpression\", node, opts);\n}\nfunction assertVariableDeclaration(node, opts) {\n assert(\"VariableDeclaration\", node, opts);\n}\nfunction assertVariableDeclarator(node, opts) {\n assert(\"VariableDeclarator\", node, opts);\n}\nfunction assertWhileStatement(node, opts) {\n assert(\"WhileStatement\", node, opts);\n}\nfunction assertWithStatement(node, opts) {\n assert(\"WithStatement\", node, opts);\n}\nfunction assertAssignmentPattern(node, opts) {\n assert(\"AssignmentPattern\", node, opts);\n}\nfunction assertArrayPattern(node, opts) {\n assert(\"ArrayPattern\", node, opts);\n}\nfunction assertArrowFunctionExpression(node, opts) {\n assert(\"ArrowFunctionExpression\", node, opts);\n}\nfunction assertClassBody(node, opts) {\n assert(\"ClassBody\", node, opts);\n}\nfunction assertClassExpression(node, opts) {\n assert(\"ClassExpression\", node, opts);\n}\nfunction assertClassDeclaration(node, opts) {\n assert(\"ClassDeclaration\", node, opts);\n}\nfunction assertExportAllDeclaration(node, opts) {\n assert(\"ExportAllDeclaration\", node, opts);\n}\nfunction assertExportDefaultDeclaration(node, opts) {\n assert(\"ExportDefaultDeclaration\", node, opts);\n}\nfunction assertExportNamedDeclaration(node, opts) {\n assert(\"ExportNamedDeclaration\", node, opts);\n}\nfunction assertExportSpecifier(node, opts) {\n assert(\"ExportSpecifier\", node, opts);\n}\nfunction assertForOfStatement(node, opts) {\n assert(\"ForOfStatement\", node, opts);\n}\nfunction assertImportDeclaration(node, opts) {\n assert(\"ImportDeclaration\", node, opts);\n}\nfunction assertImportDefaultSpecifier(node, opts) {\n assert(\"ImportDefaultSpecifier\", node, opts);\n}\nfunction assertImportNamespaceSpecifier(node, opts) {\n assert(\"ImportNamespaceSpecifier\", node, opts);\n}\nfunction assertImportSpecifier(node, opts) {\n assert(\"ImportSpecifier\", node, opts);\n}\nfunction assertImportExpression(node, opts) {\n assert(\"ImportExpression\", node, opts);\n}\nfunction assertMetaProperty(node, opts) {\n assert(\"MetaProperty\", node, opts);\n}\nfunction assertClassMethod(node, opts) {\n assert(\"ClassMethod\", node, opts);\n}\nfunction assertObjectPattern(node, opts) {\n assert(\"ObjectPattern\", node, opts);\n}\nfunction assertSpreadElement(node, opts) {\n assert(\"SpreadElement\", node, opts);\n}\nfunction assertSuper(node, opts) {\n assert(\"Super\", node, opts);\n}\nfunction assertTaggedTemplateExpression(node, opts) {\n assert(\"TaggedTemplateExpression\", node, opts);\n}\nfunction assertTemplateElement(node, opts) {\n assert(\"TemplateElement\", node, opts);\n}\nfunction assertTemplateLiteral(node, opts) {\n assert(\"TemplateLiteral\", node, opts);\n}\nfunction assertYieldExpression(node, opts) {\n assert(\"YieldExpression\", node, opts);\n}\nfunction assertAwaitExpression(node, opts) {\n assert(\"AwaitExpression\", node, opts);\n}\nfunction assertImport(node, opts) {\n assert(\"Import\", node, opts);\n}\nfunction assertBigIntLiteral(node, opts) {\n assert(\"BigIntLiteral\", node, opts);\n}\nfunction assertExportNamespaceSpecifier(node, opts) {\n assert(\"ExportNamespaceSpecifier\", node, opts);\n}\nfunction assertOptionalMemberExpression(node, opts) {\n assert(\"OptionalMemberExpression\", node, opts);\n}\nfunction assertOptionalCallExpression(node, opts) {\n assert(\"OptionalCallExpression\", node, opts);\n}\nfunction assertClassProperty(node, opts) {\n assert(\"ClassProperty\", node, opts);\n}\nfunction assertClassAccessorProperty(node, opts) {\n assert(\"ClassAccessorProperty\", node, opts);\n}\nfunction assertClassPrivateProperty(node, opts) {\n assert(\"ClassPrivateProperty\", node, opts);\n}\nfunction assertClassPrivateMethod(node, opts) {\n assert(\"ClassPrivateMethod\", node, opts);\n}\nfunction assertPrivateName(node, opts) {\n assert(\"PrivateName\", node, opts);\n}\nfunction assertStaticBlock(node, opts) {\n assert(\"StaticBlock\", node, opts);\n}\nfunction assertImportAttribute(node, opts) {\n assert(\"ImportAttribute\", node, opts);\n}\nfunction assertAnyTypeAnnotation(node, opts) {\n assert(\"AnyTypeAnnotation\", node, opts);\n}\nfunction assertArrayTypeAnnotation(node, opts) {\n assert(\"ArrayTypeAnnotation\", node, opts);\n}\nfunction assertBooleanTypeAnnotation(node, opts) {\n assert(\"BooleanTypeAnnotation\", node, opts);\n}\nfunction assertBooleanLiteralTypeAnnotation(node, opts) {\n assert(\"BooleanLiteralTypeAnnotation\", node, opts);\n}\nfunction assertNullLiteralTypeAnnotation(node, opts) {\n assert(\"NullLiteralTypeAnnotation\", node, opts);\n}\nfunction assertClassImplements(node, opts) {\n assert(\"ClassImplements\", node, opts);\n}\nfunction assertDeclareClass(node, opts) {\n assert(\"DeclareClass\", node, opts);\n}\nfunction assertDeclareFunction(node, opts) {\n assert(\"DeclareFunction\", node, opts);\n}\nfunction assertDeclareInterface(node, opts) {\n assert(\"DeclareInterface\", node, opts);\n}\nfunction assertDeclareModule(node, opts) {\n assert(\"DeclareModule\", node, opts);\n}\nfunction assertDeclareModuleExports(node, opts) {\n assert(\"DeclareModuleExports\", node, opts);\n}\nfunction assertDeclareTypeAlias(node, opts) {\n assert(\"DeclareTypeAlias\", node, opts);\n}\nfunction assertDeclareOpaqueType(node, opts) {\n assert(\"DeclareOpaqueType\", node, opts);\n}\nfunction assertDeclareVariable(node, opts) {\n assert(\"DeclareVariable\", node, opts);\n}\nfunction assertDeclareExportDeclaration(node, opts) {\n assert(\"DeclareExportDeclaration\", node, opts);\n}\nfunction assertDeclareExportAllDeclaration(node, opts) {\n assert(\"DeclareExportAllDeclaration\", node, opts);\n}\nfunction assertDeclaredPredicate(node, opts) {\n assert(\"DeclaredPredicate\", node, opts);\n}\nfunction assertExistsTypeAnnotation(node, opts) {\n assert(\"ExistsTypeAnnotation\", node, opts);\n}\nfunction assertFunctionTypeAnnotation(node, opts) {\n assert(\"FunctionTypeAnnotation\", node, opts);\n}\nfunction assertFunctionTypeParam(node, opts) {\n assert(\"FunctionTypeParam\", node, opts);\n}\nfunction assertGenericTypeAnnotation(node, opts) {\n assert(\"GenericTypeAnnotation\", node, opts);\n}\nfunction assertInferredPredicate(node, opts) {\n assert(\"InferredPredicate\", node, opts);\n}\nfunction assertInterfaceExtends(node, opts) {\n assert(\"InterfaceExtends\", node, opts);\n}\nfunction assertInterfaceDeclaration(node, opts) {\n assert(\"InterfaceDeclaration\", node, opts);\n}\nfunction assertInterfaceTypeAnnotation(node, opts) {\n assert(\"InterfaceTypeAnnotation\", node, opts);\n}\nfunction assertIntersectionTypeAnnotation(node, opts) {\n assert(\"IntersectionTypeAnnotation\", node, opts);\n}\nfunction assertMixedTypeAnnotation(node, opts) {\n assert(\"MixedTypeAnnotation\", node, opts);\n}\nfunction assertEmptyTypeAnnotation(node, opts) {\n assert(\"EmptyTypeAnnotation\", node, opts);\n}\nfunction assertNullableTypeAnnotation(node, opts) {\n assert(\"NullableTypeAnnotation\", node, opts);\n}\nfunction assertNumberLiteralTypeAnnotation(node, opts) {\n assert(\"NumberLiteralTypeAnnotation\", node, opts);\n}\nfunction assertNumberTypeAnnotation(node, opts) {\n assert(\"NumberTypeAnnotation\", node, opts);\n}\nfunction assertObjectTypeAnnotation(node, opts) {\n assert(\"ObjectTypeAnnotation\", node, opts);\n}\nfunction assertObjectTypeInternalSlot(node, opts) {\n assert(\"ObjectTypeInternalSlot\", node, opts);\n}\nfunction assertObjectTypeCallProperty(node, opts) {\n assert(\"ObjectTypeCallProperty\", node, opts);\n}\nfunction assertObjectTypeIndexer(node, opts) {\n assert(\"ObjectTypeIndexer\", node, opts);\n}\nfunction assertObjectTypeProperty(node, opts) {\n assert(\"ObjectTypeProperty\", node, opts);\n}\nfunction assertObjectTypeSpreadProperty(node, opts) {\n assert(\"ObjectTypeSpreadProperty\", node, opts);\n}\nfunction assertOpaqueType(node, opts) {\n assert(\"OpaqueType\", node, opts);\n}\nfunction assertQualifiedTypeIdentifier(node, opts) {\n assert(\"QualifiedTypeIdentifier\", node, opts);\n}\nfunction assertStringLiteralTypeAnnotation(node, opts) {\n assert(\"StringLiteralTypeAnnotation\", node, opts);\n}\nfunction assertStringTypeAnnotation(node, opts) {\n assert(\"StringTypeAnnotation\", node, opts);\n}\nfunction assertSymbolTypeAnnotation(node, opts) {\n assert(\"SymbolTypeAnnotation\", node, opts);\n}\nfunction assertThisTypeAnnotation(node, opts) {\n assert(\"ThisTypeAnnotation\", node, opts);\n}\nfunction assertTupleTypeAnnotation(node, opts) {\n assert(\"TupleTypeAnnotation\", node, opts);\n}\nfunction assertTypeofTypeAnnotation(node, opts) {\n assert(\"TypeofTypeAnnotation\", node, opts);\n}\nfunction assertTypeAlias(node, opts) {\n assert(\"TypeAlias\", node, opts);\n}\nfunction assertTypeAnnotation(node, opts) {\n assert(\"TypeAnnotation\", node, opts);\n}\nfunction assertTypeCastExpression(node, opts) {\n assert(\"TypeCastExpression\", node, opts);\n}\nfunction assertTypeParameter(node, opts) {\n assert(\"TypeParameter\", node, opts);\n}\nfunction assertTypeParameterDeclaration(node, opts) {\n assert(\"TypeParameterDeclaration\", node, opts);\n}\nfunction assertTypeParameterInstantiation(node, opts) {\n assert(\"TypeParameterInstantiation\", node, opts);\n}\nfunction assertUnionTypeAnnotation(node, opts) {\n assert(\"UnionTypeAnnotation\", node, opts);\n}\nfunction assertVariance(node, opts) {\n assert(\"Variance\", node, opts);\n}\nfunction assertVoidTypeAnnotation(node, opts) {\n assert(\"VoidTypeAnnotation\", node, opts);\n}\nfunction assertEnumDeclaration(node, opts) {\n assert(\"EnumDeclaration\", node, opts);\n}\nfunction assertEnumBooleanBody(node, opts) {\n assert(\"EnumBooleanBody\", node, opts);\n}\nfunction assertEnumNumberBody(node, opts) {\n assert(\"EnumNumberBody\", node, opts);\n}\nfunction assertEnumStringBody(node, opts) {\n assert(\"EnumStringBody\", node, opts);\n}\nfunction assertEnumSymbolBody(node, opts) {\n assert(\"EnumSymbolBody\", node, opts);\n}\nfunction assertEnumBooleanMember(node, opts) {\n assert(\"EnumBooleanMember\", node, opts);\n}\nfunction assertEnumNumberMember(node, opts) {\n assert(\"EnumNumberMember\", node, opts);\n}\nfunction assertEnumStringMember(node, opts) {\n assert(\"EnumStringMember\", node, opts);\n}\nfunction assertEnumDefaultedMember(node, opts) {\n assert(\"EnumDefaultedMember\", node, opts);\n}\nfunction assertIndexedAccessType(node, opts) {\n assert(\"IndexedAccessType\", node, opts);\n}\nfunction assertOptionalIndexedAccessType(node, opts) {\n assert(\"OptionalIndexedAccessType\", node, opts);\n}\nfunction assertJSXAttribute(node, opts) {\n assert(\"JSXAttribute\", node, opts);\n}\nfunction assertJSXClosingElement(node, opts) {\n assert(\"JSXClosingElement\", node, opts);\n}\nfunction assertJSXElement(node, opts) {\n assert(\"JSXElement\", node, opts);\n}\nfunction assertJSXEmptyExpression(node, opts) {\n assert(\"JSXEmptyExpression\", node, opts);\n}\nfunction assertJSXExpressionContainer(node, opts) {\n assert(\"JSXExpressionContainer\", node, opts);\n}\nfunction assertJSXSpreadChild(node, opts) {\n assert(\"JSXSpreadChild\", node, opts);\n}\nfunction assertJSXIdentifier(node, opts) {\n assert(\"JSXIdentifier\", node, opts);\n}\nfunction assertJSXMemberExpression(node, opts) {\n assert(\"JSXMemberExpression\", node, opts);\n}\nfunction assertJSXNamespacedName(node, opts) {\n assert(\"JSXNamespacedName\", node, opts);\n}\nfunction assertJSXOpeningElement(node, opts) {\n assert(\"JSXOpeningElement\", node, opts);\n}\nfunction assertJSXSpreadAttribute(node, opts) {\n assert(\"JSXSpreadAttribute\", node, opts);\n}\nfunction assertJSXText(node, opts) {\n assert(\"JSXText\", node, opts);\n}\nfunction assertJSXFragment(node, opts) {\n assert(\"JSXFragment\", node, opts);\n}\nfunction assertJSXOpeningFragment(node, opts) {\n assert(\"JSXOpeningFragment\", node, opts);\n}\nfunction assertJSXClosingFragment(node, opts) {\n assert(\"JSXClosingFragment\", node, opts);\n}\nfunction assertNoop(node, opts) {\n assert(\"Noop\", node, opts);\n}\nfunction assertPlaceholder(node, opts) {\n assert(\"Placeholder\", node, opts);\n}\nfunction assertV8IntrinsicIdentifier(node, opts) {\n assert(\"V8IntrinsicIdentifier\", node, opts);\n}\nfunction assertArgumentPlaceholder(node, opts) {\n assert(\"ArgumentPlaceholder\", node, opts);\n}\nfunction assertBindExpression(node, opts) {\n assert(\"BindExpression\", node, opts);\n}\nfunction assertDecorator(node, opts) {\n assert(\"Decorator\", node, opts);\n}\nfunction assertDoExpression(node, opts) {\n assert(\"DoExpression\", node, opts);\n}\nfunction assertExportDefaultSpecifier(node, opts) {\n assert(\"ExportDefaultSpecifier\", node, opts);\n}\nfunction assertRecordExpression(node, opts) {\n assert(\"RecordExpression\", node, opts);\n}\nfunction assertTupleExpression(node, opts) {\n assert(\"TupleExpression\", node, opts);\n}\nfunction assertDecimalLiteral(node, opts) {\n assert(\"DecimalLiteral\", node, opts);\n}\nfunction assertModuleExpression(node, opts) {\n assert(\"ModuleExpression\", node, opts);\n}\nfunction assertTopicReference(node, opts) {\n assert(\"TopicReference\", node, opts);\n}\nfunction assertPipelineTopicExpression(node, opts) {\n assert(\"PipelineTopicExpression\", node, opts);\n}\nfunction assertPipelineBareFunction(node, opts) {\n assert(\"PipelineBareFunction\", node, opts);\n}\nfunction assertPipelinePrimaryTopicReference(node, opts) {\n assert(\"PipelinePrimaryTopicReference\", node, opts);\n}\nfunction assertVoidPattern(node, opts) {\n assert(\"VoidPattern\", node, opts);\n}\nfunction assertTSParameterProperty(node, opts) {\n assert(\"TSParameterProperty\", node, opts);\n}\nfunction assertTSDeclareFunction(node, opts) {\n assert(\"TSDeclareFunction\", node, opts);\n}\nfunction assertTSDeclareMethod(node, opts) {\n assert(\"TSDeclareMethod\", node, opts);\n}\nfunction assertTSQualifiedName(node, opts) {\n assert(\"TSQualifiedName\", node, opts);\n}\nfunction assertTSCallSignatureDeclaration(node, opts) {\n assert(\"TSCallSignatureDeclaration\", node, opts);\n}\nfunction assertTSConstructSignatureDeclaration(node, opts) {\n assert(\"TSConstructSignatureDeclaration\", node, opts);\n}\nfunction assertTSPropertySignature(node, opts) {\n assert(\"TSPropertySignature\", node, opts);\n}\nfunction assertTSMethodSignature(node, opts) {\n assert(\"TSMethodSignature\", node, opts);\n}\nfunction assertTSIndexSignature(node, opts) {\n assert(\"TSIndexSignature\", node, opts);\n}\nfunction assertTSAnyKeyword(node, opts) {\n assert(\"TSAnyKeyword\", node, opts);\n}\nfunction assertTSBooleanKeyword(node, opts) {\n assert(\"TSBooleanKeyword\", node, opts);\n}\nfunction assertTSBigIntKeyword(node, opts) {\n assert(\"TSBigIntKeyword\", node, opts);\n}\nfunction assertTSIntrinsicKeyword(node, opts) {\n assert(\"TSIntrinsicKeyword\", node, opts);\n}\nfunction assertTSNeverKeyword(node, opts) {\n assert(\"TSNeverKeyword\", node, opts);\n}\nfunction assertTSNullKeyword(node, opts) {\n assert(\"TSNullKeyword\", node, opts);\n}\nfunction assertTSNumberKeyword(node, opts) {\n assert(\"TSNumberKeyword\", node, opts);\n}\nfunction assertTSObjectKeyword(node, opts) {\n assert(\"TSObjectKeyword\", node, opts);\n}\nfunction assertTSStringKeyword(node, opts) {\n assert(\"TSStringKeyword\", node, opts);\n}\nfunction assertTSSymbolKeyword(node, opts) {\n assert(\"TSSymbolKeyword\", node, opts);\n}\nfunction assertTSUndefinedKeyword(node, opts) {\n assert(\"TSUndefinedKeyword\", node, opts);\n}\nfunction assertTSUnknownKeyword(node, opts) {\n assert(\"TSUnknownKeyword\", node, opts);\n}\nfunction assertTSVoidKeyword(node, opts) {\n assert(\"TSVoidKeyword\", node, opts);\n}\nfunction assertTSThisType(node, opts) {\n assert(\"TSThisType\", node, opts);\n}\nfunction assertTSFunctionType(node, opts) {\n assert(\"TSFunctionType\", node, opts);\n}\nfunction assertTSConstructorType(node, opts) {\n assert(\"TSConstructorType\", node, opts);\n}\nfunction assertTSTypeReference(node, opts) {\n assert(\"TSTypeReference\", node, opts);\n}\nfunction assertTSTypePredicate(node, opts) {\n assert(\"TSTypePredicate\", node, opts);\n}\nfunction assertTSTypeQuery(node, opts) {\n assert(\"TSTypeQuery\", node, opts);\n}\nfunction assertTSTypeLiteral(node, opts) {\n assert(\"TSTypeLiteral\", node, opts);\n}\nfunction assertTSArrayType(node, opts) {\n assert(\"TSArrayType\", node, opts);\n}\nfunction assertTSTupleType(node, opts) {\n assert(\"TSTupleType\", node, opts);\n}\nfunction assertTSOptionalType(node, opts) {\n assert(\"TSOptionalType\", node, opts);\n}\nfunction assertTSRestType(node, opts) {\n assert(\"TSRestType\", node, opts);\n}\nfunction assertTSNamedTupleMember(node, opts) {\n assert(\"TSNamedTupleMember\", node, opts);\n}\nfunction assertTSUnionType(node, opts) {\n assert(\"TSUnionType\", node, opts);\n}\nfunction assertTSIntersectionType(node, opts) {\n assert(\"TSIntersectionType\", node, opts);\n}\nfunction assertTSConditionalType(node, opts) {\n assert(\"TSConditionalType\", node, opts);\n}\nfunction assertTSInferType(node, opts) {\n assert(\"TSInferType\", node, opts);\n}\nfunction assertTSParenthesizedType(node, opts) {\n assert(\"TSParenthesizedType\", node, opts);\n}\nfunction assertTSTypeOperator(node, opts) {\n assert(\"TSTypeOperator\", node, opts);\n}\nfunction assertTSIndexedAccessType(node, opts) {\n assert(\"TSIndexedAccessType\", node, opts);\n}\nfunction assertTSMappedType(node, opts) {\n assert(\"TSMappedType\", node, opts);\n}\nfunction assertTSTemplateLiteralType(node, opts) {\n assert(\"TSTemplateLiteralType\", node, opts);\n}\nfunction assertTSLiteralType(node, opts) {\n assert(\"TSLiteralType\", node, opts);\n}\nfunction assertTSExpressionWithTypeArguments(node, opts) {\n assert(\"TSExpressionWithTypeArguments\", node, opts);\n}\nfunction assertTSInterfaceDeclaration(node, opts) {\n assert(\"TSInterfaceDeclaration\", node, opts);\n}\nfunction assertTSInterfaceBody(node, opts) {\n assert(\"TSInterfaceBody\", node, opts);\n}\nfunction assertTSTypeAliasDeclaration(node, opts) {\n assert(\"TSTypeAliasDeclaration\", node, opts);\n}\nfunction assertTSInstantiationExpression(node, opts) {\n assert(\"TSInstantiationExpression\", node, opts);\n}\nfunction assertTSAsExpression(node, opts) {\n assert(\"TSAsExpression\", node, opts);\n}\nfunction assertTSSatisfiesExpression(node, opts) {\n assert(\"TSSatisfiesExpression\", node, opts);\n}\nfunction assertTSTypeAssertion(node, opts) {\n assert(\"TSTypeAssertion\", node, opts);\n}\nfunction assertTSEnumBody(node, opts) {\n assert(\"TSEnumBody\", node, opts);\n}\nfunction assertTSEnumDeclaration(node, opts) {\n assert(\"TSEnumDeclaration\", node, opts);\n}\nfunction assertTSEnumMember(node, opts) {\n assert(\"TSEnumMember\", node, opts);\n}\nfunction assertTSModuleDeclaration(node, opts) {\n assert(\"TSModuleDeclaration\", node, opts);\n}\nfunction assertTSModuleBlock(node, opts) {\n assert(\"TSModuleBlock\", node, opts);\n}\nfunction assertTSImportType(node, opts) {\n assert(\"TSImportType\", node, opts);\n}\nfunction assertTSImportEqualsDeclaration(node, opts) {\n assert(\"TSImportEqualsDeclaration\", node, opts);\n}\nfunction assertTSExternalModuleReference(node, opts) {\n assert(\"TSExternalModuleReference\", node, opts);\n}\nfunction assertTSNonNullExpression(node, opts) {\n assert(\"TSNonNullExpression\", node, opts);\n}\nfunction assertTSExportAssignment(node, opts) {\n assert(\"TSExportAssignment\", node, opts);\n}\nfunction assertTSNamespaceExportDeclaration(node, opts) {\n assert(\"TSNamespaceExportDeclaration\", node, opts);\n}\nfunction assertTSTypeAnnotation(node, opts) {\n assert(\"TSTypeAnnotation\", node, opts);\n}\nfunction assertTSTypeParameterInstantiation(node, opts) {\n assert(\"TSTypeParameterInstantiation\", node, opts);\n}\nfunction assertTSTypeParameterDeclaration(node, opts) {\n assert(\"TSTypeParameterDeclaration\", node, opts);\n}\nfunction assertTSTypeParameter(node, opts) {\n assert(\"TSTypeParameter\", node, opts);\n}\nfunction assertStandardized(node, opts) {\n assert(\"Standardized\", node, opts);\n}\nfunction assertExpression(node, opts) {\n assert(\"Expression\", node, opts);\n}\nfunction assertBinary(node, opts) {\n assert(\"Binary\", node, opts);\n}\nfunction assertScopable(node, opts) {\n assert(\"Scopable\", node, opts);\n}\nfunction assertBlockParent(node, opts) {\n assert(\"BlockParent\", node, opts);\n}\nfunction assertBlock(node, opts) {\n assert(\"Block\", node, opts);\n}\nfunction assertStatement(node, opts) {\n assert(\"Statement\", node, opts);\n}\nfunction assertTerminatorless(node, opts) {\n assert(\"Terminatorless\", node, opts);\n}\nfunction assertCompletionStatement(node, opts) {\n assert(\"CompletionStatement\", node, opts);\n}\nfunction assertConditional(node, opts) {\n assert(\"Conditional\", node, opts);\n}\nfunction assertLoop(node, opts) {\n assert(\"Loop\", node, opts);\n}\nfunction assertWhile(node, opts) {\n assert(\"While\", node, opts);\n}\nfunction assertExpressionWrapper(node, opts) {\n assert(\"ExpressionWrapper\", node, opts);\n}\nfunction assertFor(node, opts) {\n assert(\"For\", node, opts);\n}\nfunction assertForXStatement(node, opts) {\n assert(\"ForXStatement\", node, opts);\n}\nfunction assertFunction(node, opts) {\n assert(\"Function\", node, opts);\n}\nfunction assertFunctionParent(node, opts) {\n assert(\"FunctionParent\", node, opts);\n}\nfunction assertPureish(node, opts) {\n assert(\"Pureish\", node, opts);\n}\nfunction assertDeclaration(node, opts) {\n assert(\"Declaration\", node, opts);\n}\nfunction assertFunctionParameter(node, opts) {\n assert(\"FunctionParameter\", node, opts);\n}\nfunction assertPatternLike(node, opts) {\n assert(\"PatternLike\", node, opts);\n}\nfunction assertLVal(node, opts) {\n assert(\"LVal\", node, opts);\n}\nfunction assertTSEntityName(node, opts) {\n assert(\"TSEntityName\", node, opts);\n}\nfunction assertLiteral(node, opts) {\n assert(\"Literal\", node, opts);\n}\nfunction assertImmutable(node, opts) {\n assert(\"Immutable\", node, opts);\n}\nfunction assertUserWhitespacable(node, opts) {\n assert(\"UserWhitespacable\", node, opts);\n}\nfunction assertMethod(node, opts) {\n assert(\"Method\", node, opts);\n}\nfunction assertObjectMember(node, opts) {\n assert(\"ObjectMember\", node, opts);\n}\nfunction assertProperty(node, opts) {\n assert(\"Property\", node, opts);\n}\nfunction assertUnaryLike(node, opts) {\n assert(\"UnaryLike\", node, opts);\n}\nfunction assertPattern(node, opts) {\n assert(\"Pattern\", node, opts);\n}\nfunction assertClass(node, opts) {\n assert(\"Class\", node, opts);\n}\nfunction assertImportOrExportDeclaration(node, opts) {\n assert(\"ImportOrExportDeclaration\", node, opts);\n}\nfunction assertExportDeclaration(node, opts) {\n assert(\"ExportDeclaration\", node, opts);\n}\nfunction assertModuleSpecifier(node, opts) {\n assert(\"ModuleSpecifier\", node, opts);\n}\nfunction assertAccessor(node, opts) {\n assert(\"Accessor\", node, opts);\n}\nfunction assertPrivate(node, opts) {\n assert(\"Private\", node, opts);\n}\nfunction assertFlow(node, opts) {\n assert(\"Flow\", node, opts);\n}\nfunction assertFlowType(node, opts) {\n assert(\"FlowType\", node, opts);\n}\nfunction assertFlowBaseAnnotation(node, opts) {\n assert(\"FlowBaseAnnotation\", node, opts);\n}\nfunction assertFlowDeclaration(node, opts) {\n assert(\"FlowDeclaration\", node, opts);\n}\nfunction assertFlowPredicate(node, opts) {\n assert(\"FlowPredicate\", node, opts);\n}\nfunction assertEnumBody(node, opts) {\n assert(\"EnumBody\", node, opts);\n}\nfunction assertEnumMember(node, opts) {\n assert(\"EnumMember\", node, opts);\n}\nfunction assertJSX(node, opts) {\n assert(\"JSX\", node, opts);\n}\nfunction assertMiscellaneous(node, opts) {\n assert(\"Miscellaneous\", node, opts);\n}\nfunction assertTypeScript(node, opts) {\n assert(\"TypeScript\", node, opts);\n}\nfunction assertTSTypeElement(node, opts) {\n assert(\"TSTypeElement\", node, opts);\n}\nfunction assertTSType(node, opts) {\n assert(\"TSType\", node, opts);\n}\nfunction assertTSBaseType(node, opts) {\n assert(\"TSBaseType\", node, opts);\n}\nfunction assertNumberLiteral(node, opts) {\n (0, _deprecationWarning.default)(\"assertNumberLiteral\", \"assertNumericLiteral\");\n assert(\"NumberLiteral\", node, opts);\n}\nfunction assertRegexLiteral(node, opts) {\n (0, _deprecationWarning.default)(\"assertRegexLiteral\", \"assertRegExpLiteral\");\n assert(\"RegexLiteral\", node, opts);\n}\nfunction assertRestProperty(node, opts) {\n (0, _deprecationWarning.default)(\"assertRestProperty\", \"assertRestElement\");\n assert(\"RestProperty\", node, opts);\n}\nfunction assertSpreadProperty(node, opts) {\n (0, _deprecationWarning.default)(\"assertSpreadProperty\", \"assertSpreadElement\");\n assert(\"SpreadProperty\", node, opts);\n}\nfunction assertModuleDeclaration(node, opts) {\n (0, _deprecationWarning.default)(\"assertModuleDeclaration\", \"assertImportOrExportDeclaration\");\n assert(\"ModuleDeclaration\", node, opts);\n}\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _index = require(\"../generated/index.js\");\nvar _default = exports.default = createTypeAnnotationBasedOnTypeof;\nfunction createTypeAnnotationBasedOnTypeof(type) {\n switch (type) {\n case \"string\":\n return (0, _index.stringTypeAnnotation)();\n case \"number\":\n return (0, _index.numberTypeAnnotation)();\n case \"undefined\":\n return (0, _index.voidTypeAnnotation)();\n case \"boolean\":\n return (0, _index.booleanTypeAnnotation)();\n case \"function\":\n return (0, _index.genericTypeAnnotation)((0, _index.identifier)(\"Function\"));\n case \"object\":\n return (0, _index.genericTypeAnnotation)((0, _index.identifier)(\"Object\"));\n case \"symbol\":\n return (0, _index.genericTypeAnnotation)((0, _index.identifier)(\"Symbol\"));\n case \"bigint\":\n return (0, _index.anyTypeAnnotation)();\n }\n throw new Error(\"Invalid typeof value: \" + type);\n}\n\n//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = createFlowUnionType;\nvar _index = require(\"../generated/index.js\");\nvar _removeTypeDuplicates = require(\"../../modifications/flow/removeTypeDuplicates.js\");\nfunction createFlowUnionType(types) {\n const flattened = (0, _removeTypeDuplicates.default)(types);\n if (flattened.length === 1) {\n return flattened[0];\n } else {\n return (0, _index.unionTypeAnnotation)(flattened);\n }\n}\n\n//# sourceMappingURL=createFlowUnionType.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = removeTypeDuplicates;\nvar _index = require(\"../../validators/generated/index.js\");\nfunction getQualifiedName(node) {\n return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;\n}\nfunction removeTypeDuplicates(nodesIn) {\n const nodes = Array.from(nodesIn);\n const generics = new Map();\n const bases = new Map();\n const typeGroups = new Set();\n const types = [];\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n if (types.includes(node)) {\n continue;\n }\n if ((0, _index.isAnyTypeAnnotation)(node)) {\n return [node];\n }\n if ((0, _index.isFlowBaseAnnotation)(node)) {\n bases.set(node.type, node);\n continue;\n }\n if ((0, _index.isUnionTypeAnnotation)(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n if ((0, _index.isGenericTypeAnnotation)(node)) {\n const name = getQualifiedName(node.id);\n if (generics.has(name)) {\n let existing = generics.get(name);\n if (existing.typeParameters) {\n if (node.typeParameters) {\n existing.typeParameters.params.push(...node.typeParameters.params);\n existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params);\n }\n } else {\n existing = node.typeParameters;\n }\n } else {\n generics.set(name, node);\n }\n continue;\n }\n types.push(node);\n }\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n return types;\n}\n\n//# sourceMappingURL=removeTypeDuplicates.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = createTSUnionType;\nvar _index = require(\"../generated/index.js\");\nvar _removeTypeDuplicates = require(\"../../modifications/typescript/removeTypeDuplicates.js\");\nvar _index2 = require(\"../../validators/generated/index.js\");\nfunction createTSUnionType(typeAnnotations) {\n const types = typeAnnotations.map(type => {\n return (0, _index2.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;\n });\n const flattened = (0, _removeTypeDuplicates.default)(types);\n if (flattened.length === 1) {\n return flattened[0];\n } else {\n return (0, _index.tsUnionType)(flattened);\n }\n}\n\n//# sourceMappingURL=createTSUnionType.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = removeTypeDuplicates;\nvar _index = require(\"../../validators/generated/index.js\");\nfunction getQualifiedName(node) {\n return (0, _index.isIdentifier)(node) ? node.name : (0, _index.isThisExpression)(node) ? \"this\" : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\nfunction removeTypeDuplicates(nodesIn) {\n const nodes = Array.from(nodesIn);\n const generics = new Map();\n const bases = new Map();\n const typeGroups = new Set();\n const types = [];\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (!node) continue;\n if (types.includes(node)) {\n continue;\n }\n if ((0, _index.isTSAnyKeyword)(node)) {\n return [node];\n }\n if ((0, _index.isTSBaseType)(node)) {\n bases.set(node.type, node);\n continue;\n }\n if ((0, _index.isTSUnionType)(node)) {\n if (!typeGroups.has(node.types)) {\n nodes.push(...node.types);\n typeGroups.add(node.types);\n }\n continue;\n }\n const typeArgumentsKey = \"typeParameters\";\n if ((0, _index.isTSTypeReference)(node) && node[typeArgumentsKey]) {\n const typeArguments = node[typeArgumentsKey];\n const name = getQualifiedName(node.typeName);\n if (generics.has(name)) {\n let existing = generics.get(name);\n const existingTypeArguments = existing[typeArgumentsKey];\n if (existingTypeArguments) {\n existingTypeArguments.params.push(...typeArguments.params);\n existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params);\n } else {\n existing = typeArguments;\n }\n } else {\n generics.set(name, node);\n }\n continue;\n }\n types.push(node);\n }\n for (const [, baseType] of bases) {\n types.push(baseType);\n }\n for (const [, genericName] of generics) {\n types.push(genericName);\n }\n return types;\n}\n\n//# sourceMappingURL=removeTypeDuplicates.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.buildUndefinedNode = buildUndefinedNode;\nvar _index = require(\"./generated/index.js\");\nfunction buildUndefinedNode() {\n return (0, _index.unaryExpression)(\"void\", (0, _index.numericLiteral)(0), true);\n}\n\n//# sourceMappingURL=productions.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = cloneNode;\nvar _index = require(\"../definitions/index.js\");\nvar _index2 = require(\"../validators/generated/index.js\");\nconst {\n hasOwn\n} = {\n hasOwn: Function.call.bind(Object.prototype.hasOwnProperty)\n};\nfunction cloneIfNode(obj, deep, withoutLoc, commentsCache) {\n if (obj && typeof obj.type === \"string\") {\n return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);\n }\n return obj;\n}\nfunction cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {\n if (Array.isArray(obj)) {\n return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));\n }\n return cloneIfNode(obj, deep, withoutLoc, commentsCache);\n}\nfunction cloneNode(node, deep = true, withoutLoc = false) {\n return cloneNodeInternal(node, deep, withoutLoc, new Map());\n}\nfunction cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {\n if (!node) return node;\n const {\n type\n } = node;\n const newNode = {\n type: node.type\n };\n if ((0, _index2.isIdentifier)(node)) {\n newNode.name = node.name;\n if (hasOwn(node, \"optional\") && typeof node.optional === \"boolean\") {\n newNode.optional = node.optional;\n }\n if (hasOwn(node, \"typeAnnotation\")) {\n newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;\n }\n if (hasOwn(node, \"decorators\")) {\n newNode.decorators = deep ? cloneIfNodeOrArray(node.decorators, true, withoutLoc, commentsCache) : node.decorators;\n }\n } else if (!hasOwn(_index.NODE_FIELDS, type)) {\n throw new Error(`Unknown node type: \"${type}\"`);\n } else {\n for (const field of Object.keys(_index.NODE_FIELDS[type])) {\n if (hasOwn(node, field)) {\n if (deep) {\n newNode[field] = (0, _index2.isFile)(node) && field === \"comments\" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);\n } else {\n newNode[field] = node[field];\n }\n }\n }\n }\n if (hasOwn(node, \"loc\")) {\n if (withoutLoc) {\n newNode.loc = null;\n } else {\n newNode.loc = node.loc;\n }\n }\n if (hasOwn(node, \"leadingComments\")) {\n newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);\n }\n if (hasOwn(node, \"innerComments\")) {\n newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);\n }\n if (hasOwn(node, \"trailingComments\")) {\n newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);\n }\n if (hasOwn(node, \"extra\")) {\n newNode.extra = Object.assign({}, node.extra);\n }\n return newNode;\n}\nfunction maybeCloneComments(comments, deep, withoutLoc, commentsCache) {\n if (!comments || !deep) {\n return comments;\n }\n return comments.map(comment => {\n const cache = commentsCache.get(comment);\n if (cache) return cache;\n const {\n type,\n value,\n loc\n } = comment;\n const ret = {\n type,\n value,\n loc\n };\n if (withoutLoc) {\n ret.loc = null;\n }\n commentsCache.set(comment, ret);\n return ret;\n });\n}\n\n//# sourceMappingURL=cloneNode.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = clone;\nvar _cloneNode = require(\"./cloneNode.js\");\nfunction clone(node) {\n return (0, _cloneNode.default)(node, false);\n}\n\n//# sourceMappingURL=clone.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = cloneDeep;\nvar _cloneNode = require(\"./cloneNode.js\");\nfunction cloneDeep(node) {\n return (0, _cloneNode.default)(node);\n}\n\n//# sourceMappingURL=cloneDeep.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = cloneDeepWithoutLoc;\nvar _cloneNode = require(\"./cloneNode.js\");\nfunction cloneDeepWithoutLoc(node) {\n return (0, _cloneNode.default)(node, true, true);\n}\n\n//# sourceMappingURL=cloneDeepWithoutLoc.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = cloneWithoutLoc;\nvar _cloneNode = require(\"./cloneNode.js\");\nfunction cloneWithoutLoc(node) {\n return (0, _cloneNode.default)(node, false, true);\n}\n\n//# sourceMappingURL=cloneWithoutLoc.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = addComment;\nvar _addComments = require(\"./addComments.js\");\nfunction addComment(node, type, content, line) {\n return (0, _addComments.default)(node, type, [{\n type: line ? \"CommentLine\" : \"CommentBlock\",\n value: content\n }]);\n}\n\n//# sourceMappingURL=addComment.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = addComments;\nfunction addComments(node, type, comments) {\n if (!comments || !node) return node;\n const key = `${type}Comments`;\n if (node[key]) {\n if (type === \"leading\") {\n node[key] = comments.concat(node[key]);\n } else {\n node[key].push(...comments);\n }\n } else {\n node[key] = comments;\n }\n return node;\n}\n\n//# sourceMappingURL=addComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inheritInnerComments;\nvar _inherit = require(\"../utils/inherit.js\");\nfunction inheritInnerComments(child, parent) {\n (0, _inherit.default)(\"innerComments\", child, parent);\n}\n\n//# sourceMappingURL=inheritInnerComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inherit;\nfunction inherit(key, child, parent) {\n if (child && parent) {\n child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));\n }\n}\n\n//# sourceMappingURL=inherit.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inheritLeadingComments;\nvar _inherit = require(\"../utils/inherit.js\");\nfunction inheritLeadingComments(child, parent) {\n (0, _inherit.default)(\"leadingComments\", child, parent);\n}\n\n//# sourceMappingURL=inheritLeadingComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inheritsComments;\nvar _inheritTrailingComments = require(\"./inheritTrailingComments.js\");\nvar _inheritLeadingComments = require(\"./inheritLeadingComments.js\");\nvar _inheritInnerComments = require(\"./inheritInnerComments.js\");\nfunction inheritsComments(child, parent) {\n (0, _inheritTrailingComments.default)(child, parent);\n (0, _inheritLeadingComments.default)(child, parent);\n (0, _inheritInnerComments.default)(child, parent);\n return child;\n}\n\n//# sourceMappingURL=inheritsComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inheritTrailingComments;\nvar _inherit = require(\"../utils/inherit.js\");\nfunction inheritTrailingComments(child, parent) {\n (0, _inherit.default)(\"trailingComments\", child, parent);\n}\n\n//# sourceMappingURL=inheritTrailingComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = removeComments;\nvar _index = require(\"../constants/index.js\");\nfunction removeComments(node) {\n _index.COMMENT_KEYS.forEach(key => {\n node[key] = null;\n });\n return node;\n}\n\n//# sourceMappingURL=removeComments.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTIONPARAMETER_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;\nvar _index = require(\"../../definitions/index.js\");\nconst STANDARDIZED_TYPES = exports.STANDARDIZED_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Standardized\"];\nconst EXPRESSION_TYPES = exports.EXPRESSION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Expression\"];\nconst BINARY_TYPES = exports.BINARY_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Binary\"];\nconst SCOPABLE_TYPES = exports.SCOPABLE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Scopable\"];\nconst BLOCKPARENT_TYPES = exports.BLOCKPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"BlockParent\"];\nconst BLOCK_TYPES = exports.BLOCK_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Block\"];\nconst STATEMENT_TYPES = exports.STATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Statement\"];\nconst TERMINATORLESS_TYPES = exports.TERMINATORLESS_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Terminatorless\"];\nconst COMPLETIONSTATEMENT_TYPES = exports.COMPLETIONSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"CompletionStatement\"];\nconst CONDITIONAL_TYPES = exports.CONDITIONAL_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Conditional\"];\nconst LOOP_TYPES = exports.LOOP_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Loop\"];\nconst WHILE_TYPES = exports.WHILE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"While\"];\nconst EXPRESSIONWRAPPER_TYPES = exports.EXPRESSIONWRAPPER_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ExpressionWrapper\"];\nconst FOR_TYPES = exports.FOR_TYPES = _index.FLIPPED_ALIAS_KEYS[\"For\"];\nconst FORXSTATEMENT_TYPES = exports.FORXSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ForXStatement\"];\nconst FUNCTION_TYPES = exports.FUNCTION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Function\"];\nconst FUNCTIONPARENT_TYPES = exports.FUNCTIONPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FunctionParent\"];\nconst PUREISH_TYPES = exports.PUREISH_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Pureish\"];\nconst DECLARATION_TYPES = exports.DECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Declaration\"];\nconst FUNCTIONPARAMETER_TYPES = exports.FUNCTIONPARAMETER_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FunctionParameter\"];\nconst PATTERNLIKE_TYPES = exports.PATTERNLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"PatternLike\"];\nconst LVAL_TYPES = exports.LVAL_TYPES = _index.FLIPPED_ALIAS_KEYS[\"LVal\"];\nconst TSENTITYNAME_TYPES = exports.TSENTITYNAME_TYPES = _index.FLIPPED_ALIAS_KEYS[\"TSEntityName\"];\nconst LITERAL_TYPES = exports.LITERAL_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Literal\"];\nconst IMMUTABLE_TYPES = exports.IMMUTABLE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Immutable\"];\nconst USERWHITESPACABLE_TYPES = exports.USERWHITESPACABLE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"UserWhitespacable\"];\nconst METHOD_TYPES = exports.METHOD_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Method\"];\nconst OBJECTMEMBER_TYPES = exports.OBJECTMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ObjectMember\"];\nconst PROPERTY_TYPES = exports.PROPERTY_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Property\"];\nconst UNARYLIKE_TYPES = exports.UNARYLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"UnaryLike\"];\nconst PATTERN_TYPES = exports.PATTERN_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Pattern\"];\nconst CLASS_TYPES = exports.CLASS_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Class\"];\nconst IMPORTOREXPORTDECLARATION_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ImportOrExportDeclaration\"];\nconst EXPORTDECLARATION_TYPES = exports.EXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ExportDeclaration\"];\nconst MODULESPECIFIER_TYPES = exports.MODULESPECIFIER_TYPES = _index.FLIPPED_ALIAS_KEYS[\"ModuleSpecifier\"];\nconst ACCESSOR_TYPES = exports.ACCESSOR_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Accessor\"];\nconst PRIVATE_TYPES = exports.PRIVATE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Private\"];\nconst FLOW_TYPES = exports.FLOW_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Flow\"];\nconst FLOWTYPE_TYPES = exports.FLOWTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FlowType\"];\nconst FLOWBASEANNOTATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FlowBaseAnnotation\"];\nconst FLOWDECLARATION_TYPES = exports.FLOWDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FlowDeclaration\"];\nconst FLOWPREDICATE_TYPES = exports.FLOWPREDICATE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"FlowPredicate\"];\nconst ENUMBODY_TYPES = exports.ENUMBODY_TYPES = _index.FLIPPED_ALIAS_KEYS[\"EnumBody\"];\nconst ENUMMEMBER_TYPES = exports.ENUMMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS[\"EnumMember\"];\nconst JSX_TYPES = exports.JSX_TYPES = _index.FLIPPED_ALIAS_KEYS[\"JSX\"];\nconst MISCELLANEOUS_TYPES = exports.MISCELLANEOUS_TYPES = _index.FLIPPED_ALIAS_KEYS[\"Miscellaneous\"];\nconst TYPESCRIPT_TYPES = exports.TYPESCRIPT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"TypeScript\"];\nconst TSTYPEELEMENT_TYPES = exports.TSTYPEELEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS[\"TSTypeElement\"];\nconst TSTYPE_TYPES = exports.TSTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"TSType\"];\nconst TSBASETYPE_TYPES = exports.TSBASETYPE_TYPES = _index.FLIPPED_ALIAS_KEYS[\"TSBaseType\"];\nconst MODULEDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;\n\n//# sourceMappingURL=index.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = ensureBlock;\nvar _toBlock = require(\"./toBlock.js\");\nfunction ensureBlock(node, key = \"body\") {\n const result = (0, _toBlock.default)(node[key], node);\n node[key] = result;\n return result;\n}\n\n//# sourceMappingURL=ensureBlock.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toBlock;\nvar _index = require(\"../validators/generated/index.js\");\nvar _index2 = require(\"../builders/generated/index.js\");\nfunction toBlock(node, parent) {\n if ((0, _index.isBlockStatement)(node)) {\n return node;\n }\n let blockNodes = [];\n if ((0, _index.isEmptyStatement)(node)) {\n blockNodes = [];\n } else {\n if (!(0, _index.isStatement)(node)) {\n if ((0, _index.isFunction)(parent)) {\n node = (0, _index2.returnStatement)(node);\n } else {\n node = (0, _index2.expressionStatement)(node);\n }\n }\n blockNodes = [node];\n }\n return (0, _index2.blockStatement)(blockNodes);\n}\n\n//# sourceMappingURL=toBlock.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toBindingIdentifierName;\nvar _toIdentifier = require(\"./toIdentifier.js\");\nfunction toBindingIdentifierName(name) {\n name = (0, _toIdentifier.default)(name);\n if (name === \"eval\" || name === \"arguments\") name = \"_\" + name;\n return name;\n}\n\n//# sourceMappingURL=toBindingIdentifierName.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toIdentifier;\nvar _isValidIdentifier = require(\"../validators/isValidIdentifier.js\");\nvar _helperValidatorIdentifier = require(\"@babel/helper-validator-identifier\");\nfunction toIdentifier(input) {\n input = input + \"\";\n let name = \"\";\n for (const c of input) {\n name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : \"-\";\n }\n name = name.replace(/^[-0-9]+/, \"\");\n name = name.replace(/[-\\s]+(.)?/g, function (match, c) {\n return c ? c.toUpperCase() : \"\";\n });\n if (!(0, _isValidIdentifier.default)(name)) {\n name = `_${name}`;\n }\n return name || \"_\";\n}\n\n//# sourceMappingURL=toIdentifier.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toComputedKey;\nvar _index = require(\"../validators/generated/index.js\");\nvar _index2 = require(\"../builders/generated/index.js\");\nfunction toComputedKey(node, key = node.key || node.property) {\n if (!node.computed && (0, _index.isIdentifier)(key)) key = (0, _index2.stringLiteral)(key.name);\n return key;\n}\n\n//# sourceMappingURL=toComputedKey.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _index = require(\"../validators/generated/index.js\");\nvar _default = exports.default = toExpression;\nfunction toExpression(node) {\n if ((0, _index.isExpressionStatement)(node)) {\n node = node.expression;\n }\n if ((0, _index.isExpression)(node)) {\n return node;\n }\n if ((0, _index.isClass)(node)) {\n node.type = \"ClassExpression\";\n node.abstract = false;\n } else if ((0, _index.isFunction)(node)) {\n node.type = \"FunctionExpression\";\n }\n if (!(0, _index.isExpression)(node)) {\n throw new Error(`cannot turn ${node.type} to an expression`);\n }\n return node;\n}\n\n//# sourceMappingURL=toExpression.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toKeyAlias;\nvar _index = require(\"../validators/generated/index.js\");\nvar _cloneNode = require(\"../clone/cloneNode.js\");\nvar _removePropertiesDeep = require(\"../modifications/removePropertiesDeep.js\");\nfunction toKeyAlias(node, key = node.key) {\n let alias;\n if (node.kind === \"method\") {\n return toKeyAlias.increment() + \"\";\n } else if ((0, _index.isIdentifier)(key)) {\n alias = key.name;\n } else if ((0, _index.isStringLiteral)(key)) {\n alias = JSON.stringify(key.value);\n } else {\n alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));\n }\n if (node.computed) {\n alias = `[${alias}]`;\n }\n if (node.static) {\n alias = `static:${alias}`;\n }\n return alias;\n}\ntoKeyAlias.uid = 0;\ntoKeyAlias.increment = function () {\n if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {\n return toKeyAlias.uid = 0;\n } else {\n return toKeyAlias.uid++;\n }\n};\n\n//# sourceMappingURL=toKeyAlias.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = removePropertiesDeep;\nvar _traverseFast = require(\"../traverse/traverseFast.js\");\nvar _removeProperties = require(\"./removeProperties.js\");\nfunction removePropertiesDeep(tree, opts) {\n (0, _traverseFast.default)(tree, _removeProperties.default, opts);\n return tree;\n}\n\n//# sourceMappingURL=removePropertiesDeep.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = traverseFast;\nvar _index = require(\"../definitions/index.js\");\nconst _skip = Symbol();\nconst _stop = Symbol();\nfunction traverseFast(node, enter, opts) {\n if (!node) return false;\n const keys = _index.VISITOR_KEYS[node.type];\n if (!keys) return false;\n opts = opts || {};\n const ret = enter(node, opts);\n if (ret !== undefined) {\n switch (ret) {\n case _skip:\n return false;\n case _stop:\n return true;\n }\n }\n for (const key of keys) {\n const subNode = node[key];\n if (!subNode) continue;\n if (Array.isArray(subNode)) {\n for (const node of subNode) {\n if (traverseFast(node, enter, opts)) return true;\n }\n } else {\n if (traverseFast(subNode, enter, opts)) return true;\n }\n }\n return false;\n}\ntraverseFast.skip = _skip;\ntraverseFast.stop = _stop;\n\n//# sourceMappingURL=traverseFast.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = removeProperties;\nvar _index = require(\"../constants/index.js\");\nconst CLEAR_KEYS = [\"tokens\", \"start\", \"end\", \"loc\", \"raw\", \"rawValue\"];\nconst CLEAR_KEYS_PLUS_COMMENTS = [..._index.COMMENT_KEYS, \"comments\", ...CLEAR_KEYS];\nfunction removeProperties(node, opts = {}) {\n const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;\n for (const key of map) {\n if (node[key] != null) node[key] = undefined;\n }\n for (const key of Object.keys(node)) {\n if (key.startsWith(\"_\") && node[key] != null) node[key] = undefined;\n }\n const symbols = Object.getOwnPropertySymbols(node);\n for (const sym of symbols) {\n node[sym] = null;\n }\n}\n\n//# sourceMappingURL=removeProperties.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _index = require(\"../validators/generated/index.js\");\nvar _index2 = require(\"../builders/generated/index.js\");\nvar _default = exports.default = toStatement;\nfunction toStatement(node, ignore) {\n if ((0, _index.isStatement)(node)) {\n return node;\n }\n let mustHaveId = false;\n let newType;\n if ((0, _index.isClass)(node)) {\n mustHaveId = true;\n newType = \"ClassDeclaration\";\n } else if ((0, _index.isFunction)(node)) {\n mustHaveId = true;\n newType = \"FunctionDeclaration\";\n } else if ((0, _index.isAssignmentExpression)(node)) {\n return (0, _index2.expressionStatement)(node);\n }\n if (mustHaveId && !node.id) {\n newType = false;\n }\n if (!newType) {\n if (ignore) {\n return false;\n } else {\n throw new Error(`cannot turn ${node.type} to a statement`);\n }\n }\n node.type = newType;\n return node;\n}\n\n//# sourceMappingURL=toStatement.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _isValidIdentifier = require(\"../validators/isValidIdentifier.js\");\nvar _index = require(\"../builders/generated/index.js\");\nvar _default = exports.default = valueToNode;\nconst objectToString = Function.call.bind(Object.prototype.toString);\nfunction isRegExp(value) {\n return objectToString(value) === \"[object RegExp]\";\n}\nfunction isPlainObject(value) {\n if (typeof value !== \"object\" || value === null || Object.prototype.toString.call(value) !== \"[object Object]\") {\n return false;\n }\n const proto = Object.getPrototypeOf(value);\n return proto === null || Object.getPrototypeOf(proto) === null;\n}\nfunction valueToNode(value) {\n if (value === undefined) {\n return (0, _index.identifier)(\"undefined\");\n }\n if (value === true || value === false) {\n return (0, _index.booleanLiteral)(value);\n }\n if (value === null) {\n return (0, _index.nullLiteral)();\n }\n if (typeof value === \"string\") {\n return (0, _index.stringLiteral)(value);\n }\n if (typeof value === \"number\") {\n let result;\n if (Number.isFinite(value)) {\n result = (0, _index.numericLiteral)(Math.abs(value));\n } else {\n let numerator;\n if (Number.isNaN(value)) {\n numerator = (0, _index.numericLiteral)(0);\n } else {\n numerator = (0, _index.numericLiteral)(1);\n }\n result = (0, _index.binaryExpression)(\"/\", numerator, (0, _index.numericLiteral)(0));\n }\n if (value < 0 || Object.is(value, -0)) {\n result = (0, _index.unaryExpression)(\"-\", result);\n }\n return result;\n }\n if (typeof value === \"bigint\") {\n if (value < 0) {\n return (0, _index.unaryExpression)(\"-\", (0, _index.bigIntLiteral)(-value));\n } else {\n return (0, _index.bigIntLiteral)(value);\n }\n }\n if (isRegExp(value)) {\n const pattern = value.source;\n const flags = /\\/([a-z]*)$/.exec(value.toString())[1];\n return (0, _index.regExpLiteral)(pattern, flags);\n }\n if (Array.isArray(value)) {\n return (0, _index.arrayExpression)(value.map(valueToNode));\n }\n if (isPlainObject(value)) {\n const props = [];\n for (const key of Object.keys(value)) {\n let nodeKey,\n computed = false;\n if ((0, _isValidIdentifier.default)(key)) {\n if (key === \"__proto__\") {\n computed = true;\n nodeKey = (0, _index.stringLiteral)(key);\n } else {\n nodeKey = (0, _index.identifier)(key);\n }\n } else {\n nodeKey = (0, _index.stringLiteral)(key);\n }\n props.push((0, _index.objectProperty)(nodeKey, valueToNode(value[key]), computed));\n }\n return (0, _index.objectExpression)(props);\n }\n throw new Error(\"don't know how to turn this value into a node\");\n}\n\n//# sourceMappingURL=valueToNode.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = appendToMemberExpression;\nvar _index = require(\"../builders/generated/index.js\");\nfunction appendToMemberExpression(member, append, computed = false) {\n member.object = (0, _index.memberExpression)(member.object, member.property, member.computed);\n member.property = append;\n member.computed = !!computed;\n return member;\n}\n\n//# sourceMappingURL=appendToMemberExpression.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = inherits;\nvar _index = require(\"../constants/index.js\");\nvar _inheritsComments = require(\"../comments/inheritsComments.js\");\nfunction inherits(child, parent) {\n if (!child || !parent) return child;\n for (const key of _index.INHERIT_KEYS.optional) {\n if (child[key] == null) {\n child[key] = parent[key];\n }\n }\n for (const key of Object.keys(parent)) {\n if (key.startsWith(\"_\") && key !== \"__clone\") {\n child[key] = parent[key];\n }\n }\n for (const key of _index.INHERIT_KEYS.force) {\n child[key] = parent[key];\n }\n (0, _inheritsComments.default)(child, parent);\n return child;\n}\n\n//# sourceMappingURL=inherits.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = prependToMemberExpression;\nvar _index = require(\"../builders/generated/index.js\");\nvar _index2 = require(\"../index.js\");\nfunction prependToMemberExpression(member, prepend) {\n if ((0, _index2.isSuper)(member.object)) {\n throw new Error(\"Cannot prepend node to super property access (`super.foo`).\");\n }\n member.object = (0, _index.memberExpression)(prepend, member.object);\n return member;\n}\n\n//# sourceMappingURL=prependToMemberExpression.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = getAssignmentIdentifiers;\nfunction getAssignmentIdentifiers(node) {\n const search = [].concat(node);\n const ids = Object.create(null);\n while (search.length) {\n const id = search.pop();\n if (!id) continue;\n switch (id.type) {\n case \"ArrayPattern\":\n search.push(...id.elements);\n break;\n case \"AssignmentExpression\":\n case \"AssignmentPattern\":\n case \"ForInStatement\":\n case \"ForOfStatement\":\n search.push(id.left);\n break;\n case \"ObjectPattern\":\n search.push(...id.properties);\n break;\n case \"ObjectProperty\":\n search.push(id.value);\n break;\n case \"RestElement\":\n case \"UpdateExpression\":\n search.push(id.argument);\n break;\n case \"UnaryExpression\":\n if (id.operator === \"delete\") {\n search.push(id.argument);\n }\n break;\n case \"Identifier\":\n ids[id.name] = id;\n break;\n default:\n break;\n }\n }\n return ids;\n}\n\n//# sourceMappingURL=getAssignmentIdentifiers.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = getBindingIdentifiers;\nvar _index = require(\"../validators/generated/index.js\");\nfunction getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {\n const search = [].concat(node);\n const ids = Object.create(null);\n while (search.length) {\n const id = search.shift();\n if (!id) continue;\n if (newBindingsOnly && ((0, _index.isAssignmentExpression)(id) || (0, _index.isUnaryExpression)(id) || (0, _index.isUpdateExpression)(id))) {\n continue;\n }\n if ((0, _index.isIdentifier)(id)) {\n if (duplicates) {\n const _ids = ids[id.name] = ids[id.name] || [];\n _ids.push(id);\n } else {\n ids[id.name] = id;\n }\n continue;\n }\n if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) {\n if ((0, _index.isDeclaration)(id.declaration)) {\n search.push(id.declaration);\n }\n continue;\n }\n if (outerOnly) {\n if ((0, _index.isFunctionDeclaration)(id)) {\n search.push(id.id);\n continue;\n }\n if ((0, _index.isFunctionExpression)(id)) {\n continue;\n }\n }\n const keys = getBindingIdentifiers.keys[id.type];\n if (keys) {\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const nodes = id[key];\n if (nodes) {\n if (Array.isArray(nodes)) {\n search.push(...nodes);\n } else {\n search.push(nodes);\n }\n }\n }\n }\n }\n return ids;\n}\nconst keys = {\n DeclareClass: [\"id\"],\n DeclareFunction: [\"id\"],\n DeclareModule: [\"id\"],\n DeclareVariable: [\"id\"],\n DeclareInterface: [\"id\"],\n DeclareTypeAlias: [\"id\"],\n DeclareOpaqueType: [\"id\"],\n InterfaceDeclaration: [\"id\"],\n TypeAlias: [\"id\"],\n OpaqueType: [\"id\"],\n CatchClause: [\"param\"],\n LabeledStatement: [\"label\"],\n UnaryExpression: [\"argument\"],\n AssignmentExpression: [\"left\"],\n ImportSpecifier: [\"local\"],\n ImportNamespaceSpecifier: [\"local\"],\n ImportDefaultSpecifier: [\"local\"],\n ImportDeclaration: [\"specifiers\"],\n TSImportEqualsDeclaration: [\"id\"],\n ExportSpecifier: [\"exported\"],\n ExportNamespaceSpecifier: [\"exported\"],\n ExportDefaultSpecifier: [\"exported\"],\n FunctionDeclaration: [\"id\", \"params\"],\n FunctionExpression: [\"id\", \"params\"],\n ArrowFunctionExpression: [\"params\"],\n ObjectMethod: [\"params\"],\n ClassMethod: [\"params\"],\n ClassPrivateMethod: [\"params\"],\n ForInStatement: [\"left\"],\n ForOfStatement: [\"left\"],\n ClassDeclaration: [\"id\"],\n ClassExpression: [\"id\"],\n RestElement: [\"argument\"],\n UpdateExpression: [\"argument\"],\n ObjectProperty: [\"value\"],\n AssignmentPattern: [\"left\"],\n ArrayPattern: [\"elements\"],\n ObjectPattern: [\"properties\"],\n VariableDeclaration: [\"declarations\"],\n VariableDeclarator: [\"id\"]\n};\ngetBindingIdentifiers.keys = keys;\n\n//# sourceMappingURL=getBindingIdentifiers.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\nvar _getBindingIdentifiers = require(\"./getBindingIdentifiers.js\");\nvar _default = exports.default = getOuterBindingIdentifiers;\nfunction getOuterBindingIdentifiers(node, duplicates) {\n return (0, _getBindingIdentifiers.default)(node, duplicates, true);\n}\n\n//# sourceMappingURL=getOuterBindingIdentifiers.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = getFunctionName;\nvar _index = require(\"../validators/generated/index.js\");\nfunction getNameFromLiteralId(id) {\n if ((0, _index.isNullLiteral)(id)) {\n return \"null\";\n }\n if ((0, _index.isRegExpLiteral)(id)) {\n return `/${id.pattern}/${id.flags}`;\n }\n if ((0, _index.isTemplateLiteral)(id)) {\n return id.quasis.map(quasi => quasi.value.raw).join(\"\");\n }\n if (id.value !== undefined) {\n return String(id.value);\n }\n return null;\n}\nfunction getObjectMemberKey(node) {\n if (!node.computed || (0, _index.isLiteral)(node.key)) {\n return node.key;\n }\n}\nfunction getFunctionName(node, parent) {\n if (\"id\" in node && node.id) {\n return {\n name: node.id.name,\n originalNode: node.id\n };\n }\n let prefix = \"\";\n let id;\n if ((0, _index.isObjectProperty)(parent, {\n value: node\n })) {\n id = getObjectMemberKey(parent);\n } else if ((0, _index.isObjectMethod)(node) || (0, _index.isClassMethod)(node)) {\n id = getObjectMemberKey(node);\n if (node.kind === \"get\") prefix = \"get \";else if (node.kind === \"set\") prefix = \"set \";\n } else if ((0, _index.isVariableDeclarator)(parent, {\n init: node\n })) {\n id = parent.id;\n } else if ((0, _index.isAssignmentExpression)(parent, {\n operator: \"=\",\n right: node\n })) {\n id = parent.left;\n }\n if (!id) return null;\n const name = (0, _index.isLiteral)(id) ? getNameFromLiteralId(id) : (0, _index.isIdentifier)(id) ? id.name : (0, _index.isPrivateName)(id) ? id.id.name : null;\n if (name == null) return null;\n return {\n name: prefix + name,\n originalNode: id\n };\n}\n\n//# sourceMappingURL=getFunctionName.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = traverse;\nvar _index = require(\"../definitions/index.js\");\nfunction traverse(node, handlers, state) {\n if (typeof handlers === \"function\") {\n handlers = {\n enter: handlers\n };\n }\n const {\n enter,\n exit\n } = handlers;\n traverseSimpleImpl(node, enter, exit, state, []);\n}\nfunction traverseSimpleImpl(node, enter, exit, state, ancestors) {\n const keys = _index.VISITOR_KEYS[node.type];\n if (!keys) return;\n if (enter) enter(node, ancestors, state);\n for (const key of keys) {\n const subNode = node[key];\n if (Array.isArray(subNode)) {\n for (let i = 0; i < subNode.length; i++) {\n const child = subNode[i];\n if (!child) continue;\n ancestors.push({\n node,\n key,\n index: i\n });\n traverseSimpleImpl(child, enter, exit, state, ancestors);\n ancestors.pop();\n }\n } else if (subNode) {\n ancestors.push({\n node,\n key\n });\n traverseSimpleImpl(subNode, enter, exit, state, ancestors);\n ancestors.pop();\n }\n }\n if (exit) exit(node, ancestors, state);\n}\n\n//# sourceMappingURL=traverse.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isBinding;\nvar _getBindingIdentifiers = require(\"../retrievers/getBindingIdentifiers.js\");\nfunction isBinding(node, parent, grandparent) {\n if (grandparent && node.type === \"Identifier\" && parent.type === \"ObjectProperty\" && grandparent.type === \"ObjectExpression\") {\n return false;\n }\n const keys = _getBindingIdentifiers.default.keys[parent.type];\n if (keys) {\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const val = parent[key];\n if (Array.isArray(val)) {\n if (val.includes(node)) return true;\n } else {\n if (val === node) return true;\n }\n }\n }\n return false;\n}\n\n//# sourceMappingURL=isBinding.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isBlockScoped;\nvar _index = require(\"./generated/index.js\");\nvar _isLet = require(\"./isLet.js\");\nfunction isBlockScoped(node) {\n return (0, _index.isFunctionDeclaration)(node) || (0, _index.isClassDeclaration)(node) || (0, _isLet.default)(node);\n}\n\n//# sourceMappingURL=isBlockScoped.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isLet;\nvar _index = require(\"./generated/index.js\");\nvar BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\nfunction isLet(node) {\n return (0, _index.isVariableDeclaration)(node) && (node.kind !== \"var\" || node[BLOCK_SCOPED_SYMBOL]);\n}\n\n//# sourceMappingURL=isLet.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isImmutable;\nvar _isType = require(\"./isType.js\");\nvar _index = require(\"./generated/index.js\");\nfunction isImmutable(node) {\n if ((0, _isType.default)(node.type, \"Immutable\")) return true;\n if ((0, _index.isIdentifier)(node)) {\n if (node.name === \"undefined\") {\n return true;\n } else {\n return false;\n }\n }\n return false;\n}\n\n//# sourceMappingURL=isImmutable.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isNodesEquivalent;\nvar _index = require(\"../definitions/index.js\");\nfunction isNodesEquivalent(a, b) {\n if (typeof a !== \"object\" || typeof b !== \"object\" || a == null || b == null) {\n return a === b;\n }\n if (a.type !== b.type) {\n return false;\n }\n const fields = Object.keys(_index.NODE_FIELDS[a.type] || a.type);\n const visitorKeys = _index.VISITOR_KEYS[a.type];\n for (const field of fields) {\n const val_a = a[field];\n const val_b = b[field];\n if (typeof val_a !== typeof val_b) {\n return false;\n }\n if (val_a == null && val_b == null) {\n continue;\n } else if (val_a == null || val_b == null) {\n return false;\n }\n if (Array.isArray(val_a)) {\n if (!Array.isArray(val_b)) {\n return false;\n }\n if (val_a.length !== val_b.length) {\n return false;\n }\n for (let i = 0; i < val_a.length; i++) {\n if (!isNodesEquivalent(val_a[i], val_b[i])) {\n return false;\n }\n }\n continue;\n }\n if (typeof val_a === \"object\" && !(visitorKeys != null && visitorKeys.includes(field))) {\n for (const key of Object.keys(val_a)) {\n if (val_a[key] !== val_b[key]) {\n return false;\n }\n }\n continue;\n }\n if (!isNodesEquivalent(val_a, val_b)) {\n return false;\n }\n }\n return true;\n}\n\n//# sourceMappingURL=isNodesEquivalent.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isReferenced;\nfunction isReferenced(node, parent, grandparent) {\n switch (parent.type) {\n case \"MemberExpression\":\n case \"OptionalMemberExpression\":\n if (parent.property === node) {\n return !!parent.computed;\n }\n return parent.object === node;\n case \"JSXMemberExpression\":\n return parent.object === node;\n case \"VariableDeclarator\":\n return parent.init === node;\n case \"ArrowFunctionExpression\":\n return parent.body === node;\n case \"PrivateName\":\n return false;\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"ObjectMethod\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return false;\n case \"ObjectProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return (grandparent == null ? void 0 : grandparent.type) !== \"ObjectPattern\";\n case \"ClassProperty\":\n case \"ClassAccessorProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n case \"ClassPrivateProperty\":\n return parent.key !== node;\n case \"ClassDeclaration\":\n case \"ClassExpression\":\n return parent.superClass === node;\n case \"AssignmentExpression\":\n return parent.right === node;\n case \"AssignmentPattern\":\n return parent.right === node;\n case \"LabeledStatement\":\n return false;\n case \"CatchClause\":\n return false;\n case \"RestElement\":\n return false;\n case \"BreakStatement\":\n case \"ContinueStatement\":\n return false;\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n return false;\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n return false;\n case \"ExportSpecifier\":\n if (grandparent != null && grandparent.source) {\n return false;\n }\n return parent.local === node;\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n return false;\n case \"ImportAttribute\":\n return false;\n case \"JSXAttribute\":\n return false;\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n return false;\n case \"MetaProperty\":\n return false;\n case \"ObjectTypeProperty\":\n return parent.key !== node;\n case \"TSEnumMember\":\n return parent.id !== node;\n case \"TSPropertySignature\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n }\n return true;\n}\n\n//# sourceMappingURL=isReferenced.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isScope;\nvar _index = require(\"./generated/index.js\");\nfunction isScope(node, parent) {\n if ((0, _index.isBlockStatement)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) {\n return false;\n }\n if ((0, _index.isPattern)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) {\n return true;\n }\n return (0, _index.isScopable)(node);\n}\n\n//# sourceMappingURL=isScope.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isSpecifierDefault;\nvar _index = require(\"./generated/index.js\");\nfunction isSpecifierDefault(specifier) {\n return (0, _index.isImportDefaultSpecifier)(specifier) || (0, _index.isIdentifier)(specifier.imported || specifier.exported, {\n name: \"default\"\n });\n}\n\n//# sourceMappingURL=isSpecifierDefault.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isValidES3Identifier;\nvar _isValidIdentifier = require(\"./isValidIdentifier.js\");\nconst RESERVED_WORDS_ES3_ONLY = new Set([\"abstract\", \"boolean\", \"byte\", \"char\", \"double\", \"enum\", \"final\", \"float\", \"goto\", \"implements\", \"int\", \"interface\", \"long\", \"native\", \"package\", \"private\", \"protected\", \"public\", \"short\", \"static\", \"synchronized\", \"throws\", \"transient\", \"volatile\"]);\nfunction isValidES3Identifier(name) {\n return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);\n}\n\n//# sourceMappingURL=isValidES3Identifier.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = isVar;\nvar _index = require(\"./generated/index.js\");\nvar BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\nfunction isVar(node) {\n return (0, _index.isVariableDeclaration)(node, {\n kind: \"var\"\n }) && !node[BLOCK_SCOPED_SYMBOL];\n}\n\n//# sourceMappingURL=isVar.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = toSequenceExpression;\nvar _gatherSequenceExpressions = require(\"./gatherSequenceExpressions.js\");\nfunction toSequenceExpression(nodes, scope) {\n if (!(nodes != null && nodes.length)) return;\n const declars = [];\n const result = (0, _gatherSequenceExpressions.default)(nodes, declars);\n if (!result) return;\n for (const declar of declars) {\n scope.push(declar);\n }\n return result;\n}\n\n//# sourceMappingURL=toSequenceExpression.js.map\n","\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = gatherSequenceExpressions;\nvar _getBindingIdentifiers = require(\"../retrievers/getBindingIdentifiers.js\");\nvar _index = require(\"../validators/generated/index.js\");\nvar _index2 = require(\"../builders/generated/index.js\");\nvar _productions = require(\"../builders/productions.js\");\nvar _cloneNode = require(\"../clone/cloneNode.js\");\nfunction gatherSequenceExpressions(nodes, declars) {\n const exprs = [];\n let ensureLastUndefined = true;\n for (const node of nodes) {\n if (!(0, _index.isEmptyStatement)(node)) {\n ensureLastUndefined = false;\n }\n if ((0, _index.isExpression)(node)) {\n exprs.push(node);\n } else if ((0, _index.isExpressionStatement)(node)) {\n exprs.push(node.expression);\n } else if ((0, _index.isVariableDeclaration)(node)) {\n if (node.kind !== \"var\") return;\n for (const declar of node.declarations) {\n const bindings = (0, _getBindingIdentifiers.default)(declar);\n for (const key of Object.keys(bindings)) {\n declars.push({\n kind: node.kind,\n id: (0, _cloneNode.default)(bindings[key])\n });\n }\n if (declar.init) {\n exprs.push((0, _index2.assignmentExpression)(\"=\", declar.id, declar.init));\n }\n }\n ensureLastUndefined = true;\n } else if ((0, _index.isIfStatement)(node)) {\n const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : (0, _productions.buildUndefinedNode)();\n const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : (0, _productions.buildUndefinedNode)();\n if (!consequent || !alternate) return;\n exprs.push((0, _index2.conditionalExpression)(node.test, consequent, alternate));\n } else if ((0, _index.isBlockStatement)(node)) {\n const body = gatherSequenceExpressions(node.body, declars);\n if (!body) return;\n exprs.push(body);\n } else if ((0, _index.isEmptyStatement)(node)) {\n if (nodes.indexOf(node) === 0) {\n ensureLastUndefined = true;\n }\n } else {\n return;\n }\n }\n if (ensureLastUndefined) {\n exprs.push((0, _productions.buildUndefinedNode)());\n }\n if (exprs.length === 1) {\n return exprs[0];\n } else {\n return (0, _index2.sequenceExpression)(exprs);\n }\n}\n\n//# sourceMappingURL=gatherSequenceExpressions.js.map\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js b/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js new file mode 100644 index 0000000..5d4664a --- /dev/null +++ b/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js @@ -0,0 +1,477 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509103, function(require, module, exports) { +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.sourcemapCodec = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module) { + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/sourcemap-codec.ts +var sourcemap_codec_exports = {}; +__export(sourcemap_codec_exports, { + decode: () => decode, + decodeGeneratedRanges: () => decodeGeneratedRanges, + decodeOriginalScopes: () => decodeOriginalScopes, + encode: () => encode, + encodeGeneratedRanges: () => encodeGeneratedRanges, + encodeOriginalScopes: () => encodeOriginalScopes +}); +module.exports = __toCommonJS(sourcemap_codec_exports); + +// src/vlq.ts +var comma = ",".charCodeAt(0); +var semicolon = ";".charCodeAt(0); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +function decodeInteger(reader, relative) { + let value = 0; + let shift = 0; + let integer = 0; + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + const shouldNegate = value & 1; + value >>>= 1; + if (shouldNegate) { + value = -2147483648 | -value; + } + return relative + value; +} +function encodeInteger(builder, num, relative) { + let delta = num - relative; + delta = delta < 0 ? -delta << 1 | 1 : delta << 1; + do { + let clamped = delta & 31; + delta >>>= 5; + if (delta > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (delta > 0); + return num; +} +function hasMoreVlq(reader, max) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} + +// src/strings.ts +var bufLength = 1024 * 16; +var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } +} : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } +}; +var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +}; +var StringReader = class { + constructor(buffer) { + this.pos = 0; + this.buffer = buffer; + } + next() { + return this.buffer.charCodeAt(this.pos++); + } + peek() { + return this.buffer.charCodeAt(this.pos); + } + indexOf(char) { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +}; + +// src/scopes.ts +var EMPTY = []; +function decodeOriginalScopes(input) { + const { length } = input; + const reader = new StringReader(input); + const scopes = []; + const stack = []; + let line = 0; + for (; reader.pos < length; reader.pos++) { + line = decodeInteger(reader, line); + const column = decodeInteger(reader, 0); + if (!hasMoreVlq(reader, length)) { + const last = stack.pop(); + last[2] = line; + last[3] = column; + continue; + } + const kind = decodeInteger(reader, 0); + const fields = decodeInteger(reader, 0); + const hasName = fields & 1; + const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]; + let vars = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeInteger(reader, 0); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + scopes.push(scope); + stack.push(scope); + } + return scopes; +} +function encodeOriginalScopes(scopes) { + const writer = new StringWriter(); + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + return writer.flush(); +} +function _encodeOriginalScopes(scopes, index, writer, state) { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + if (index > 0) writer.write(comma); + state[0] = encodeInteger(writer, startLine, state[0]); + encodeInteger(writer, startColumn, 0); + encodeInteger(writer, kind, 0); + const fields = scope.length === 6 ? 1 : 0; + encodeInteger(writer, fields, 0); + if (scope.length === 6) encodeInteger(writer, scope[5], 0); + for (const v of vars) { + encodeInteger(writer, v, 0); + } + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + writer.write(comma); + state[0] = encodeInteger(writer, endLine, state[0]); + encodeInteger(writer, endColumn, 0); + return index; +} +function decodeGeneratedRanges(input) { + const { length } = input; + const reader = new StringReader(input); + const ranges = []; + const stack = []; + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + do { + const semi = reader.indexOf(";"); + let genColumn = 0; + for (; reader.pos < semi; reader.pos++) { + genColumn = decodeInteger(reader, genColumn); + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop(); + last[2] = genLine; + last[3] = genColumn; + continue; + } + const fields = decodeInteger(reader, 0); + const hasDefinition = fields & 1; + const hasCallsite = fields & 2; + const hasScope = fields & 4; + let callsite = null; + let bindings = EMPTY; + let range; + if (hasDefinition) { + const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex); + definitionScopeIndex = decodeInteger( + reader, + definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0 + ); + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex]; + } else { + range = [genLine, genColumn, 0, 0]; + } + range.isScope = !!hasScope; + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0); + callsiteColumn = decodeInteger( + reader, + sameSource && prevLine === callsiteLine ? callsiteColumn : 0 + ); + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeInteger(reader, 0); + let expressionRanges; + if (expressionsCount < -1) { + expressionRanges = [[decodeInteger(reader, 0)]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine = decodeInteger(reader, bindingLine); + bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0); + const expression = decodeInteger(reader, 0); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + ranges.push(range); + stack.push(range); + } + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + return ranges; +} +function encodeGeneratedRanges(ranges) { + if (ranges.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + return writer.flush(); +} +function _encodeGeneratedRanges(ranges, index, writer, state) { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings + } = range; + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + state[1] = encodeInteger(writer, range[1], state[1]); + const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0); + encodeInteger(writer, fields, 0); + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + state[2] = encodeInteger(writer, sourcesIndex, state[2]); + state[3] = encodeInteger(writer, scopesIndex, state[3]); + } + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + state[4] = encodeInteger(writer, sourcesIndex, state[4]); + state[5] = encodeInteger(writer, callLine, state[5]); + state[6] = encodeInteger(writer, callColumn, state[6]); + } + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, -binding.length, 0); + const expression = binding[0][0]; + encodeInteger(writer, expression, 0); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine); + bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn); + encodeInteger(writer, expRange[0], 0); + } + } + } + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + state[1] = encodeInteger(writer, endColumn, state[1]); + return index; +} +function catchupLine(writer, lastLine, line) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} + +// src/sourcemap-codec.ts +function decode(mappings) { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + do { + const semi = reader.indexOf(";"); + const line = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + while (reader.pos < semi) { + let seg; + genColumn = decodeInteger(reader, genColumn); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + if (hasMoreVlq(reader, semi)) { + sourcesIndex = decodeInteger(reader, sourcesIndex); + sourceLine = decodeInteger(reader, sourceLine); + sourceColumn = decodeInteger(reader, sourceColumn); + if (hasMoreVlq(reader, semi)) { + namesIndex = decodeInteger(reader, namesIndex); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + line.push(seg); + reader.pos++; + } + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + return decoded; +} +function sort(line) { + line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[0] - b[0]; +} +function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + genColumn = encodeInteger(writer, segment[0], genColumn); + if (segment.length === 1) continue; + sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex); + sourceLine = encodeInteger(writer, segment[2], sourceLine); + sourceColumn = encodeInteger(writer, segment[3], sourceColumn); + if (segment.length === 4) continue; + namesIndex = encodeInteger(writer, segment[4], namesIndex); + } + } + return writer.flush(); +} +})); +//# sourceMappingURL=sourcemap-codec.umd.js.map + +}, function(modId) {var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509103); +})() +//miniprogram-npm-outsideDeps=[] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js.map b/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js.map new file mode 100644 index 0000000..94c1396 --- /dev/null +++ b/miniapp/miniprogram_npm/@jridgewell/sourcemap-codec/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["sourcemap-codec.umd.js"],"names":[],"mappings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file":"index.js","sourcesContent":["(function (global, factory) {\n if (typeof exports === 'object' && typeof module !== 'undefined') {\n factory(module);\n module.exports = def(module);\n } else if (typeof define === 'function' && define.amd) {\n define(['module'], function(mod) {\n factory.apply(this, arguments);\n mod.exports = def(mod);\n });\n } else {\n const mod = { exports: {} };\n factory(mod);\n global = typeof globalThis !== 'undefined' ? globalThis : global || self;\n global.sourcemapCodec = def(mod);\n }\n function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; }\n})(this, (function (module) {\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n if (from && typeof from === \"object\" || typeof from === \"function\") {\n for (let key of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key) && key !== except)\n __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n }\n return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/sourcemap-codec.ts\nvar sourcemap_codec_exports = {};\n__export(sourcemap_codec_exports, {\n decode: () => decode,\n decodeGeneratedRanges: () => decodeGeneratedRanges,\n decodeOriginalScopes: () => decodeOriginalScopes,\n encode: () => encode,\n encodeGeneratedRanges: () => encodeGeneratedRanges,\n encodeOriginalScopes: () => encodeOriginalScopes\n});\nmodule.exports = __toCommonJS(sourcemap_codec_exports);\n\n// src/vlq.ts\nvar comma = \",\".charCodeAt(0);\nvar semicolon = \";\".charCodeAt(0);\nvar chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nvar intToChar = new Uint8Array(64);\nvar charToInt = new Uint8Array(128);\nfor (let i = 0; i < chars.length; i++) {\n const c = chars.charCodeAt(i);\n intToChar[i] = c;\n charToInt[c] = i;\n}\nfunction decodeInteger(reader, relative) {\n let value = 0;\n let shift = 0;\n let integer = 0;\n do {\n const c = reader.next();\n integer = charToInt[c];\n value |= (integer & 31) << shift;\n shift += 5;\n } while (integer & 32);\n const shouldNegate = value & 1;\n value >>>= 1;\n if (shouldNegate) {\n value = -2147483648 | -value;\n }\n return relative + value;\n}\nfunction encodeInteger(builder, num, relative) {\n let delta = num - relative;\n delta = delta < 0 ? -delta << 1 | 1 : delta << 1;\n do {\n let clamped = delta & 31;\n delta >>>= 5;\n if (delta > 0) clamped |= 32;\n builder.write(intToChar[clamped]);\n } while (delta > 0);\n return num;\n}\nfunction hasMoreVlq(reader, max) {\n if (reader.pos >= max) return false;\n return reader.peek() !== comma;\n}\n\n// src/strings.ts\nvar bufLength = 1024 * 16;\nvar td = typeof TextDecoder !== \"undefined\" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== \"undefined\" ? {\n decode(buf) {\n const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);\n return out.toString();\n }\n} : {\n decode(buf) {\n let out = \"\";\n for (let i = 0; i < buf.length; i++) {\n out += String.fromCharCode(buf[i]);\n }\n return out;\n }\n};\nvar StringWriter = class {\n constructor() {\n this.pos = 0;\n this.out = \"\";\n this.buffer = new Uint8Array(bufLength);\n }\n write(v) {\n const { buffer } = this;\n buffer[this.pos++] = v;\n if (this.pos === bufLength) {\n this.out += td.decode(buffer);\n this.pos = 0;\n }\n }\n flush() {\n const { buffer, out, pos } = this;\n return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;\n }\n};\nvar StringReader = class {\n constructor(buffer) {\n this.pos = 0;\n this.buffer = buffer;\n }\n next() {\n return this.buffer.charCodeAt(this.pos++);\n }\n peek() {\n return this.buffer.charCodeAt(this.pos);\n }\n indexOf(char) {\n const { buffer, pos } = this;\n const idx = buffer.indexOf(char, pos);\n return idx === -1 ? buffer.length : idx;\n }\n};\n\n// src/scopes.ts\nvar EMPTY = [];\nfunction decodeOriginalScopes(input) {\n const { length } = input;\n const reader = new StringReader(input);\n const scopes = [];\n const stack = [];\n let line = 0;\n for (; reader.pos < length; reader.pos++) {\n line = decodeInteger(reader, line);\n const column = decodeInteger(reader, 0);\n if (!hasMoreVlq(reader, length)) {\n const last = stack.pop();\n last[2] = line;\n last[3] = column;\n continue;\n }\n const kind = decodeInteger(reader, 0);\n const fields = decodeInteger(reader, 0);\n const hasName = fields & 1;\n const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];\n let vars = EMPTY;\n if (hasMoreVlq(reader, length)) {\n vars = [];\n do {\n const varsIndex = decodeInteger(reader, 0);\n vars.push(varsIndex);\n } while (hasMoreVlq(reader, length));\n }\n scope.vars = vars;\n scopes.push(scope);\n stack.push(scope);\n }\n return scopes;\n}\nfunction encodeOriginalScopes(scopes) {\n const writer = new StringWriter();\n for (let i = 0; i < scopes.length; ) {\n i = _encodeOriginalScopes(scopes, i, writer, [0]);\n }\n return writer.flush();\n}\nfunction _encodeOriginalScopes(scopes, index, writer, state) {\n const scope = scopes[index];\n const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;\n if (index > 0) writer.write(comma);\n state[0] = encodeInteger(writer, startLine, state[0]);\n encodeInteger(writer, startColumn, 0);\n encodeInteger(writer, kind, 0);\n const fields = scope.length === 6 ? 1 : 0;\n encodeInteger(writer, fields, 0);\n if (scope.length === 6) encodeInteger(writer, scope[5], 0);\n for (const v of vars) {\n encodeInteger(writer, v, 0);\n }\n for (index++; index < scopes.length; ) {\n const next = scopes[index];\n const { 0: l, 1: c } = next;\n if (l > endLine || l === endLine && c >= endColumn) {\n break;\n }\n index = _encodeOriginalScopes(scopes, index, writer, state);\n }\n writer.write(comma);\n state[0] = encodeInteger(writer, endLine, state[0]);\n encodeInteger(writer, endColumn, 0);\n return index;\n}\nfunction decodeGeneratedRanges(input) {\n const { length } = input;\n const reader = new StringReader(input);\n const ranges = [];\n const stack = [];\n let genLine = 0;\n let definitionSourcesIndex = 0;\n let definitionScopeIndex = 0;\n let callsiteSourcesIndex = 0;\n let callsiteLine = 0;\n let callsiteColumn = 0;\n let bindingLine = 0;\n let bindingColumn = 0;\n do {\n const semi = reader.indexOf(\";\");\n let genColumn = 0;\n for (; reader.pos < semi; reader.pos++) {\n genColumn = decodeInteger(reader, genColumn);\n if (!hasMoreVlq(reader, semi)) {\n const last = stack.pop();\n last[2] = genLine;\n last[3] = genColumn;\n continue;\n }\n const fields = decodeInteger(reader, 0);\n const hasDefinition = fields & 1;\n const hasCallsite = fields & 2;\n const hasScope = fields & 4;\n let callsite = null;\n let bindings = EMPTY;\n let range;\n if (hasDefinition) {\n const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);\n definitionScopeIndex = decodeInteger(\n reader,\n definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0\n );\n definitionSourcesIndex = defSourcesIndex;\n range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];\n } else {\n range = [genLine, genColumn, 0, 0];\n }\n range.isScope = !!hasScope;\n if (hasCallsite) {\n const prevCsi = callsiteSourcesIndex;\n const prevLine = callsiteLine;\n callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);\n const sameSource = prevCsi === callsiteSourcesIndex;\n callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);\n callsiteColumn = decodeInteger(\n reader,\n sameSource && prevLine === callsiteLine ? callsiteColumn : 0\n );\n callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];\n }\n range.callsite = callsite;\n if (hasMoreVlq(reader, semi)) {\n bindings = [];\n do {\n bindingLine = genLine;\n bindingColumn = genColumn;\n const expressionsCount = decodeInteger(reader, 0);\n let expressionRanges;\n if (expressionsCount < -1) {\n expressionRanges = [[decodeInteger(reader, 0)]];\n for (let i = -1; i > expressionsCount; i--) {\n const prevBl = bindingLine;\n bindingLine = decodeInteger(reader, bindingLine);\n bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);\n const expression = decodeInteger(reader, 0);\n expressionRanges.push([expression, bindingLine, bindingColumn]);\n }\n } else {\n expressionRanges = [[expressionsCount]];\n }\n bindings.push(expressionRanges);\n } while (hasMoreVlq(reader, semi));\n }\n range.bindings = bindings;\n ranges.push(range);\n stack.push(range);\n }\n genLine++;\n reader.pos = semi + 1;\n } while (reader.pos < length);\n return ranges;\n}\nfunction encodeGeneratedRanges(ranges) {\n if (ranges.length === 0) return \"\";\n const writer = new StringWriter();\n for (let i = 0; i < ranges.length; ) {\n i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);\n }\n return writer.flush();\n}\nfunction _encodeGeneratedRanges(ranges, index, writer, state) {\n const range = ranges[index];\n const {\n 0: startLine,\n 1: startColumn,\n 2: endLine,\n 3: endColumn,\n isScope,\n callsite,\n bindings\n } = range;\n if (state[0] < startLine) {\n catchupLine(writer, state[0], startLine);\n state[0] = startLine;\n state[1] = 0;\n } else if (index > 0) {\n writer.write(comma);\n }\n state[1] = encodeInteger(writer, range[1], state[1]);\n const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);\n encodeInteger(writer, fields, 0);\n if (range.length === 6) {\n const { 4: sourcesIndex, 5: scopesIndex } = range;\n if (sourcesIndex !== state[2]) {\n state[3] = 0;\n }\n state[2] = encodeInteger(writer, sourcesIndex, state[2]);\n state[3] = encodeInteger(writer, scopesIndex, state[3]);\n }\n if (callsite) {\n const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;\n if (sourcesIndex !== state[4]) {\n state[5] = 0;\n state[6] = 0;\n } else if (callLine !== state[5]) {\n state[6] = 0;\n }\n state[4] = encodeInteger(writer, sourcesIndex, state[4]);\n state[5] = encodeInteger(writer, callLine, state[5]);\n state[6] = encodeInteger(writer, callColumn, state[6]);\n }\n if (bindings) {\n for (const binding of bindings) {\n if (binding.length > 1) encodeInteger(writer, -binding.length, 0);\n const expression = binding[0][0];\n encodeInteger(writer, expression, 0);\n let bindingStartLine = startLine;\n let bindingStartColumn = startColumn;\n for (let i = 1; i < binding.length; i++) {\n const expRange = binding[i];\n bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);\n bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);\n encodeInteger(writer, expRange[0], 0);\n }\n }\n }\n for (index++; index < ranges.length; ) {\n const next = ranges[index];\n const { 0: l, 1: c } = next;\n if (l > endLine || l === endLine && c >= endColumn) {\n break;\n }\n index = _encodeGeneratedRanges(ranges, index, writer, state);\n }\n if (state[0] < endLine) {\n catchupLine(writer, state[0], endLine);\n state[0] = endLine;\n state[1] = 0;\n } else {\n writer.write(comma);\n }\n state[1] = encodeInteger(writer, endColumn, state[1]);\n return index;\n}\nfunction catchupLine(writer, lastLine, line) {\n do {\n writer.write(semicolon);\n } while (++lastLine < line);\n}\n\n// src/sourcemap-codec.ts\nfunction decode(mappings) {\n const { length } = mappings;\n const reader = new StringReader(mappings);\n const decoded = [];\n let genColumn = 0;\n let sourcesIndex = 0;\n let sourceLine = 0;\n let sourceColumn = 0;\n let namesIndex = 0;\n do {\n const semi = reader.indexOf(\";\");\n const line = [];\n let sorted = true;\n let lastCol = 0;\n genColumn = 0;\n while (reader.pos < semi) {\n let seg;\n genColumn = decodeInteger(reader, genColumn);\n if (genColumn < lastCol) sorted = false;\n lastCol = genColumn;\n if (hasMoreVlq(reader, semi)) {\n sourcesIndex = decodeInteger(reader, sourcesIndex);\n sourceLine = decodeInteger(reader, sourceLine);\n sourceColumn = decodeInteger(reader, sourceColumn);\n if (hasMoreVlq(reader, semi)) {\n namesIndex = decodeInteger(reader, namesIndex);\n seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];\n } else {\n seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];\n }\n } else {\n seg = [genColumn];\n }\n line.push(seg);\n reader.pos++;\n }\n if (!sorted) sort(line);\n decoded.push(line);\n reader.pos = semi + 1;\n } while (reader.pos <= length);\n return decoded;\n}\nfunction sort(line) {\n line.sort(sortComparator);\n}\nfunction sortComparator(a, b) {\n return a[0] - b[0];\n}\nfunction encode(decoded) {\n const writer = new StringWriter();\n let sourcesIndex = 0;\n let sourceLine = 0;\n let sourceColumn = 0;\n let namesIndex = 0;\n for (let i = 0; i < decoded.length; i++) {\n const line = decoded[i];\n if (i > 0) writer.write(semicolon);\n if (line.length === 0) continue;\n let genColumn = 0;\n for (let j = 0; j < line.length; j++) {\n const segment = line[j];\n if (j > 0) writer.write(comma);\n genColumn = encodeInteger(writer, segment[0], genColumn);\n if (segment.length === 1) continue;\n sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);\n sourceLine = encodeInteger(writer, segment[2], sourceLine);\n sourceColumn = encodeInteger(writer, segment[3], sourceColumn);\n if (segment.length === 4) continue;\n namesIndex = encodeInteger(writer, segment[4], namesIndex);\n }\n }\n return writer.flush();\n}\n}));\n//# sourceMappingURL=sourcemap-codec.umd.js.map\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-core/index.js b/miniapp/miniprogram_npm/@vue/compiler-core/index.js new file mode 100644 index 0000000..fc4d646 --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-core/index.js @@ -0,0 +1,13677 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509105, function(require, module, exports) { + + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./dist/compiler-core.cjs.prod.js') +} else { + module.exports = require('./dist/compiler-core.cjs.js') +} + +}, function(modId) {var map = {"./dist/compiler-core.cjs.prod.js":1771034509106,"./dist/compiler-core.cjs.js":1771034509107}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509106, function(require, module, exports) { +/** +* @vue/compiler-core v3.5.28 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var shared = require('@vue/shared'); +var decode = require('entities/decode'); +var parser = require('@babel/parser'); +var estreeWalker = require('estree-walker'); +var sourceMapJs = require('source-map-js'); + +const FRAGMENT = /* @__PURE__ */ Symbol(``); +const TELEPORT = /* @__PURE__ */ Symbol(``); +const SUSPENSE = /* @__PURE__ */ Symbol(``); +const KEEP_ALIVE = /* @__PURE__ */ Symbol(``); +const BASE_TRANSITION = /* @__PURE__ */ Symbol( + `` +); +const OPEN_BLOCK = /* @__PURE__ */ Symbol(``); +const CREATE_BLOCK = /* @__PURE__ */ Symbol(``); +const CREATE_ELEMENT_BLOCK = /* @__PURE__ */ Symbol( + `` +); +const CREATE_VNODE = /* @__PURE__ */ Symbol(``); +const CREATE_ELEMENT_VNODE = /* @__PURE__ */ Symbol( + `` +); +const CREATE_COMMENT = /* @__PURE__ */ Symbol( + `` +); +const CREATE_TEXT = /* @__PURE__ */ Symbol( + `` +); +const CREATE_STATIC = /* @__PURE__ */ Symbol( + `` +); +const RESOLVE_COMPONENT = /* @__PURE__ */ Symbol( + `` +); +const RESOLVE_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol( + `` +); +const RESOLVE_DIRECTIVE = /* @__PURE__ */ Symbol( + `` +); +const RESOLVE_FILTER = /* @__PURE__ */ Symbol( + `` +); +const WITH_DIRECTIVES = /* @__PURE__ */ Symbol( + `` +); +const RENDER_LIST = /* @__PURE__ */ Symbol(``); +const RENDER_SLOT = /* @__PURE__ */ Symbol(``); +const CREATE_SLOTS = /* @__PURE__ */ Symbol(``); +const TO_DISPLAY_STRING = /* @__PURE__ */ Symbol( + `` +); +const MERGE_PROPS = /* @__PURE__ */ Symbol(``); +const NORMALIZE_CLASS = /* @__PURE__ */ Symbol( + `` +); +const NORMALIZE_STYLE = /* @__PURE__ */ Symbol( + `` +); +const NORMALIZE_PROPS = /* @__PURE__ */ Symbol( + `` +); +const GUARD_REACTIVE_PROPS = /* @__PURE__ */ Symbol( + `` +); +const TO_HANDLERS = /* @__PURE__ */ Symbol(``); +const CAMELIZE = /* @__PURE__ */ Symbol(``); +const CAPITALIZE = /* @__PURE__ */ Symbol(``); +const TO_HANDLER_KEY = /* @__PURE__ */ Symbol( + `` +); +const SET_BLOCK_TRACKING = /* @__PURE__ */ Symbol( + `` +); +const PUSH_SCOPE_ID = /* @__PURE__ */ Symbol(``); +const POP_SCOPE_ID = /* @__PURE__ */ Symbol(``); +const WITH_CTX = /* @__PURE__ */ Symbol(``); +const UNREF = /* @__PURE__ */ Symbol(``); +const IS_REF = /* @__PURE__ */ Symbol(``); +const WITH_MEMO = /* @__PURE__ */ Symbol(``); +const IS_MEMO_SAME = /* @__PURE__ */ Symbol(``); +const helperNameMap = { + [FRAGMENT]: `Fragment`, + [TELEPORT]: `Teleport`, + [SUSPENSE]: `Suspense`, + [KEEP_ALIVE]: `KeepAlive`, + [BASE_TRANSITION]: `BaseTransition`, + [OPEN_BLOCK]: `openBlock`, + [CREATE_BLOCK]: `createBlock`, + [CREATE_ELEMENT_BLOCK]: `createElementBlock`, + [CREATE_VNODE]: `createVNode`, + [CREATE_ELEMENT_VNODE]: `createElementVNode`, + [CREATE_COMMENT]: `createCommentVNode`, + [CREATE_TEXT]: `createTextVNode`, + [CREATE_STATIC]: `createStaticVNode`, + [RESOLVE_COMPONENT]: `resolveComponent`, + [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`, + [RESOLVE_DIRECTIVE]: `resolveDirective`, + [RESOLVE_FILTER]: `resolveFilter`, + [WITH_DIRECTIVES]: `withDirectives`, + [RENDER_LIST]: `renderList`, + [RENDER_SLOT]: `renderSlot`, + [CREATE_SLOTS]: `createSlots`, + [TO_DISPLAY_STRING]: `toDisplayString`, + [MERGE_PROPS]: `mergeProps`, + [NORMALIZE_CLASS]: `normalizeClass`, + [NORMALIZE_STYLE]: `normalizeStyle`, + [NORMALIZE_PROPS]: `normalizeProps`, + [GUARD_REACTIVE_PROPS]: `guardReactiveProps`, + [TO_HANDLERS]: `toHandlers`, + [CAMELIZE]: `camelize`, + [CAPITALIZE]: `capitalize`, + [TO_HANDLER_KEY]: `toHandlerKey`, + [SET_BLOCK_TRACKING]: `setBlockTracking`, + [PUSH_SCOPE_ID]: `pushScopeId`, + [POP_SCOPE_ID]: `popScopeId`, + [WITH_CTX]: `withCtx`, + [UNREF]: `unref`, + [IS_REF]: `isRef`, + [WITH_MEMO]: `withMemo`, + [IS_MEMO_SAME]: `isMemoSame` +}; +function registerRuntimeHelpers(helpers) { + Object.getOwnPropertySymbols(helpers).forEach((s) => { + helperNameMap[s] = helpers[s]; + }); +} + +const Namespaces = { + "HTML": 0, + "0": "HTML", + "SVG": 1, + "1": "SVG", + "MATH_ML": 2, + "2": "MATH_ML" +}; +const NodeTypes = { + "ROOT": 0, + "0": "ROOT", + "ELEMENT": 1, + "1": "ELEMENT", + "TEXT": 2, + "2": "TEXT", + "COMMENT": 3, + "3": "COMMENT", + "SIMPLE_EXPRESSION": 4, + "4": "SIMPLE_EXPRESSION", + "INTERPOLATION": 5, + "5": "INTERPOLATION", + "ATTRIBUTE": 6, + "6": "ATTRIBUTE", + "DIRECTIVE": 7, + "7": "DIRECTIVE", + "COMPOUND_EXPRESSION": 8, + "8": "COMPOUND_EXPRESSION", + "IF": 9, + "9": "IF", + "IF_BRANCH": 10, + "10": "IF_BRANCH", + "FOR": 11, + "11": "FOR", + "TEXT_CALL": 12, + "12": "TEXT_CALL", + "VNODE_CALL": 13, + "13": "VNODE_CALL", + "JS_CALL_EXPRESSION": 14, + "14": "JS_CALL_EXPRESSION", + "JS_OBJECT_EXPRESSION": 15, + "15": "JS_OBJECT_EXPRESSION", + "JS_PROPERTY": 16, + "16": "JS_PROPERTY", + "JS_ARRAY_EXPRESSION": 17, + "17": "JS_ARRAY_EXPRESSION", + "JS_FUNCTION_EXPRESSION": 18, + "18": "JS_FUNCTION_EXPRESSION", + "JS_CONDITIONAL_EXPRESSION": 19, + "19": "JS_CONDITIONAL_EXPRESSION", + "JS_CACHE_EXPRESSION": 20, + "20": "JS_CACHE_EXPRESSION", + "JS_BLOCK_STATEMENT": 21, + "21": "JS_BLOCK_STATEMENT", + "JS_TEMPLATE_LITERAL": 22, + "22": "JS_TEMPLATE_LITERAL", + "JS_IF_STATEMENT": 23, + "23": "JS_IF_STATEMENT", + "JS_ASSIGNMENT_EXPRESSION": 24, + "24": "JS_ASSIGNMENT_EXPRESSION", + "JS_SEQUENCE_EXPRESSION": 25, + "25": "JS_SEQUENCE_EXPRESSION", + "JS_RETURN_STATEMENT": 26, + "26": "JS_RETURN_STATEMENT" +}; +const ElementTypes = { + "ELEMENT": 0, + "0": "ELEMENT", + "COMPONENT": 1, + "1": "COMPONENT", + "SLOT": 2, + "2": "SLOT", + "TEMPLATE": 3, + "3": "TEMPLATE" +}; +const ConstantTypes = { + "NOT_CONSTANT": 0, + "0": "NOT_CONSTANT", + "CAN_SKIP_PATCH": 1, + "1": "CAN_SKIP_PATCH", + "CAN_CACHE": 2, + "2": "CAN_CACHE", + "CAN_STRINGIFY": 3, + "3": "CAN_STRINGIFY" +}; +const locStub = { + start: { line: 1, column: 1, offset: 0 }, + end: { line: 1, column: 1, offset: 0 }, + source: "" +}; +function createRoot(children, source = "") { + return { + type: 0, + source, + children, + helpers: /* @__PURE__ */ new Set(), + components: [], + directives: [], + hoists: [], + imports: [], + cached: [], + temps: 0, + codegenNode: void 0, + loc: locStub + }; +} +function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) { + if (context) { + if (isBlock) { + context.helper(OPEN_BLOCK); + context.helper(getVNodeBlockHelper(context.inSSR, isComponent)); + } else { + context.helper(getVNodeHelper(context.inSSR, isComponent)); + } + if (directives) { + context.helper(WITH_DIRECTIVES); + } + } + return { + type: 13, + tag, + props, + children, + patchFlag, + dynamicProps, + directives, + isBlock, + disableTracking, + isComponent, + loc + }; +} +function createArrayExpression(elements, loc = locStub) { + return { + type: 17, + loc, + elements + }; +} +function createObjectExpression(properties, loc = locStub) { + return { + type: 15, + loc, + properties + }; +} +function createObjectProperty(key, value) { + return { + type: 16, + loc: locStub, + key: shared.isString(key) ? createSimpleExpression(key, true) : key, + value + }; +} +function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) { + return { + type: 4, + loc, + content, + isStatic, + constType: isStatic ? 3 : constType + }; +} +function createInterpolation(content, loc) { + return { + type: 5, + loc, + content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content + }; +} +function createCompoundExpression(children, loc = locStub) { + return { + type: 8, + loc, + children + }; +} +function createCallExpression(callee, args = [], loc = locStub) { + return { + type: 14, + loc, + callee, + arguments: args + }; +} +function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) { + return { + type: 18, + params, + returns, + newline, + isSlot, + loc + }; +} +function createConditionalExpression(test, consequent, alternate, newline = true) { + return { + type: 19, + test, + consequent, + alternate, + newline, + loc: locStub + }; +} +function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) { + return { + type: 20, + index, + value, + needPauseTracking, + inVOnce, + needArraySpread: false, + loc: locStub + }; +} +function createBlockStatement(body) { + return { + type: 21, + body, + loc: locStub + }; +} +function createTemplateLiteral(elements) { + return { + type: 22, + elements, + loc: locStub + }; +} +function createIfStatement(test, consequent, alternate) { + return { + type: 23, + test, + consequent, + alternate, + loc: locStub + }; +} +function createAssignmentExpression(left, right) { + return { + type: 24, + left, + right, + loc: locStub + }; +} +function createSequenceExpression(expressions) { + return { + type: 25, + expressions, + loc: locStub + }; +} +function createReturnStatement(returns) { + return { + type: 26, + returns, + loc: locStub + }; +} +function getVNodeHelper(ssr, isComponent) { + return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE; +} +function getVNodeBlockHelper(ssr, isComponent) { + return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK; +} +function convertToBlock(node, { helper, removeHelper, inSSR }) { + if (!node.isBlock) { + node.isBlock = true; + removeHelper(getVNodeHelper(inSSR, node.isComponent)); + helper(OPEN_BLOCK); + helper(getVNodeBlockHelper(inSSR, node.isComponent)); + } +} + +const defaultDelimitersOpen = new Uint8Array([123, 123]); +const defaultDelimitersClose = new Uint8Array([125, 125]); +function isTagStartChar(c) { + return c >= 97 && c <= 122 || c >= 65 && c <= 90; +} +function isWhitespace(c) { + return c === 32 || c === 10 || c === 9 || c === 12 || c === 13; +} +function isEndOfTagSection(c) { + return c === 47 || c === 62 || isWhitespace(c); +} +function toCharCodes(str) { + const ret = new Uint8Array(str.length); + for (let i = 0; i < str.length; i++) { + ret[i] = str.charCodeAt(i); + } + return ret; +} +const Sequences = { + Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]), + // CDATA[ + CdataEnd: new Uint8Array([93, 93, 62]), + // ]]> + CommentEnd: new Uint8Array([45, 45, 62]), + // `-->` + ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]), + // `<\/script` + StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]), + // ` this.emitCodePoint(cp, consumed) + ); + } + } + get inSFCRoot() { + return this.mode === 2 && this.stack.length === 0; + } + reset() { + this.state = 1; + this.mode = 0; + this.buffer = ""; + this.sectionStart = 0; + this.index = 0; + this.baseState = 1; + this.inRCDATA = false; + this.currentSequence = void 0; + this.newlines.length = 0; + this.delimiterOpen = defaultDelimitersOpen; + this.delimiterClose = defaultDelimitersClose; + } + /** + * Generate Position object with line / column information using recorded + * newline positions. We know the index is always going to be an already + * processed index, so all the newlines up to this index should have been + * recorded. + */ + getPos(index) { + let line = 1; + let column = index + 1; + const length = this.newlines.length; + let j = -1; + if (length > 100) { + let l = -1; + let r = length; + while (l + 1 < r) { + const m = l + r >>> 1; + this.newlines[m] < index ? l = m : r = m; + } + j = l; + } else { + for (let i = length - 1; i >= 0; i--) { + if (index > this.newlines[i]) { + j = i; + break; + } + } + } + if (j >= 0) { + line = j + 2; + column = index - this.newlines[j]; + } + return { + column, + line, + offset: index + }; + } + peek() { + return this.buffer.charCodeAt(this.index + 1); + } + stateText(c) { + if (c === 60) { + if (this.index > this.sectionStart) { + this.cbs.ontext(this.sectionStart, this.index); + } + this.state = 5; + this.sectionStart = this.index; + } else if (c === 38) { + this.startEntity(); + } else if (!this.inVPre && c === this.delimiterOpen[0]) { + this.state = 2; + this.delimiterIndex = 0; + this.stateInterpolationOpen(c); + } + } + stateInterpolationOpen(c) { + if (c === this.delimiterOpen[this.delimiterIndex]) { + if (this.delimiterIndex === this.delimiterOpen.length - 1) { + const start = this.index + 1 - this.delimiterOpen.length; + if (start > this.sectionStart) { + this.cbs.ontext(this.sectionStart, start); + } + this.state = 3; + this.sectionStart = start; + } else { + this.delimiterIndex++; + } + } else if (this.inRCDATA) { + this.state = 32; + this.stateInRCDATA(c); + } else { + this.state = 1; + this.stateText(c); + } + } + stateInterpolation(c) { + if (c === this.delimiterClose[0]) { + this.state = 4; + this.delimiterIndex = 0; + this.stateInterpolationClose(c); + } + } + stateInterpolationClose(c) { + if (c === this.delimiterClose[this.delimiterIndex]) { + if (this.delimiterIndex === this.delimiterClose.length - 1) { + this.cbs.oninterpolation(this.sectionStart, this.index + 1); + if (this.inRCDATA) { + this.state = 32; + } else { + this.state = 1; + } + this.sectionStart = this.index + 1; + } else { + this.delimiterIndex++; + } + } else { + this.state = 3; + this.stateInterpolation(c); + } + } + stateSpecialStartSequence(c) { + const isEnd = this.sequenceIndex === this.currentSequence.length; + const isMatch = isEnd ? ( + // If we are at the end of the sequence, make sure the tag name has ended + isEndOfTagSection(c) + ) : ( + // Otherwise, do a case-insensitive comparison + (c | 32) === this.currentSequence[this.sequenceIndex] + ); + if (!isMatch) { + this.inRCDATA = false; + } else if (!isEnd) { + this.sequenceIndex++; + return; + } + this.sequenceIndex = 0; + this.state = 6; + this.stateInTagName(c); + } + /** Look for an end tag. For and <textarea>, also decode entities. */ + stateInRCDATA(c) { + if (this.sequenceIndex === this.currentSequence.length) { + if (c === 62 || isWhitespace(c)) { + const endOfText = this.index - this.currentSequence.length; + if (this.sectionStart < endOfText) { + const actualIndex = this.index; + this.index = endOfText; + this.cbs.ontext(this.sectionStart, endOfText); + this.index = actualIndex; + } + this.sectionStart = endOfText + 2; + this.stateInClosingTagName(c); + this.inRCDATA = false; + return; + } + this.sequenceIndex = 0; + } + if ((c | 32) === this.currentSequence[this.sequenceIndex]) { + this.sequenceIndex += 1; + } else if (this.sequenceIndex === 0) { + if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) { + if (c === 38) { + this.startEntity(); + } else if (!this.inVPre && c === this.delimiterOpen[0]) { + this.state = 2; + this.delimiterIndex = 0; + this.stateInterpolationOpen(c); + } + } else if (this.fastForwardTo(60)) { + this.sequenceIndex = 1; + } + } else { + this.sequenceIndex = Number(c === 60); + } + } + stateCDATASequence(c) { + if (c === Sequences.Cdata[this.sequenceIndex]) { + if (++this.sequenceIndex === Sequences.Cdata.length) { + this.state = 28; + this.currentSequence = Sequences.CdataEnd; + this.sequenceIndex = 0; + this.sectionStart = this.index + 1; + } + } else { + this.sequenceIndex = 0; + this.state = 23; + this.stateInDeclaration(c); + } + } + /** + * When we wait for one specific character, we can speed things up + * by skipping through the buffer until we find it. + * + * @returns Whether the character was found. + */ + fastForwardTo(c) { + while (++this.index < this.buffer.length) { + const cc = this.buffer.charCodeAt(this.index); + if (cc === 10) { + this.newlines.push(this.index); + } + if (cc === c) { + return true; + } + } + this.index = this.buffer.length - 1; + return false; + } + /** + * Comments and CDATA end with `-->` and `]]>`. + * + * Their common qualities are: + * - Their end sequences have a distinct character they start with. + * - That character is then repeated, so we have to check multiple repeats. + * - All characters but the start character of the sequence can be skipped. + */ + stateInCommentLike(c) { + if (c === this.currentSequence[this.sequenceIndex]) { + if (++this.sequenceIndex === this.currentSequence.length) { + if (this.currentSequence === Sequences.CdataEnd) { + this.cbs.oncdata(this.sectionStart, this.index - 2); + } else { + this.cbs.oncomment(this.sectionStart, this.index - 2); + } + this.sequenceIndex = 0; + this.sectionStart = this.index + 1; + this.state = 1; + } + } else if (this.sequenceIndex === 0) { + if (this.fastForwardTo(this.currentSequence[0])) { + this.sequenceIndex = 1; + } + } else if (c !== this.currentSequence[this.sequenceIndex - 1]) { + this.sequenceIndex = 0; + } + } + startSpecial(sequence, offset) { + this.enterRCDATA(sequence, offset); + this.state = 31; + } + enterRCDATA(sequence, offset) { + this.inRCDATA = true; + this.currentSequence = sequence; + this.sequenceIndex = offset; + } + stateBeforeTagName(c) { + if (c === 33) { + this.state = 22; + this.sectionStart = this.index + 1; + } else if (c === 63) { + this.state = 24; + this.sectionStart = this.index + 1; + } else if (isTagStartChar(c)) { + this.sectionStart = this.index; + if (this.mode === 0) { + this.state = 6; + } else if (this.inSFCRoot) { + this.state = 34; + } else if (!this.inXML) { + if (c === 116) { + this.state = 30; + } else { + this.state = c === 115 ? 29 : 6; + } + } else { + this.state = 6; + } + } else if (c === 47) { + this.state = 8; + } else { + this.state = 1; + this.stateText(c); + } + } + stateInTagName(c) { + if (isEndOfTagSection(c)) { + this.handleTagName(c); + } + } + stateInSFCRootTagName(c) { + if (isEndOfTagSection(c)) { + const tag = this.buffer.slice(this.sectionStart, this.index); + if (tag !== "template") { + this.enterRCDATA(toCharCodes(`</` + tag), 0); + } + this.handleTagName(c); + } + } + handleTagName(c) { + this.cbs.onopentagname(this.sectionStart, this.index); + this.sectionStart = -1; + this.state = 11; + this.stateBeforeAttrName(c); + } + stateBeforeClosingTagName(c) { + if (isWhitespace(c)) ; else if (c === 62) { + { + this.cbs.onerr(14, this.index); + } + this.state = 1; + this.sectionStart = this.index + 1; + } else { + this.state = isTagStartChar(c) ? 9 : 27; + this.sectionStart = this.index; + } + } + stateInClosingTagName(c) { + if (c === 62 || isWhitespace(c)) { + this.cbs.onclosetag(this.sectionStart, this.index); + this.sectionStart = -1; + this.state = 10; + this.stateAfterClosingTagName(c); + } + } + stateAfterClosingTagName(c) { + if (c === 62) { + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeAttrName(c) { + if (c === 62) { + this.cbs.onopentagend(this.index); + if (this.inRCDATA) { + this.state = 32; + } else { + this.state = 1; + } + this.sectionStart = this.index + 1; + } else if (c === 47) { + this.state = 7; + if (this.peek() !== 62) { + this.cbs.onerr(22, this.index); + } + } else if (c === 60 && this.peek() === 47) { + this.cbs.onopentagend(this.index); + this.state = 5; + this.sectionStart = this.index; + } else if (!isWhitespace(c)) { + if (c === 61) { + this.cbs.onerr( + 19, + this.index + ); + } + this.handleAttrStart(c); + } + } + handleAttrStart(c) { + if (c === 118 && this.peek() === 45) { + this.state = 13; + this.sectionStart = this.index; + } else if (c === 46 || c === 58 || c === 64 || c === 35) { + this.cbs.ondirname(this.index, this.index + 1); + this.state = 14; + this.sectionStart = this.index + 1; + } else { + this.state = 12; + this.sectionStart = this.index; + } + } + stateInSelfClosingTag(c) { + if (c === 62) { + this.cbs.onselfclosingtag(this.index); + this.state = 1; + this.sectionStart = this.index + 1; + this.inRCDATA = false; + } else if (!isWhitespace(c)) { + this.state = 11; + this.stateBeforeAttrName(c); + } + } + stateInAttrName(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.onattribname(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 34 || c === 39 || c === 60) { + this.cbs.onerr( + 17, + this.index + ); + } + } + stateInDirName(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirname(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 58) { + this.cbs.ondirname(this.sectionStart, this.index); + this.state = 14; + this.sectionStart = this.index + 1; + } else if (c === 46) { + this.cbs.ondirname(this.sectionStart, this.index); + this.state = 16; + this.sectionStart = this.index + 1; + } + } + stateInDirArg(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirarg(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 91) { + this.state = 15; + } else if (c === 46) { + this.cbs.ondirarg(this.sectionStart, this.index); + this.state = 16; + this.sectionStart = this.index + 1; + } + } + stateInDynamicDirArg(c) { + if (c === 93) { + this.state = 14; + } else if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirarg(this.sectionStart, this.index + 1); + this.handleAttrNameEnd(c); + { + this.cbs.onerr( + 27, + this.index + ); + } + } + } + stateInDirModifier(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirmodifier(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 46) { + this.cbs.ondirmodifier(this.sectionStart, this.index); + this.sectionStart = this.index + 1; + } + } + handleAttrNameEnd(c) { + this.sectionStart = this.index; + this.state = 17; + this.cbs.onattribnameend(this.index); + this.stateAfterAttrName(c); + } + stateAfterAttrName(c) { + if (c === 61) { + this.state = 18; + } else if (c === 47 || c === 62) { + this.cbs.onattribend(0, this.sectionStart); + this.sectionStart = -1; + this.state = 11; + this.stateBeforeAttrName(c); + } else if (!isWhitespace(c)) { + this.cbs.onattribend(0, this.sectionStart); + this.handleAttrStart(c); + } + } + stateBeforeAttrValue(c) { + if (c === 34) { + this.state = 19; + this.sectionStart = this.index + 1; + } else if (c === 39) { + this.state = 20; + this.sectionStart = this.index + 1; + } else if (!isWhitespace(c)) { + this.sectionStart = this.index; + this.state = 21; + this.stateInAttrValueNoQuotes(c); + } + } + handleInAttrValue(c, quote) { + if (c === quote || false) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = -1; + this.cbs.onattribend( + quote === 34 ? 3 : 2, + this.index + 1 + ); + this.state = 11; + } else if (c === 38) { + this.startEntity(); + } + } + stateInAttrValueDoubleQuotes(c) { + this.handleInAttrValue(c, 34); + } + stateInAttrValueSingleQuotes(c) { + this.handleInAttrValue(c, 39); + } + stateInAttrValueNoQuotes(c) { + if (isWhitespace(c) || c === 62) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = -1; + this.cbs.onattribend(1, this.index); + this.state = 11; + this.stateBeforeAttrName(c); + } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) { + this.cbs.onerr( + 18, + this.index + ); + } else if (c === 38) { + this.startEntity(); + } + } + stateBeforeDeclaration(c) { + if (c === 91) { + this.state = 26; + this.sequenceIndex = 0; + } else { + this.state = c === 45 ? 25 : 23; + } + } + stateInDeclaration(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateInProcessingInstruction(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.cbs.onprocessinginstruction(this.sectionStart, this.index); + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeComment(c) { + if (c === 45) { + this.state = 28; + this.currentSequence = Sequences.CommentEnd; + this.sequenceIndex = 2; + this.sectionStart = this.index + 1; + } else { + this.state = 23; + } + } + stateInSpecialComment(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.cbs.oncomment(this.sectionStart, this.index); + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeSpecialS(c) { + if (c === Sequences.ScriptEnd[3]) { + this.startSpecial(Sequences.ScriptEnd, 4); + } else if (c === Sequences.StyleEnd[3]) { + this.startSpecial(Sequences.StyleEnd, 4); + } else { + this.state = 6; + this.stateInTagName(c); + } + } + stateBeforeSpecialT(c) { + if (c === Sequences.TitleEnd[3]) { + this.startSpecial(Sequences.TitleEnd, 4); + } else if (c === Sequences.TextareaEnd[3]) { + this.startSpecial(Sequences.TextareaEnd, 4); + } else { + this.state = 6; + this.stateInTagName(c); + } + } + startEntity() { + { + this.baseState = this.state; + this.state = 33; + this.entityStart = this.index; + this.entityDecoder.startEntity( + this.baseState === 1 || this.baseState === 32 ? decode.DecodingMode.Legacy : decode.DecodingMode.Attribute + ); + } + } + stateInEntity() { + { + const length = this.entityDecoder.write(this.buffer, this.index); + if (length >= 0) { + this.state = this.baseState; + if (length === 0) { + this.index = this.entityStart; + } + } else { + this.index = this.buffer.length - 1; + } + } + } + /** + * Iterates through the buffer, calling the function corresponding to the current state. + * + * States that are more likely to be hit are higher up, as a performance improvement. + */ + parse(input) { + this.buffer = input; + while (this.index < this.buffer.length) { + const c = this.buffer.charCodeAt(this.index); + if (c === 10 && this.state !== 33) { + this.newlines.push(this.index); + } + switch (this.state) { + case 1: { + this.stateText(c); + break; + } + case 2: { + this.stateInterpolationOpen(c); + break; + } + case 3: { + this.stateInterpolation(c); + break; + } + case 4: { + this.stateInterpolationClose(c); + break; + } + case 31: { + this.stateSpecialStartSequence(c); + break; + } + case 32: { + this.stateInRCDATA(c); + break; + } + case 26: { + this.stateCDATASequence(c); + break; + } + case 19: { + this.stateInAttrValueDoubleQuotes(c); + break; + } + case 12: { + this.stateInAttrName(c); + break; + } + case 13: { + this.stateInDirName(c); + break; + } + case 14: { + this.stateInDirArg(c); + break; + } + case 15: { + this.stateInDynamicDirArg(c); + break; + } + case 16: { + this.stateInDirModifier(c); + break; + } + case 28: { + this.stateInCommentLike(c); + break; + } + case 27: { + this.stateInSpecialComment(c); + break; + } + case 11: { + this.stateBeforeAttrName(c); + break; + } + case 6: { + this.stateInTagName(c); + break; + } + case 34: { + this.stateInSFCRootTagName(c); + break; + } + case 9: { + this.stateInClosingTagName(c); + break; + } + case 5: { + this.stateBeforeTagName(c); + break; + } + case 17: { + this.stateAfterAttrName(c); + break; + } + case 20: { + this.stateInAttrValueSingleQuotes(c); + break; + } + case 18: { + this.stateBeforeAttrValue(c); + break; + } + case 8: { + this.stateBeforeClosingTagName(c); + break; + } + case 10: { + this.stateAfterClosingTagName(c); + break; + } + case 29: { + this.stateBeforeSpecialS(c); + break; + } + case 30: { + this.stateBeforeSpecialT(c); + break; + } + case 21: { + this.stateInAttrValueNoQuotes(c); + break; + } + case 7: { + this.stateInSelfClosingTag(c); + break; + } + case 23: { + this.stateInDeclaration(c); + break; + } + case 22: { + this.stateBeforeDeclaration(c); + break; + } + case 25: { + this.stateBeforeComment(c); + break; + } + case 24: { + this.stateInProcessingInstruction(c); + break; + } + case 33: { + this.stateInEntity(); + break; + } + } + this.index++; + } + this.cleanup(); + this.finish(); + } + /** + * Remove data that has already been consumed from the buffer. + */ + cleanup() { + if (this.sectionStart !== this.index) { + if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) { + this.cbs.ontext(this.sectionStart, this.index); + this.sectionStart = this.index; + } else if (this.state === 19 || this.state === 20 || this.state === 21) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = this.index; + } + } + } + finish() { + if (this.state === 33) { + this.entityDecoder.end(); + this.state = this.baseState; + } + this.handleTrailingData(); + this.cbs.onend(); + } + /** Handle any trailing data. */ + handleTrailingData() { + const endIndex = this.buffer.length; + if (this.sectionStart >= endIndex) { + return; + } + if (this.state === 28) { + if (this.currentSequence === Sequences.CdataEnd) { + this.cbs.oncdata(this.sectionStart, endIndex); + } else { + this.cbs.oncomment(this.sectionStart, endIndex); + } + } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else { + this.cbs.ontext(this.sectionStart, endIndex); + } + } + emitCodePoint(cp, consumed) { + { + if (this.baseState !== 1 && this.baseState !== 32) { + if (this.sectionStart < this.entityStart) { + this.cbs.onattribdata(this.sectionStart, this.entityStart); + } + this.sectionStart = this.entityStart + consumed; + this.index = this.sectionStart - 1; + this.cbs.onattribentity( + decode.fromCodePoint(cp), + this.entityStart, + this.sectionStart + ); + } else { + if (this.sectionStart < this.entityStart) { + this.cbs.ontext(this.sectionStart, this.entityStart); + } + this.sectionStart = this.entityStart + consumed; + this.index = this.sectionStart - 1; + this.cbs.ontextentity( + decode.fromCodePoint(cp), + this.entityStart, + this.sectionStart + ); + } + } + } +} + +const CompilerDeprecationTypes = { + "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT", + "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC", + "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER", + "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE", + "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE", + "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE", + "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE", + "COMPILER_FILTERS": "COMPILER_FILTERS" +}; +const deprecationData = { + ["COMPILER_IS_ON_ELEMENT"]: { + message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`, + link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html` + }, + ["COMPILER_V_BIND_SYNC"]: { + message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html` + }, + ["COMPILER_V_BIND_OBJECT_ORDER"]: { + message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html` + }, + ["COMPILER_V_ON_NATIVE"]: { + message: `.native modifier for v-on has been removed as is no longer necessary.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html` + }, + ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: { + message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html` + }, + ["COMPILER_NATIVE_TEMPLATE"]: { + message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.` + }, + ["COMPILER_INLINE_TEMPLATE"]: { + message: `"inline-template" has been removed in Vue 3.`, + link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html` + }, + ["COMPILER_FILTERS"]: { + message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`, + link: `https://v3-migration.vuejs.org/breaking-changes/filters.html` + } +}; +function getCompatValue(key, { compatConfig }) { + const value = compatConfig && compatConfig[key]; + if (key === "MODE") { + return value || 3; + } else { + return value; + } +} +function isCompatEnabled(key, context) { + const mode = getCompatValue("MODE", context); + const value = getCompatValue(key, context); + return mode === 3 ? value === true : value !== false; +} +function checkCompatEnabled(key, context, loc, ...args) { + const enabled = isCompatEnabled(key, context); + return enabled; +} +function warnDeprecation(key, context, loc, ...args) { + const val = getCompatValue(key, context); + if (val === "suppress-warning") { + return; + } + const { message, link } = deprecationData[key]; + const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? ` + Details: ${link}` : ``}`; + const err = new SyntaxError(msg); + err.code = key; + if (loc) err.loc = loc; + context.onWarn(err); +} + +function defaultOnError(error) { + throw error; +} +function defaultOnWarn(msg) { +} +function createCompilerError(code, loc, messages, additionalMessage) { + const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ; + const error = new SyntaxError(String(msg)); + error.code = code; + error.loc = loc; + return error; +} +const ErrorCodes = { + "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0, + "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT", + "CDATA_IN_HTML_CONTENT": 1, + "1": "CDATA_IN_HTML_CONTENT", + "DUPLICATE_ATTRIBUTE": 2, + "2": "DUPLICATE_ATTRIBUTE", + "END_TAG_WITH_ATTRIBUTES": 3, + "3": "END_TAG_WITH_ATTRIBUTES", + "END_TAG_WITH_TRAILING_SOLIDUS": 4, + "4": "END_TAG_WITH_TRAILING_SOLIDUS", + "EOF_BEFORE_TAG_NAME": 5, + "5": "EOF_BEFORE_TAG_NAME", + "EOF_IN_CDATA": 6, + "6": "EOF_IN_CDATA", + "EOF_IN_COMMENT": 7, + "7": "EOF_IN_COMMENT", + "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8, + "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT", + "EOF_IN_TAG": 9, + "9": "EOF_IN_TAG", + "INCORRECTLY_CLOSED_COMMENT": 10, + "10": "INCORRECTLY_CLOSED_COMMENT", + "INCORRECTLY_OPENED_COMMENT": 11, + "11": "INCORRECTLY_OPENED_COMMENT", + "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12, + "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME", + "MISSING_ATTRIBUTE_VALUE": 13, + "13": "MISSING_ATTRIBUTE_VALUE", + "MISSING_END_TAG_NAME": 14, + "14": "MISSING_END_TAG_NAME", + "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15, + "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES", + "NESTED_COMMENT": 16, + "16": "NESTED_COMMENT", + "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17, + "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME", + "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18, + "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE", + "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19, + "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME", + "UNEXPECTED_NULL_CHARACTER": 20, + "20": "UNEXPECTED_NULL_CHARACTER", + "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21, + "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME", + "UNEXPECTED_SOLIDUS_IN_TAG": 22, + "22": "UNEXPECTED_SOLIDUS_IN_TAG", + "X_INVALID_END_TAG": 23, + "23": "X_INVALID_END_TAG", + "X_MISSING_END_TAG": 24, + "24": "X_MISSING_END_TAG", + "X_MISSING_INTERPOLATION_END": 25, + "25": "X_MISSING_INTERPOLATION_END", + "X_MISSING_DIRECTIVE_NAME": 26, + "26": "X_MISSING_DIRECTIVE_NAME", + "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27, + "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END", + "X_V_IF_NO_EXPRESSION": 28, + "28": "X_V_IF_NO_EXPRESSION", + "X_V_IF_SAME_KEY": 29, + "29": "X_V_IF_SAME_KEY", + "X_V_ELSE_NO_ADJACENT_IF": 30, + "30": "X_V_ELSE_NO_ADJACENT_IF", + "X_V_FOR_NO_EXPRESSION": 31, + "31": "X_V_FOR_NO_EXPRESSION", + "X_V_FOR_MALFORMED_EXPRESSION": 32, + "32": "X_V_FOR_MALFORMED_EXPRESSION", + "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33, + "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT", + "X_V_BIND_NO_EXPRESSION": 34, + "34": "X_V_BIND_NO_EXPRESSION", + "X_V_ON_NO_EXPRESSION": 35, + "35": "X_V_ON_NO_EXPRESSION", + "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36, + "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET", + "X_V_SLOT_MIXED_SLOT_USAGE": 37, + "37": "X_V_SLOT_MIXED_SLOT_USAGE", + "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38, + "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES", + "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39, + "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN", + "X_V_SLOT_MISPLACED": 40, + "40": "X_V_SLOT_MISPLACED", + "X_V_MODEL_NO_EXPRESSION": 41, + "41": "X_V_MODEL_NO_EXPRESSION", + "X_V_MODEL_MALFORMED_EXPRESSION": 42, + "42": "X_V_MODEL_MALFORMED_EXPRESSION", + "X_V_MODEL_ON_SCOPE_VARIABLE": 43, + "43": "X_V_MODEL_ON_SCOPE_VARIABLE", + "X_V_MODEL_ON_PROPS": 44, + "44": "X_V_MODEL_ON_PROPS", + "X_V_MODEL_ON_CONST": 45, + "45": "X_V_MODEL_ON_CONST", + "X_INVALID_EXPRESSION": 46, + "46": "X_INVALID_EXPRESSION", + "X_KEEP_ALIVE_INVALID_CHILDREN": 47, + "47": "X_KEEP_ALIVE_INVALID_CHILDREN", + "X_PREFIX_ID_NOT_SUPPORTED": 48, + "48": "X_PREFIX_ID_NOT_SUPPORTED", + "X_MODULE_MODE_NOT_SUPPORTED": 49, + "49": "X_MODULE_MODE_NOT_SUPPORTED", + "X_CACHE_HANDLER_NOT_SUPPORTED": 50, + "50": "X_CACHE_HANDLER_NOT_SUPPORTED", + "X_SCOPE_ID_NOT_SUPPORTED": 51, + "51": "X_SCOPE_ID_NOT_SUPPORTED", + "X_VNODE_HOOKS": 52, + "52": "X_VNODE_HOOKS", + "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 53, + "53": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT", + "__EXTEND_POINT__": 54, + "54": "__EXTEND_POINT__" +}; +const errorMessages = { + // parse errors + [0]: "Illegal comment.", + [1]: "CDATA section is allowed only in XML context.", + [2]: "Duplicate attribute.", + [3]: "End tag cannot have attributes.", + [4]: "Illegal '/' in tags.", + [5]: "Unexpected EOF in tag.", + [6]: "Unexpected EOF in CDATA section.", + [7]: "Unexpected EOF in comment.", + [8]: "Unexpected EOF in script.", + [9]: "Unexpected EOF in tag.", + [10]: "Incorrectly closed comment.", + [11]: "Incorrectly opened comment.", + [12]: "Illegal tag name. Use '<' to print '<'.", + [13]: "Attribute value was expected.", + [14]: "End tag name was expected.", + [15]: "Whitespace was expected.", + [16]: "Unexpected '<!--' in comment.", + [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`, + [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).", + [19]: "Attribute name cannot start with '='.", + [21]: "'<?' is allowed only in XML context.", + [20]: `Unexpected null character.`, + [22]: "Illegal '/' in tags.", + // Vue-specific parse errors + [23]: "Invalid end tag.", + [24]: "Element is missing end tag.", + [25]: "Interpolation end sign was not found.", + [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.", + [26]: "Legal directive name was expected.", + // transform errors + [28]: `v-if/v-else-if is missing expression.`, + [29]: `v-if/else branches must use unique keys.`, + [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`, + [31]: `v-for is missing expression.`, + [32]: `v-for has invalid expression.`, + [33]: `<template v-for> key should be placed on the <template> tag.`, + [34]: `v-bind is missing expression.`, + [53]: `v-bind with same-name shorthand only allows static argument.`, + [35]: `v-on is missing expression.`, + [36]: `Unexpected custom directive on <slot> outlet.`, + [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`, + [38]: `Duplicate slot names found. `, + [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`, + [40]: `v-slot can only be used on components or <template> tags.`, + [41]: `v-model is missing expression.`, + [42]: `v-model value must be a valid JavaScript member expression.`, + [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`, + [44]: `v-model cannot be used on a prop, because local prop bindings are not writable. +Use a v-bind binding combined with a v-on listener that emits update:x event instead.`, + [45]: `v-model cannot be used on a const binding because it is not writable.`, + [46]: `Error parsing JavaScript expression: `, + [47]: `<KeepAlive> expects exactly one child component.`, + [52]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`, + // generic errors + [48]: `"prefixIdentifiers" option is not supported in this build of compiler.`, + [49]: `ES module mode is not supported in this build of compiler.`, + [50]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`, + [51]: `"scopeId" option is only supported in module mode.`, + // just to fulfill types + [54]: `` +}; + +function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) { + const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root; + estreeWalker.walk(root, { + enter(node, parent) { + parent && parentStack.push(parent); + if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) { + return this.skip(); + } + if (node.type === "Identifier") { + const isLocal = !!knownIds[node.name]; + const isRefed = isReferencedIdentifier(node, parent, parentStack); + if (includeAll || isRefed && !isLocal) { + onIdentifier(node, parent, parentStack, isRefed, isLocal); + } + } else if (node.type === "ObjectProperty" && // eslint-disable-next-line no-restricted-syntax + (parent == null ? void 0 : parent.type) === "ObjectPattern") { + node.inPattern = true; + } else if (isFunctionType(node)) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkFunctionParams( + node, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "BlockStatement") { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkBlockDeclarations( + node, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "SwitchStatement") { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkSwitchStatement( + node, + false, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "CatchClause" && node.param) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + for (const id of extractIdentifiers(node.param)) { + markScopeIdentifier(node, id, knownIds); + } + } + } else if (isForStatement(node)) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkForStatement( + node, + false, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } + }, + leave(node, parent) { + parent && parentStack.pop(); + if (node !== rootExp && node.scopeIds) { + for (const id of node.scopeIds) { + knownIds[id]--; + if (knownIds[id] === 0) { + delete knownIds[id]; + } + } + } + } + }); +} +function isReferencedIdentifier(id, parent, parentStack) { + if (!parent) { + return true; + } + if (id.name === "arguments") { + return false; + } + if (isReferenced(id, parent, parentStack[parentStack.length - 2])) { + return true; + } + switch (parent.type) { + case "AssignmentExpression": + case "AssignmentPattern": + return true; + case "ObjectProperty": + return parent.key !== id && isInDestructureAssignment(parent, parentStack); + case "ArrayPattern": + return isInDestructureAssignment(parent, parentStack); + } + return false; +} +function isInDestructureAssignment(parent, parentStack) { + if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) { + let i = parentStack.length; + while (i--) { + const p = parentStack[i]; + if (p.type === "AssignmentExpression") { + return true; + } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) { + break; + } + } + } + return false; +} +function isInNewExpression(parentStack) { + let i = parentStack.length; + while (i--) { + const p = parentStack[i]; + if (p.type === "NewExpression") { + return true; + } else if (p.type !== "MemberExpression") { + break; + } + } + return false; +} +function walkFunctionParams(node, onIdent) { + for (const p of node.params) { + for (const id of extractIdentifiers(p)) { + onIdent(id); + } + } +} +function walkBlockDeclarations(block, onIdent) { + const body = block.type === "SwitchCase" ? block.consequent : block.body; + for (const stmt of body) { + if (stmt.type === "VariableDeclaration") { + if (stmt.declare) continue; + for (const decl of stmt.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") { + if (stmt.declare || !stmt.id) continue; + onIdent(stmt.id); + } else if (isForStatement(stmt)) { + walkForStatement(stmt, true, onIdent); + } else if (stmt.type === "SwitchStatement") { + walkSwitchStatement(stmt, true, onIdent); + } + } +} +function isForStatement(stmt) { + return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement"; +} +function walkForStatement(stmt, isVar, onIdent) { + const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left; + if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) { + for (const decl of variable.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } +} +function walkSwitchStatement(stmt, isVar, onIdent) { + for (const cs of stmt.cases) { + for (const stmt2 of cs.consequent) { + if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) { + for (const decl of stmt2.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } + } + walkBlockDeclarations(cs, onIdent); + } +} +function extractIdentifiers(param, nodes = []) { + switch (param.type) { + case "Identifier": + nodes.push(param); + break; + case "MemberExpression": + let object = param; + while (object.type === "MemberExpression") { + object = object.object; + } + nodes.push(object); + break; + case "ObjectPattern": + for (const prop of param.properties) { + if (prop.type === "RestElement") { + extractIdentifiers(prop.argument, nodes); + } else { + extractIdentifiers(prop.value, nodes); + } + } + break; + case "ArrayPattern": + param.elements.forEach((element) => { + if (element) extractIdentifiers(element, nodes); + }); + break; + case "RestElement": + extractIdentifiers(param.argument, nodes); + break; + case "AssignmentPattern": + extractIdentifiers(param.left, nodes); + break; + } + return nodes; +} +function markKnownIds(name, knownIds) { + if (name in knownIds) { + knownIds[name]++; + } else { + knownIds[name] = 1; + } +} +function markScopeIdentifier(node, child, knownIds) { + const { name } = child; + if (node.scopeIds && node.scopeIds.has(name)) { + return; + } + markKnownIds(name, knownIds); + (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name); +} +const isFunctionType = (node) => { + return /Function(?:Expression|Declaration)$|Method$/.test(node.type); +}; +const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed; +const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node; +function isReferenced(node, parent, grandparent) { + switch (parent.type) { + // yes: PARENT[NODE] + // yes: NODE.child + // no: parent.NODE + case "MemberExpression": + case "OptionalMemberExpression": + if (parent.property === node) { + return !!parent.computed; + } + return parent.object === node; + case "JSXMemberExpression": + return parent.object === node; + // no: let NODE = init; + // yes: let id = NODE; + case "VariableDeclarator": + return parent.init === node; + // yes: () => NODE + // no: (NODE) => {} + case "ArrowFunctionExpression": + return parent.body === node; + // no: class { #NODE; } + // no: class { get #NODE() {} } + // no: class { #NODE() {} } + // no: class { fn() { return this.#NODE; } } + case "PrivateName": + return false; + // no: class { NODE() {} } + // yes: class { [NODE]() {} } + // no: class { foo(NODE) {} } + case "ClassMethod": + case "ClassPrivateMethod": + case "ObjectMethod": + if (parent.key === node) { + return !!parent.computed; + } + return false; + // yes: { [NODE]: "" } + // no: { NODE: "" } + // depends: { NODE } + // depends: { key: NODE } + case "ObjectProperty": + if (parent.key === node) { + return !!parent.computed; + } + return !grandparent || grandparent.type !== "ObjectPattern"; + // no: class { NODE = value; } + // yes: class { [NODE] = value; } + // yes: class { key = NODE; } + case "ClassProperty": + if (parent.key === node) { + return !!parent.computed; + } + return true; + case "ClassPrivateProperty": + return parent.key !== node; + // no: class NODE {} + // yes: class Foo extends NODE {} + case "ClassDeclaration": + case "ClassExpression": + return parent.superClass === node; + // yes: left = NODE; + // no: NODE = right; + case "AssignmentExpression": + return parent.right === node; + // no: [NODE = foo] = []; + // yes: [foo = NODE] = []; + case "AssignmentPattern": + return parent.right === node; + // no: NODE: for (;;) {} + case "LabeledStatement": + return false; + // no: try {} catch (NODE) {} + case "CatchClause": + return false; + // no: function foo(...NODE) {} + case "RestElement": + return false; + case "BreakStatement": + case "ContinueStatement": + return false; + // no: function NODE() {} + // no: function foo(NODE) {} + case "FunctionDeclaration": + case "FunctionExpression": + return false; + // no: export NODE from "foo"; + // no: export * as NODE from "foo"; + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + return false; + // no: export { foo as NODE }; + // yes: export { NODE as foo }; + // no: export { NODE as foo } from "foo"; + case "ExportSpecifier": + if (grandparent == null ? void 0 : grandparent.source) { + return false; + } + return parent.local === node; + // no: import NODE from "foo"; + // no: import * as NODE from "foo"; + // no: import { NODE as foo } from "foo"; + // no: import { foo as NODE } from "foo"; + // no: import NODE from "bar"; + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + return false; + // no: import "foo" assert { NODE: "json" } + case "ImportAttribute": + return false; + // no: <div NODE="foo" /> + case "JSXAttribute": + return false; + // no: [NODE] = []; + // no: ({ NODE }) = []; + case "ObjectPattern": + case "ArrayPattern": + return false; + // no: new.NODE + // no: NODE.target + case "MetaProperty": + return false; + // yes: type X = { someProperty: NODE } + // no: type X = { NODE: OtherType } + case "ObjectTypeProperty": + return parent.key !== node; + // yes: enum X { Foo = NODE } + // no: enum X { NODE } + case "TSEnumMember": + return parent.id !== node; + // yes: { [NODE]: value } + // no: { NODE: value } + case "TSPropertySignature": + if (parent.key === node) { + return !!parent.computed; + } + return true; + } + return true; +} +const TS_NODE_TYPES = [ + "TSAsExpression", + // foo as number + "TSTypeAssertion", + // (<number>foo) + "TSNonNullExpression", + // foo! + "TSInstantiationExpression", + // foo<string> + "TSSatisfiesExpression" + // foo satisfies T +]; +function unwrapTSNode(node) { + if (TS_NODE_TYPES.includes(node.type)) { + return unwrapTSNode(node.expression); + } else { + return node; + } +} + +const isStaticExp = (p) => p.type === 4 && p.isStatic; +function isCoreComponent(tag) { + switch (tag) { + case "Teleport": + case "teleport": + return TELEPORT; + case "Suspense": + case "suspense": + return SUSPENSE; + case "KeepAlive": + case "keep-alive": + return KEEP_ALIVE; + case "BaseTransition": + case "base-transition": + return BASE_TRANSITION; + } +} +const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/; +const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name); +const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/; +const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/; +const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g; +const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source; +const isMemberExpressionBrowser = (exp) => { + const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim()); + let state = 0 /* inMemberExp */; + let stateStack = []; + let currentOpenBracketCount = 0; + let currentOpenParensCount = 0; + let currentStringType = null; + for (let i = 0; i < path.length; i++) { + const char = path.charAt(i); + switch (state) { + case 0 /* inMemberExp */: + if (char === "[") { + stateStack.push(state); + state = 1 /* inBrackets */; + currentOpenBracketCount++; + } else if (char === "(") { + stateStack.push(state); + state = 2 /* inParens */; + currentOpenParensCount++; + } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) { + return false; + } + break; + case 1 /* inBrackets */: + if (char === `'` || char === `"` || char === "`") { + stateStack.push(state); + state = 3 /* inString */; + currentStringType = char; + } else if (char === `[`) { + currentOpenBracketCount++; + } else if (char === `]`) { + if (!--currentOpenBracketCount) { + state = stateStack.pop(); + } + } + break; + case 2 /* inParens */: + if (char === `'` || char === `"` || char === "`") { + stateStack.push(state); + state = 3 /* inString */; + currentStringType = char; + } else if (char === `(`) { + currentOpenParensCount++; + } else if (char === `)`) { + if (i === path.length - 1) { + return false; + } + if (!--currentOpenParensCount) { + state = stateStack.pop(); + } + } + break; + case 3 /* inString */: + if (char === currentStringType) { + state = stateStack.pop(); + currentStringType = null; + } + break; + } + } + return !currentOpenBracketCount && !currentOpenParensCount; +}; +const isMemberExpressionNode = (exp, context) => { + try { + let ret = exp.ast || parser.parseExpression(getExpSource(exp), { + plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] + }); + ret = unwrapTSNode(ret); + return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined"; + } catch (e) { + return false; + } +}; +const isMemberExpression = isMemberExpressionNode; +const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/; +const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp)); +const isFnExpressionNode = (exp, context) => { + try { + let ret = exp.ast || parser.parseExpression(getExpSource(exp), { + plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] + }); + if (ret.type === "Program") { + ret = ret.body[0]; + if (ret.type === "ExpressionStatement") { + ret = ret.expression; + } + } + ret = unwrapTSNode(ret); + return ret.type === "FunctionExpression" || ret.type === "ArrowFunctionExpression"; + } catch (e) { + return false; + } +}; +const isFnExpression = isFnExpressionNode; +function advancePositionWithClone(pos, source, numberOfCharacters = source.length) { + return advancePositionWithMutation( + { + offset: pos.offset, + line: pos.line, + column: pos.column + }, + source, + numberOfCharacters + ); +} +function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) { + let linesCount = 0; + let lastNewLinePos = -1; + for (let i = 0; i < numberOfCharacters; i++) { + if (source.charCodeAt(i) === 10) { + linesCount++; + lastNewLinePos = i; + } + } + pos.offset += numberOfCharacters; + pos.line += linesCount; + pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos; + return pos; +} +function assert(condition, msg) { + if (!condition) { + throw new Error(msg || `unexpected compiler condition`); + } +} +function findDir(node, name, allowEmpty = false) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) { + return p; + } + } +} +function findProp(node, name, dynamicOnly = false, allowEmpty = false) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + if (dynamicOnly) continue; + if (p.name === name && (p.value || allowEmpty)) { + return p; + } + } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) { + return p; + } + } +} +function isStaticArgOf(arg, name) { + return !!(arg && isStaticExp(arg) && arg.content === name); +} +function hasDynamicKeyVBind(node) { + return node.props.some( + (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj" + p.arg.type !== 4 || // v-bind:[_ctx.foo] + !p.arg.isStatic) + // v-bind:[foo] + ); +} +function isText$1(node) { + return node.type === 5 || node.type === 2; +} +function isVPre(p) { + return p.type === 7 && p.name === "pre"; +} +function isVSlot(p) { + return p.type === 7 && p.name === "slot"; +} +function isTemplateNode(node) { + return node.type === 1 && node.tagType === 3; +} +function isSlotOutlet(node) { + return node.type === 1 && node.tagType === 2; +} +const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]); +function getUnnormalizedProps(props, callPath = []) { + if (props && !shared.isString(props) && props.type === 14) { + const callee = props.callee; + if (!shared.isString(callee) && propsHelperSet.has(callee)) { + return getUnnormalizedProps( + props.arguments[0], + callPath.concat(props) + ); + } + } + return [props, callPath]; +} +function injectProp(node, prop, context) { + let propsWithInjection; + let props = node.type === 13 ? node.props : node.arguments[2]; + let callPath = []; + let parentCall; + if (props && !shared.isString(props) && props.type === 14) { + const ret = getUnnormalizedProps(props); + props = ret[0]; + callPath = ret[1]; + parentCall = callPath[callPath.length - 1]; + } + if (props == null || shared.isString(props)) { + propsWithInjection = createObjectExpression([prop]); + } else if (props.type === 14) { + const first = props.arguments[0]; + if (!shared.isString(first) && first.type === 15) { + if (!hasProp(prop, first)) { + first.properties.unshift(prop); + } + } else { + if (props.callee === TO_HANDLERS) { + propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ + createObjectExpression([prop]), + props + ]); + } else { + props.arguments.unshift(createObjectExpression([prop])); + } + } + !propsWithInjection && (propsWithInjection = props); + } else if (props.type === 15) { + if (!hasProp(prop, props)) { + props.properties.unshift(prop); + } + propsWithInjection = props; + } else { + propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ + createObjectExpression([prop]), + props + ]); + if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) { + parentCall = callPath[callPath.length - 2]; + } + } + if (node.type === 13) { + if (parentCall) { + parentCall.arguments[0] = propsWithInjection; + } else { + node.props = propsWithInjection; + } + } else { + if (parentCall) { + parentCall.arguments[0] = propsWithInjection; + } else { + node.arguments[2] = propsWithInjection; + } + } +} +function hasProp(prop, props) { + let result = false; + if (prop.key.type === 4) { + const propKeyName = prop.key.content; + result = props.properties.some( + (p) => p.key.type === 4 && p.key.content === propKeyName + ); + } + return result; +} +function toValidAssetId(name, type) { + return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => { + return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString(); + })}`; +} +function hasScopeRef(node, ids) { + if (!node || Object.keys(ids).length === 0) { + return false; + } + switch (node.type) { + case 1: + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) { + return true; + } + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 11: + if (hasScopeRef(node.source, ids)) { + return true; + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 9: + return node.branches.some((b) => hasScopeRef(b, ids)); + case 10: + if (hasScopeRef(node.condition, ids)) { + return true; + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 4: + return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content]; + case 8: + return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids)); + case 5: + case 12: + return hasScopeRef(node.content, ids); + case 2: + case 3: + case 20: + return false; + default: + return false; + } +} +function getMemoedVNodeCall(node) { + if (node.type === 14 && node.callee === WITH_MEMO) { + return node.arguments[1].returns; + } else { + return node; + } +} +const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/; +function isAllWhitespace(str) { + for (let i = 0; i < str.length; i++) { + if (!isWhitespace(str.charCodeAt(i))) { + return false; + } + } + return true; +} +function isWhitespaceText(node) { + return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content); +} +function isCommentOrWhitespace(node) { + return node.type === 3 || isWhitespaceText(node); +} + +const defaultParserOptions = { + parseMode: "base", + ns: 0, + delimiters: [`{{`, `}}`], + getNamespace: () => 0, + isVoidTag: shared.NO, + isPreTag: shared.NO, + isIgnoreNewlineTag: shared.NO, + isCustomElement: shared.NO, + onError: defaultOnError, + onWarn: defaultOnWarn, + comments: false, + prefixIdentifiers: false +}; +let currentOptions = defaultParserOptions; +let currentRoot = null; +let currentInput = ""; +let currentOpenTag = null; +let currentProp = null; +let currentAttrValue = ""; +let currentAttrStartIndex = -1; +let currentAttrEndIndex = -1; +let inPre = 0; +let inVPre = false; +let currentVPreBoundary = null; +const stack = []; +const tokenizer = new Tokenizer(stack, { + onerr: emitError, + ontext(start, end) { + onText(getSlice(start, end), start, end); + }, + ontextentity(char, start, end) { + onText(char, start, end); + }, + oninterpolation(start, end) { + if (inVPre) { + return onText(getSlice(start, end), start, end); + } + let innerStart = start + tokenizer.delimiterOpen.length; + let innerEnd = end - tokenizer.delimiterClose.length; + while (isWhitespace(currentInput.charCodeAt(innerStart))) { + innerStart++; + } + while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) { + innerEnd--; + } + let exp = getSlice(innerStart, innerEnd); + if (exp.includes("&")) { + { + exp = decode.decodeHTML(exp); + } + } + addNode({ + type: 5, + content: createExp(exp, false, getLoc(innerStart, innerEnd)), + loc: getLoc(start, end) + }); + }, + onopentagname(start, end) { + const name = getSlice(start, end); + currentOpenTag = { + type: 1, + tag: name, + ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns), + tagType: 0, + // will be refined on tag close + props: [], + children: [], + loc: getLoc(start - 1, end), + codegenNode: void 0 + }; + }, + onopentagend(end) { + endOpenTag(end); + }, + onclosetag(start, end) { + const name = getSlice(start, end); + if (!currentOptions.isVoidTag(name)) { + let found = false; + for (let i = 0; i < stack.length; i++) { + const e = stack[i]; + if (e.tag.toLowerCase() === name.toLowerCase()) { + found = true; + if (i > 0) { + emitError(24, stack[0].loc.start.offset); + } + for (let j = 0; j <= i; j++) { + const el = stack.shift(); + onCloseTag(el, end, j < i); + } + break; + } + } + if (!found) { + emitError(23, backTrack(start, 60)); + } + } + }, + onselfclosingtag(end) { + const name = currentOpenTag.tag; + currentOpenTag.isSelfClosing = true; + endOpenTag(end); + if (stack[0] && stack[0].tag === name) { + onCloseTag(stack.shift(), end); + } + }, + onattribname(start, end) { + currentProp = { + type: 6, + name: getSlice(start, end), + nameLoc: getLoc(start, end), + value: void 0, + loc: getLoc(start) + }; + }, + ondirname(start, end) { + const raw = getSlice(start, end); + const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2); + if (!inVPre && name === "") { + emitError(26, start); + } + if (inVPre || name === "") { + currentProp = { + type: 6, + name: raw, + nameLoc: getLoc(start, end), + value: void 0, + loc: getLoc(start) + }; + } else { + currentProp = { + type: 7, + name, + rawName: raw, + exp: void 0, + arg: void 0, + modifiers: raw === "." ? [createSimpleExpression("prop")] : [], + loc: getLoc(start) + }; + if (name === "pre") { + inVPre = tokenizer.inVPre = true; + currentVPreBoundary = currentOpenTag; + const props = currentOpenTag.props; + for (let i = 0; i < props.length; i++) { + if (props[i].type === 7) { + props[i] = dirToAttr(props[i]); + } + } + } + } + }, + ondirarg(start, end) { + if (start === end) return; + const arg = getSlice(start, end); + if (inVPre && !isVPre(currentProp)) { + currentProp.name += arg; + setLocEnd(currentProp.nameLoc, end); + } else { + const isStatic = arg[0] !== `[`; + currentProp.arg = createExp( + isStatic ? arg : arg.slice(1, -1), + isStatic, + getLoc(start, end), + isStatic ? 3 : 0 + ); + } + }, + ondirmodifier(start, end) { + const mod = getSlice(start, end); + if (inVPre && !isVPre(currentProp)) { + currentProp.name += "." + mod; + setLocEnd(currentProp.nameLoc, end); + } else if (currentProp.name === "slot") { + const arg = currentProp.arg; + if (arg) { + arg.content += "." + mod; + setLocEnd(arg.loc, end); + } + } else { + const exp = createSimpleExpression(mod, true, getLoc(start, end)); + currentProp.modifiers.push(exp); + } + }, + onattribdata(start, end) { + currentAttrValue += getSlice(start, end); + if (currentAttrStartIndex < 0) currentAttrStartIndex = start; + currentAttrEndIndex = end; + }, + onattribentity(char, start, end) { + currentAttrValue += char; + if (currentAttrStartIndex < 0) currentAttrStartIndex = start; + currentAttrEndIndex = end; + }, + onattribnameend(end) { + const start = currentProp.loc.start.offset; + const name = getSlice(start, end); + if (currentProp.type === 7) { + currentProp.rawName = name; + } + if (currentOpenTag.props.some( + (p) => (p.type === 7 ? p.rawName : p.name) === name + )) { + emitError(2, start); + } + }, + onattribend(quote, end) { + if (currentOpenTag && currentProp) { + setLocEnd(currentProp.loc, end); + if (quote !== 0) { + if (currentProp.type === 6) { + if (currentProp.name === "class") { + currentAttrValue = condense(currentAttrValue).trim(); + } + if (quote === 1 && !currentAttrValue) { + emitError(13, end); + } + currentProp.value = { + type: 2, + content: currentAttrValue, + loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1) + }; + if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") { + tokenizer.enterRCDATA(toCharCodes(`</template`), 0); + } + } else { + let expParseMode = 0 /* Normal */; + { + if (currentProp.name === "for") { + expParseMode = 3 /* Skip */; + } else if (currentProp.name === "slot") { + expParseMode = 1 /* Params */; + } else if (currentProp.name === "on" && currentAttrValue.includes(";")) { + expParseMode = 2 /* Statements */; + } + } + currentProp.exp = createExp( + currentAttrValue, + false, + getLoc(currentAttrStartIndex, currentAttrEndIndex), + 0, + expParseMode + ); + if (currentProp.name === "for") { + currentProp.forParseResult = parseForExpression(currentProp.exp); + } + let syncIndex = -1; + if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex( + (mod) => mod.content === "sync" + )) > -1 && checkCompatEnabled( + "COMPILER_V_BIND_SYNC", + currentOptions, + currentProp.loc, + currentProp.arg.loc.source + )) { + currentProp.name = "model"; + currentProp.modifiers.splice(syncIndex, 1); + } + } + } + if (currentProp.type !== 7 || currentProp.name !== "pre") { + currentOpenTag.props.push(currentProp); + } + } + currentAttrValue = ""; + currentAttrStartIndex = currentAttrEndIndex = -1; + }, + oncomment(start, end) { + if (currentOptions.comments) { + addNode({ + type: 3, + content: getSlice(start, end), + loc: getLoc(start - 4, end + 3) + }); + } + }, + onend() { + const end = currentInput.length; + if (tokenizer.state !== 1) { + switch (tokenizer.state) { + case 5: + case 8: + emitError(5, end); + break; + case 3: + case 4: + emitError( + 25, + tokenizer.sectionStart + ); + break; + case 28: + if (tokenizer.currentSequence === Sequences.CdataEnd) { + emitError(6, end); + } else { + emitError(7, end); + } + break; + case 6: + case 7: + case 9: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + // " + case 20: + // ' + case 21: + emitError(9, end); + break; + } + } + for (let index = 0; index < stack.length; index++) { + onCloseTag(stack[index], end - 1); + emitError(24, stack[index].loc.start.offset); + } + }, + oncdata(start, end) { + if (stack[0].ns !== 0) { + onText(getSlice(start, end), start, end); + } else { + emitError(1, start - 9); + } + }, + onprocessinginstruction(start) { + if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) { + emitError( + 21, + start - 1 + ); + } + } +}); +const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; +const stripParensRE = /^\(|\)$/g; +function parseForExpression(input) { + const loc = input.loc; + const exp = input.content; + const inMatch = exp.match(forAliasRE); + if (!inMatch) return; + const [, LHS, RHS] = inMatch; + const createAliasExpression = (content, offset, asParam = false) => { + const start = loc.start.offset + offset; + const end = start + content.length; + return createExp( + content, + false, + getLoc(start, end), + 0, + asParam ? 1 /* Params */ : 0 /* Normal */ + ); + }; + const result = { + source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)), + value: void 0, + key: void 0, + index: void 0, + finalized: false + }; + let valueContent = LHS.trim().replace(stripParensRE, "").trim(); + const trimmedOffset = LHS.indexOf(valueContent); + const iteratorMatch = valueContent.match(forIteratorRE); + if (iteratorMatch) { + valueContent = valueContent.replace(forIteratorRE, "").trim(); + const keyContent = iteratorMatch[1].trim(); + let keyOffset; + if (keyContent) { + keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length); + result.key = createAliasExpression(keyContent, keyOffset, true); + } + if (iteratorMatch[2]) { + const indexContent = iteratorMatch[2].trim(); + if (indexContent) { + result.index = createAliasExpression( + indexContent, + exp.indexOf( + indexContent, + result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length + ), + true + ); + } + } + } + if (valueContent) { + result.value = createAliasExpression(valueContent, trimmedOffset, true); + } + return result; +} +function getSlice(start, end) { + return currentInput.slice(start, end); +} +function endOpenTag(end) { + if (tokenizer.inSFCRoot) { + currentOpenTag.innerLoc = getLoc(end + 1, end + 1); + } + addNode(currentOpenTag); + const { tag, ns } = currentOpenTag; + if (ns === 0 && currentOptions.isPreTag(tag)) { + inPre++; + } + if (currentOptions.isVoidTag(tag)) { + onCloseTag(currentOpenTag, end); + } else { + stack.unshift(currentOpenTag); + if (ns === 1 || ns === 2) { + tokenizer.inXML = true; + } + } + currentOpenTag = null; +} +function onText(content, start, end) { + const parent = stack[0] || currentRoot; + const lastNode = parent.children[parent.children.length - 1]; + if (lastNode && lastNode.type === 2) { + lastNode.content += content; + setLocEnd(lastNode.loc, end); + } else { + parent.children.push({ + type: 2, + content, + loc: getLoc(start, end) + }); + } +} +function onCloseTag(el, end, isImplied = false) { + if (isImplied) { + setLocEnd(el.loc, backTrack(end, 60)); + } else { + setLocEnd(el.loc, lookAhead(end, 62) + 1); + } + if (tokenizer.inSFCRoot) { + if (el.children.length) { + el.innerLoc.end = shared.extend({}, el.children[el.children.length - 1].loc.end); + } else { + el.innerLoc.end = shared.extend({}, el.innerLoc.start); + } + el.innerLoc.source = getSlice( + el.innerLoc.start.offset, + el.innerLoc.end.offset + ); + } + const { tag, ns, children } = el; + if (!inVPre) { + if (tag === "slot") { + el.tagType = 2; + } else if (isFragmentTemplate(el)) { + el.tagType = 3; + } else if (isComponent(el)) { + el.tagType = 1; + } + } + if (!tokenizer.inRCDATA) { + el.children = condenseWhitespace(children); + } + if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) { + const first = children[0]; + if (first && first.type === 2) { + first.content = first.content.replace(/^\r?\n/, ""); + } + } + if (ns === 0 && currentOptions.isPreTag(tag)) { + inPre--; + } + if (currentVPreBoundary === el) { + inVPre = tokenizer.inVPre = false; + currentVPreBoundary = null; + } + if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) { + tokenizer.inXML = false; + } + { + const props = el.props; + if (!tokenizer.inSFCRoot && isCompatEnabled( + "COMPILER_NATIVE_TEMPLATE", + currentOptions + ) && el.tag === "template" && !isFragmentTemplate(el)) { + const parent = stack[0] || currentRoot; + const index = parent.children.indexOf(el); + parent.children.splice(index, 1, ...el.children); + } + const inlineTemplateProp = props.find( + (p) => p.type === 6 && p.name === "inline-template" + ); + if (inlineTemplateProp && checkCompatEnabled( + "COMPILER_INLINE_TEMPLATE", + currentOptions, + inlineTemplateProp.loc + ) && el.children.length) { + inlineTemplateProp.value = { + type: 2, + content: getSlice( + el.children[0].loc.start.offset, + el.children[el.children.length - 1].loc.end.offset + ), + loc: inlineTemplateProp.loc + }; + } + } +} +function lookAhead(index, c) { + let i = index; + while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++; + return i; +} +function backTrack(index, c) { + let i = index; + while (currentInput.charCodeAt(i) !== c && i >= 0) i--; + return i; +} +const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]); +function isFragmentTemplate({ tag, props }) { + if (tag === "template") { + for (let i = 0; i < props.length; i++) { + if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) { + return true; + } + } + } + return false; +} +function isComponent({ tag, props }) { + if (currentOptions.isCustomElement(tag)) { + return false; + } + if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) { + return true; + } + for (let i = 0; i < props.length; i++) { + const p = props[i]; + if (p.type === 6) { + if (p.name === "is" && p.value) { + if (p.value.content.startsWith("vue:")) { + return true; + } else if (checkCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + currentOptions, + p.loc + )) { + return true; + } + } + } else if (// :is on plain element - only treat as component in compat mode + p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + currentOptions, + p.loc + )) { + return true; + } + } + return false; +} +function isUpperCase(c) { + return c > 64 && c < 91; +} +const windowsNewlineRE = /\r\n/g; +function condenseWhitespace(nodes) { + const shouldCondense = currentOptions.whitespace !== "preserve"; + let removedWhitespace = false; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === 2) { + if (!inPre) { + if (isAllWhitespace(node.content)) { + const prev = nodes[i - 1] && nodes[i - 1].type; + const next = nodes[i + 1] && nodes[i + 1].type; + if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) { + removedWhitespace = true; + nodes[i] = null; + } else { + node.content = " "; + } + } else if (shouldCondense) { + node.content = condense(node.content); + } + } else { + node.content = node.content.replace(windowsNewlineRE, "\n"); + } + } + } + return removedWhitespace ? nodes.filter(Boolean) : nodes; +} +function hasNewlineChar(str) { + for (let i = 0; i < str.length; i++) { + const c = str.charCodeAt(i); + if (c === 10 || c === 13) { + return true; + } + } + return false; +} +function condense(str) { + let ret = ""; + let prevCharIsWhitespace = false; + for (let i = 0; i < str.length; i++) { + if (isWhitespace(str.charCodeAt(i))) { + if (!prevCharIsWhitespace) { + ret += " "; + prevCharIsWhitespace = true; + } + } else { + ret += str[i]; + prevCharIsWhitespace = false; + } + } + return ret; +} +function addNode(node) { + (stack[0] || currentRoot).children.push(node); +} +function getLoc(start, end) { + return { + start: tokenizer.getPos(start), + // @ts-expect-error allow late attachment + end: end == null ? end : tokenizer.getPos(end), + // @ts-expect-error allow late attachment + source: end == null ? end : getSlice(start, end) + }; +} +function cloneLoc(loc) { + return getLoc(loc.start.offset, loc.end.offset); +} +function setLocEnd(loc, end) { + loc.end = tokenizer.getPos(end); + loc.source = getSlice(loc.start.offset, end); +} +function dirToAttr(dir) { + const attr = { + type: 6, + name: dir.rawName, + nameLoc: getLoc( + dir.loc.start.offset, + dir.loc.start.offset + dir.rawName.length + ), + value: void 0, + loc: dir.loc + }; + if (dir.exp) { + const loc = dir.exp.loc; + if (loc.end.offset < dir.loc.end.offset) { + loc.start.offset--; + loc.start.column--; + loc.end.offset++; + loc.end.column++; + } + attr.value = { + type: 2, + content: dir.exp.content, + loc + }; + } + return attr; +} +function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) { + const exp = createSimpleExpression(content, isStatic, loc, constType); + if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 /* Skip */ && content.trim()) { + if (isSimpleIdentifier(content)) { + exp.ast = null; + return exp; + } + try { + const plugins = currentOptions.expressionPlugins; + const options = { + plugins: plugins ? [...plugins, "typescript"] : ["typescript"] + }; + if (parseMode === 2 /* Statements */) { + exp.ast = parser.parse(` ${content} `, options).program; + } else if (parseMode === 1 /* Params */) { + exp.ast = parser.parseExpression(`(${content})=>{}`, options); + } else { + exp.ast = parser.parseExpression(`(${content})`, options); + } + } catch (e) { + exp.ast = false; + emitError(46, loc.start.offset, e.message); + } + } + return exp; +} +function emitError(code, index, message) { + currentOptions.onError( + createCompilerError(code, getLoc(index, index), void 0, message) + ); +} +function reset() { + tokenizer.reset(); + currentOpenTag = null; + currentProp = null; + currentAttrValue = ""; + currentAttrStartIndex = -1; + currentAttrEndIndex = -1; + stack.length = 0; +} +function baseParse(input, options) { + reset(); + currentInput = input; + currentOptions = shared.extend({}, defaultParserOptions); + if (options) { + let key; + for (key in options) { + if (options[key] != null) { + currentOptions[key] = options[key]; + } + } + } + tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0; + tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2; + const delimiters = options && options.delimiters; + if (delimiters) { + tokenizer.delimiterOpen = toCharCodes(delimiters[0]); + tokenizer.delimiterClose = toCharCodes(delimiters[1]); + } + const root = currentRoot = createRoot([], input); + tokenizer.parse(currentInput); + root.loc = getLoc(0, input.length); + root.children = condenseWhitespace(root.children); + currentRoot = null; + return root; +} + +function cacheStatic(root, context) { + walk( + root, + void 0, + context, + // Root node is unfortunately non-hoistable due to potential parent + // fallthrough attributes. + !!getSingleElementRoot(root) + ); +} +function getSingleElementRoot(root) { + const children = root.children.filter((x) => x.type !== 3); + return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null; +} +function walk(node, parent, context, doNotHoistNode = false, inFor = false) { + const { children } = node; + const toCache = []; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (child.type === 1 && child.tagType === 0) { + const constantType = doNotHoistNode ? 0 : getConstantType(child, context); + if (constantType > 0) { + if (constantType >= 2) { + child.codegenNode.patchFlag = -1; + toCache.push(child); + continue; + } + } else { + const codegenNode = child.codegenNode; + if (codegenNode.type === 13) { + const flag = codegenNode.patchFlag; + if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) { + const props = getNodeProps(child); + if (props) { + codegenNode.props = context.hoist(props); + } + } + if (codegenNode.dynamicProps) { + codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps); + } + } + } + } else if (child.type === 12) { + const constantType = doNotHoistNode ? 0 : getConstantType(child, context); + if (constantType >= 2) { + if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) { + child.codegenNode.arguments.push( + -1 + (``) + ); + } + toCache.push(child); + continue; + } + } + if (child.type === 1) { + const isComponent = child.tagType === 1; + if (isComponent) { + context.scopes.vSlot++; + } + walk(child, node, context, false, inFor); + if (isComponent) { + context.scopes.vSlot--; + } + } else if (child.type === 11) { + walk(child, node, context, child.children.length === 1, true); + } else if (child.type === 9) { + for (let i2 = 0; i2 < child.branches.length; i2++) { + walk( + child.branches[i2], + node, + context, + child.branches[i2].children.length === 1, + inFor + ); + } + } + } + let cachedAsArray = false; + if (toCache.length === children.length && node.type === 1) { + if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) { + node.codegenNode.children = getCacheExpression( + createArrayExpression(node.codegenNode.children) + ); + cachedAsArray = true; + } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared.isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) { + const slot = getSlotNode(node.codegenNode, "default"); + if (slot) { + slot.returns = getCacheExpression( + createArrayExpression(slot.returns) + ); + cachedAsArray = true; + } + } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) { + const slotName = findDir(node, "slot", true); + const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg); + if (slot) { + slot.returns = getCacheExpression( + createArrayExpression(slot.returns) + ); + cachedAsArray = true; + } + } + } + if (!cachedAsArray) { + for (const child of toCache) { + child.codegenNode = context.cache(child.codegenNode); + } + } + function getCacheExpression(value) { + const exp = context.cache(value); + exp.needArraySpread = true; + return exp; + } + function getSlotNode(node2, name) { + if (node2.children && !shared.isArray(node2.children) && node2.children.type === 15) { + const slot = node2.children.properties.find( + (p) => p.key === name || p.key.content === name + ); + return slot && slot.value; + } + } + if (toCache.length && context.transformHoist) { + context.transformHoist(children, context, node); + } +} +function getConstantType(node, context) { + const { constantCache } = context; + switch (node.type) { + case 1: + if (node.tagType !== 0) { + return 0; + } + const cached = constantCache.get(node); + if (cached !== void 0) { + return cached; + } + const codegenNode = node.codegenNode; + if (codegenNode.type !== 13) { + return 0; + } + if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") { + return 0; + } + if (codegenNode.patchFlag === void 0) { + let returnType2 = 3; + const generatedPropsType = getGeneratedPropsConstantType(node, context); + if (generatedPropsType === 0) { + constantCache.set(node, 0); + return 0; + } + if (generatedPropsType < returnType2) { + returnType2 = generatedPropsType; + } + for (let i = 0; i < node.children.length; i++) { + const childType = getConstantType(node.children[i], context); + if (childType === 0) { + constantCache.set(node, 0); + return 0; + } + if (childType < returnType2) { + returnType2 = childType; + } + } + if (returnType2 > 1) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && p.name === "bind" && p.exp) { + const expType = getConstantType(p.exp, context); + if (expType === 0) { + constantCache.set(node, 0); + return 0; + } + if (expType < returnType2) { + returnType2 = expType; + } + } + } + } + if (codegenNode.isBlock) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7) { + constantCache.set(node, 0); + return 0; + } + } + context.removeHelper(OPEN_BLOCK); + context.removeHelper( + getVNodeBlockHelper(context.inSSR, codegenNode.isComponent) + ); + codegenNode.isBlock = false; + context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent)); + } + constantCache.set(node, returnType2); + return returnType2; + } else { + constantCache.set(node, 0); + return 0; + } + case 2: + case 3: + return 3; + case 9: + case 11: + case 10: + return 0; + case 5: + case 12: + return getConstantType(node.content, context); + case 4: + return node.constType; + case 8: + let returnType = 3; + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (shared.isString(child) || shared.isSymbol(child)) { + continue; + } + const childType = getConstantType(child, context); + if (childType === 0) { + return 0; + } else if (childType < returnType) { + returnType = childType; + } + } + return returnType; + case 20: + return 2; + default: + return 0; + } +} +const allowHoistedHelperSet = /* @__PURE__ */ new Set([ + NORMALIZE_CLASS, + NORMALIZE_STYLE, + NORMALIZE_PROPS, + GUARD_REACTIVE_PROPS +]); +function getConstantTypeOfHelperCall(value, context) { + if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) { + const arg = value.arguments[0]; + if (arg.type === 4) { + return getConstantType(arg, context); + } else if (arg.type === 14) { + return getConstantTypeOfHelperCall(arg, context); + } + } + return 0; +} +function getGeneratedPropsConstantType(node, context) { + let returnType = 3; + const props = getNodeProps(node); + if (props && props.type === 15) { + const { properties } = props; + for (let i = 0; i < properties.length; i++) { + const { key, value } = properties[i]; + const keyType = getConstantType(key, context); + if (keyType === 0) { + return keyType; + } + if (keyType < returnType) { + returnType = keyType; + } + let valueType; + if (value.type === 4) { + valueType = getConstantType(value, context); + } else if (value.type === 14) { + valueType = getConstantTypeOfHelperCall(value, context); + } else { + valueType = 0; + } + if (valueType === 0) { + return valueType; + } + if (valueType < returnType) { + returnType = valueType; + } + } + } + return returnType; +} +function getNodeProps(node) { + const codegenNode = node.codegenNode; + if (codegenNode.type === 13) { + return codegenNode.props; + } +} + +function createTransformContext(root, { + filename = "", + prefixIdentifiers = false, + hoistStatic = false, + hmr = false, + cacheHandlers = false, + nodeTransforms = [], + directiveTransforms = {}, + transformHoist = null, + isBuiltInComponent = shared.NOOP, + isCustomElement = shared.NOOP, + expressionPlugins = [], + scopeId = null, + slotted = true, + ssr = false, + inSSR = false, + ssrCssVars = ``, + bindingMetadata = shared.EMPTY_OBJ, + inline = false, + isTS = false, + onError = defaultOnError, + onWarn = defaultOnWarn, + compatConfig +}) { + const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/); + const context = { + // options + filename, + selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])), + prefixIdentifiers, + hoistStatic, + hmr, + cacheHandlers, + nodeTransforms, + directiveTransforms, + transformHoist, + isBuiltInComponent, + isCustomElement, + expressionPlugins, + scopeId, + slotted, + ssr, + inSSR, + ssrCssVars, + bindingMetadata, + inline, + isTS, + onError, + onWarn, + compatConfig, + // state + root, + helpers: /* @__PURE__ */ new Map(), + components: /* @__PURE__ */ new Set(), + directives: /* @__PURE__ */ new Set(), + hoists: [], + imports: [], + cached: [], + constantCache: /* @__PURE__ */ new WeakMap(), + temps: 0, + identifiers: /* @__PURE__ */ Object.create(null), + scopes: { + vFor: 0, + vSlot: 0, + vPre: 0, + vOnce: 0 + }, + parent: null, + grandParent: null, + currentNode: root, + childIndex: 0, + inVOnce: false, + // methods + helper(name) { + const count = context.helpers.get(name) || 0; + context.helpers.set(name, count + 1); + return name; + }, + removeHelper(name) { + const count = context.helpers.get(name); + if (count) { + const currentCount = count - 1; + if (!currentCount) { + context.helpers.delete(name); + } else { + context.helpers.set(name, currentCount); + } + } + }, + helperString(name) { + return `_${helperNameMap[context.helper(name)]}`; + }, + replaceNode(node) { + context.parent.children[context.childIndex] = context.currentNode = node; + }, + removeNode(node) { + const list = context.parent.children; + const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1; + if (!node || node === context.currentNode) { + context.currentNode = null; + context.onNodeRemoved(); + } else { + if (context.childIndex > removalIndex) { + context.childIndex--; + context.onNodeRemoved(); + } + } + context.parent.children.splice(removalIndex, 1); + }, + onNodeRemoved: shared.NOOP, + addIdentifiers(exp) { + { + if (shared.isString(exp)) { + addId(exp); + } else if (exp.identifiers) { + exp.identifiers.forEach(addId); + } else if (exp.type === 4) { + addId(exp.content); + } + } + }, + removeIdentifiers(exp) { + { + if (shared.isString(exp)) { + removeId(exp); + } else if (exp.identifiers) { + exp.identifiers.forEach(removeId); + } else if (exp.type === 4) { + removeId(exp.content); + } + } + }, + hoist(exp) { + if (shared.isString(exp)) exp = createSimpleExpression(exp); + context.hoists.push(exp); + const identifier = createSimpleExpression( + `_hoisted_${context.hoists.length}`, + false, + exp.loc, + 2 + ); + identifier.hoisted = exp; + return identifier; + }, + cache(exp, isVNode = false, inVOnce = false) { + const cacheExp = createCacheExpression( + context.cached.length, + exp, + isVNode, + inVOnce + ); + context.cached.push(cacheExp); + return cacheExp; + } + }; + { + context.filters = /* @__PURE__ */ new Set(); + } + function addId(id) { + const { identifiers } = context; + if (identifiers[id] === void 0) { + identifiers[id] = 0; + } + identifiers[id]++; + } + function removeId(id) { + context.identifiers[id]--; + } + return context; +} +function transform(root, options) { + const context = createTransformContext(root, options); + traverseNode(root, context); + if (options.hoistStatic) { + cacheStatic(root, context); + } + if (!options.ssr) { + createRootCodegen(root, context); + } + root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]); + root.components = [...context.components]; + root.directives = [...context.directives]; + root.imports = context.imports; + root.hoists = context.hoists; + root.temps = context.temps; + root.cached = context.cached; + root.transformed = true; + { + root.filters = [...context.filters]; + } +} +function createRootCodegen(root, context) { + const { helper } = context; + const { children } = root; + if (children.length === 1) { + const singleElementRootChild = getSingleElementRoot(root); + if (singleElementRootChild && singleElementRootChild.codegenNode) { + const codegenNode = singleElementRootChild.codegenNode; + if (codegenNode.type === 13) { + convertToBlock(codegenNode, context); + } + root.codegenNode = codegenNode; + } else { + root.codegenNode = children[0]; + } + } else if (children.length > 1) { + let patchFlag = 64; + root.codegenNode = createVNodeCall( + context, + helper(FRAGMENT), + void 0, + root.children, + patchFlag, + void 0, + void 0, + true, + void 0, + false + ); + } else ; +} +function traverseChildren(parent, context) { + let i = 0; + const nodeRemoved = () => { + i--; + }; + for (; i < parent.children.length; i++) { + const child = parent.children[i]; + if (shared.isString(child)) continue; + context.grandParent = context.parent; + context.parent = parent; + context.childIndex = i; + context.onNodeRemoved = nodeRemoved; + traverseNode(child, context); + } +} +function traverseNode(node, context) { + context.currentNode = node; + const { nodeTransforms } = context; + const exitFns = []; + for (let i2 = 0; i2 < nodeTransforms.length; i2++) { + const onExit = nodeTransforms[i2](node, context); + if (onExit) { + if (shared.isArray(onExit)) { + exitFns.push(...onExit); + } else { + exitFns.push(onExit); + } + } + if (!context.currentNode) { + return; + } else { + node = context.currentNode; + } + } + switch (node.type) { + case 3: + if (!context.ssr) { + context.helper(CREATE_COMMENT); + } + break; + case 5: + if (!context.ssr) { + context.helper(TO_DISPLAY_STRING); + } + break; + // for container types, further traverse downwards + case 9: + for (let i2 = 0; i2 < node.branches.length; i2++) { + traverseNode(node.branches[i2], context); + } + break; + case 10: + case 11: + case 1: + case 0: + traverseChildren(node, context); + break; + } + context.currentNode = node; + let i = exitFns.length; + while (i--) { + exitFns[i](); + } +} +function createStructuralDirectiveTransform(name, fn) { + const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n); + return (node, context) => { + if (node.type === 1) { + const { props } = node; + if (node.tagType === 3 && props.some(isVSlot)) { + return; + } + const exitFns = []; + for (let i = 0; i < props.length; i++) { + const prop = props[i]; + if (prop.type === 7 && matches(prop.name)) { + props.splice(i, 1); + i--; + const onExit = fn(node, prop, context); + if (onExit) exitFns.push(onExit); + } + } + return exitFns; + } + }; +} + +const PURE_ANNOTATION = `/*@__PURE__*/`; +const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`; +function createCodegenContext(ast, { + mode = "function", + prefixIdentifiers = mode === "module", + sourceMap = false, + filename = `template.vue.html`, + scopeId = null, + optimizeImports = false, + runtimeGlobalName = `Vue`, + runtimeModuleName = `vue`, + ssrRuntimeModuleName = "vue/server-renderer", + ssr = false, + isTS = false, + inSSR = false +}) { + const context = { + mode, + prefixIdentifiers, + sourceMap, + filename, + scopeId, + optimizeImports, + runtimeGlobalName, + runtimeModuleName, + ssrRuntimeModuleName, + ssr, + isTS, + inSSR, + source: ast.source, + code: ``, + column: 1, + line: 1, + offset: 0, + indentLevel: 0, + pure: false, + map: void 0, + helper(key) { + return `_${helperNameMap[key]}`; + }, + push(code, newlineIndex = -2 /* None */, node) { + context.code += code; + if (context.map) { + if (node) { + let name; + if (node.type === 4 && !node.isStatic) { + const content = node.content.replace(/^_ctx\./, ""); + if (content !== node.content && isSimpleIdentifier(content)) { + name = content; + } + } + if (node.loc.source) { + addMapping(node.loc.start, name); + } + } + if (newlineIndex === -3 /* Unknown */) { + advancePositionWithMutation(context, code); + } else { + context.offset += code.length; + if (newlineIndex === -2 /* None */) { + context.column += code.length; + } else { + if (newlineIndex === -1 /* End */) { + newlineIndex = code.length - 1; + } + context.line++; + context.column = code.length - newlineIndex; + } + } + if (node && node.loc !== locStub && node.loc.source) { + addMapping(node.loc.end); + } + } + }, + indent() { + newline(++context.indentLevel); + }, + deindent(withoutNewLine = false) { + if (withoutNewLine) { + --context.indentLevel; + } else { + newline(--context.indentLevel); + } + }, + newline() { + newline(context.indentLevel); + } + }; + function newline(n) { + context.push("\n" + ` `.repeat(n), 0 /* Start */); + } + function addMapping(loc, name = null) { + const { _names, _mappings } = context.map; + if (name !== null && !_names.has(name)) _names.add(name); + _mappings.add({ + originalLine: loc.line, + originalColumn: loc.column - 1, + // source-map column is 0 based + generatedLine: context.line, + generatedColumn: context.column - 1, + source: filename, + name + }); + } + if (sourceMap) { + context.map = new sourceMapJs.SourceMapGenerator(); + context.map.setSourceContent(filename, context.source); + context.map._sources.add(filename); + } + return context; +} +function generate(ast, options = {}) { + const context = createCodegenContext(ast, options); + if (options.onContextCreated) options.onContextCreated(context); + const { + mode, + push, + prefixIdentifiers, + indent, + deindent, + newline, + scopeId, + ssr + } = context; + const helpers = Array.from(ast.helpers); + const hasHelpers = helpers.length > 0; + const useWithBlock = !prefixIdentifiers && mode !== "module"; + const genScopeId = scopeId != null && mode === "module"; + const isSetupInlined = !!options.inline; + const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context; + if (mode === "module") { + genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined); + } else { + genFunctionPreamble(ast, preambleContext); + } + const functionName = ssr ? `ssrRender` : `render`; + const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"]; + if (options.bindingMetadata && !options.inline) { + args.push("$props", "$setup", "$data", "$options"); + } + const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", "); + if (isSetupInlined) { + push(`(${signature}) => {`); + } else { + push(`function ${functionName}(${signature}) {`); + } + indent(); + if (useWithBlock) { + push(`with (_ctx) {`); + indent(); + if (hasHelpers) { + push( + `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue +`, + -1 /* End */ + ); + newline(); + } + } + if (ast.components.length) { + genAssets(ast.components, "component", context); + if (ast.directives.length || ast.temps > 0) { + newline(); + } + } + if (ast.directives.length) { + genAssets(ast.directives, "directive", context); + if (ast.temps > 0) { + newline(); + } + } + if (ast.filters && ast.filters.length) { + newline(); + genAssets(ast.filters, "filter", context); + newline(); + } + if (ast.temps > 0) { + push(`let `); + for (let i = 0; i < ast.temps; i++) { + push(`${i > 0 ? `, ` : ``}_temp${i}`); + } + } + if (ast.components.length || ast.directives.length || ast.temps) { + push(` +`, 0 /* Start */); + newline(); + } + if (!ssr) { + push(`return `); + } + if (ast.codegenNode) { + genNode(ast.codegenNode, context); + } else { + push(`null`); + } + if (useWithBlock) { + deindent(); + push(`}`); + } + deindent(); + push(`}`); + return { + ast, + code: context.code, + preamble: isSetupInlined ? preambleContext.code : ``, + map: context.map ? context.map.toJSON() : void 0 + }; +} +function genFunctionPreamble(ast, context) { + const { + ssr, + prefixIdentifiers, + push, + newline, + runtimeModuleName, + runtimeGlobalName, + ssrRuntimeModuleName + } = context; + const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName; + const helpers = Array.from(ast.helpers); + if (helpers.length > 0) { + if (prefixIdentifiers) { + push( + `const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding} +`, + -1 /* End */ + ); + } else { + push(`const _Vue = ${VueBinding} +`, -1 /* End */); + if (ast.hoists.length) { + const staticHelpers = [ + CREATE_VNODE, + CREATE_ELEMENT_VNODE, + CREATE_COMMENT, + CREATE_TEXT, + CREATE_STATIC + ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", "); + push(`const { ${staticHelpers} } = _Vue +`, -1 /* End */); + } + } + } + if (ast.ssrHelpers && ast.ssrHelpers.length) { + push( + `const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}") +`, + -1 /* End */ + ); + } + genHoists(ast.hoists, context); + newline(); + push(`return `); +} +function genModulePreamble(ast, context, genScopeId, inline) { + const { + push, + newline, + optimizeImports, + runtimeModuleName, + ssrRuntimeModuleName + } = context; + if (ast.helpers.size) { + const helpers = Array.from(ast.helpers); + if (optimizeImports) { + push( + `import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)} +`, + -1 /* End */ + ); + push( + ` +// Binding optimization for webpack code-split +const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")} +`, + -1 /* End */ + ); + } else { + push( + `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)} +`, + -1 /* End */ + ); + } + } + if (ast.ssrHelpers && ast.ssrHelpers.length) { + push( + `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}" +`, + -1 /* End */ + ); + } + if (ast.imports.length) { + genImports(ast.imports, context); + newline(); + } + genHoists(ast.hoists, context); + newline(); + if (!inline) { + push(`export `); + } +} +function genAssets(assets, type, { helper, push, newline, isTS }) { + const resolver = helper( + type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE + ); + for (let i = 0; i < assets.length; i++) { + let id = assets[i]; + const maybeSelfReference = id.endsWith("__self"); + if (maybeSelfReference) { + id = id.slice(0, -6); + } + push( + `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}` + ); + if (i < assets.length - 1) { + newline(); + } + } +} +function genHoists(hoists, context) { + if (!hoists.length) { + return; + } + context.pure = true; + const { push, newline } = context; + newline(); + for (let i = 0; i < hoists.length; i++) { + const exp = hoists[i]; + if (exp) { + push(`const _hoisted_${i + 1} = `); + genNode(exp, context); + newline(); + } + } + context.pure = false; +} +function genImports(importsOptions, context) { + if (!importsOptions.length) { + return; + } + importsOptions.forEach((imports) => { + context.push(`import `); + genNode(imports.exp, context); + context.push(` from '${imports.path}'`); + context.newline(); + }); +} +function isText(n) { + return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8; +} +function genNodeListAsArray(nodes, context) { + const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n)); + context.push(`[`); + multilines && context.indent(); + genNodeList(nodes, context, multilines); + multilines && context.deindent(); + context.push(`]`); +} +function genNodeList(nodes, context, multilines = false, comma = true) { + const { push, newline } = context; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (shared.isString(node)) { + push(node, -3 /* Unknown */); + } else if (shared.isArray(node)) { + genNodeListAsArray(node, context); + } else { + genNode(node, context); + } + if (i < nodes.length - 1) { + if (multilines) { + comma && push(","); + newline(); + } else { + comma && push(", "); + } + } + } +} +function genNode(node, context) { + if (shared.isString(node)) { + context.push(node, -3 /* Unknown */); + return; + } + if (shared.isSymbol(node)) { + context.push(context.helper(node)); + return; + } + switch (node.type) { + case 1: + case 9: + case 11: + genNode(node.codegenNode, context); + break; + case 2: + genText(node, context); + break; + case 4: + genExpression(node, context); + break; + case 5: + genInterpolation(node, context); + break; + case 12: + genNode(node.codegenNode, context); + break; + case 8: + genCompoundExpression(node, context); + break; + case 3: + genComment(node, context); + break; + case 13: + genVNodeCall(node, context); + break; + case 14: + genCallExpression(node, context); + break; + case 15: + genObjectExpression(node, context); + break; + case 17: + genArrayExpression(node, context); + break; + case 18: + genFunctionExpression(node, context); + break; + case 19: + genConditionalExpression(node, context); + break; + case 20: + genCacheExpression(node, context); + break; + case 21: + genNodeList(node.body, context, true, false); + break; + // SSR only types + case 22: + genTemplateLiteral(node, context); + break; + case 23: + genIfStatement(node, context); + break; + case 24: + genAssignmentExpression(node, context); + break; + case 25: + genSequenceExpression(node, context); + break; + case 26: + genReturnStatement(node, context); + break; + } +} +function genText(node, context) { + context.push(JSON.stringify(node.content), -3 /* Unknown */, node); +} +function genExpression(node, context) { + const { content, isStatic } = node; + context.push( + isStatic ? JSON.stringify(content) : content, + -3 /* Unknown */, + node + ); +} +function genInterpolation(node, context) { + const { push, helper, pure } = context; + if (pure) push(PURE_ANNOTATION); + push(`${helper(TO_DISPLAY_STRING)}(`); + genNode(node.content, context); + push(`)`); +} +function genCompoundExpression(node, context) { + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (shared.isString(child)) { + context.push(child, -3 /* Unknown */); + } else { + genNode(child, context); + } + } +} +function genExpressionAsPropertyKey(node, context) { + const { push } = context; + if (node.type === 8) { + push(`[`); + genCompoundExpression(node, context); + push(`]`); + } else if (node.isStatic) { + const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content); + push(text, -2 /* None */, node); + } else { + push(`[${node.content}]`, -3 /* Unknown */, node); + } +} +function genComment(node, context) { + const { push, helper, pure } = context; + if (pure) { + push(PURE_ANNOTATION); + } + push( + `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, + -3 /* Unknown */, + node + ); +} +function genVNodeCall(node, context) { + const { push, helper, pure } = context; + const { + tag, + props, + children, + patchFlag, + dynamicProps, + directives, + isBlock, + disableTracking, + isComponent + } = node; + let patchFlagString; + if (patchFlag) { + { + patchFlagString = String(patchFlag); + } + } + if (directives) { + push(helper(WITH_DIRECTIVES) + `(`); + } + if (isBlock) { + push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `); + } + if (pure) { + push(PURE_ANNOTATION); + } + const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent); + push(helper(callHelper) + `(`, -2 /* None */, node); + genNodeList( + genNullableArgs([tag, props, children, patchFlagString, dynamicProps]), + context + ); + push(`)`); + if (isBlock) { + push(`)`); + } + if (directives) { + push(`, `); + genNode(directives, context); + push(`)`); + } +} +function genNullableArgs(args) { + let i = args.length; + while (i--) { + if (args[i] != null) break; + } + return args.slice(0, i + 1).map((arg) => arg || `null`); +} +function genCallExpression(node, context) { + const { push, helper, pure } = context; + const callee = shared.isString(node.callee) ? node.callee : helper(node.callee); + if (pure) { + push(PURE_ANNOTATION); + } + push(callee + `(`, -2 /* None */, node); + genNodeList(node.arguments, context); + push(`)`); +} +function genObjectExpression(node, context) { + const { push, indent, deindent, newline } = context; + const { properties } = node; + if (!properties.length) { + push(`{}`, -2 /* None */, node); + return; + } + const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4); + push(multilines ? `{` : `{ `); + multilines && indent(); + for (let i = 0; i < properties.length; i++) { + const { key, value } = properties[i]; + genExpressionAsPropertyKey(key, context); + push(`: `); + genNode(value, context); + if (i < properties.length - 1) { + push(`,`); + newline(); + } + } + multilines && deindent(); + push(multilines ? `}` : ` }`); +} +function genArrayExpression(node, context) { + genNodeListAsArray(node.elements, context); +} +function genFunctionExpression(node, context) { + const { push, indent, deindent } = context; + const { params, returns, body, newline, isSlot } = node; + if (isSlot) { + push(`_${helperNameMap[WITH_CTX]}(`); + } + push(`(`, -2 /* None */, node); + if (shared.isArray(params)) { + genNodeList(params, context); + } else if (params) { + genNode(params, context); + } + push(`) => `); + if (newline || body) { + push(`{`); + indent(); + } + if (returns) { + if (newline) { + push(`return `); + } + if (shared.isArray(returns)) { + genNodeListAsArray(returns, context); + } else { + genNode(returns, context); + } + } else if (body) { + genNode(body, context); + } + if (newline || body) { + deindent(); + push(`}`); + } + if (isSlot) { + if (node.isNonScopedSlot) { + push(`, undefined, true`); + } + push(`)`); + } +} +function genConditionalExpression(node, context) { + const { test, consequent, alternate, newline: needNewline } = node; + const { push, indent, deindent, newline } = context; + if (test.type === 4) { + const needsParens = !isSimpleIdentifier(test.content); + needsParens && push(`(`); + genExpression(test, context); + needsParens && push(`)`); + } else { + push(`(`); + genNode(test, context); + push(`)`); + } + needNewline && indent(); + context.indentLevel++; + needNewline || push(` `); + push(`? `); + genNode(consequent, context); + context.indentLevel--; + needNewline && newline(); + needNewline || push(` `); + push(`: `); + const isNested = alternate.type === 19; + if (!isNested) { + context.indentLevel++; + } + genNode(alternate, context); + if (!isNested) { + context.indentLevel--; + } + needNewline && deindent( + true + /* without newline */ + ); +} +function genCacheExpression(node, context) { + const { push, helper, indent, deindent, newline } = context; + const { needPauseTracking, needArraySpread } = node; + if (needArraySpread) { + push(`[...(`); + } + push(`_cache[${node.index}] || (`); + if (needPauseTracking) { + indent(); + push(`${helper(SET_BLOCK_TRACKING)}(-1`); + if (node.inVOnce) push(`, true`); + push(`),`); + newline(); + push(`(`); + } + push(`_cache[${node.index}] = `); + genNode(node.value, context); + if (needPauseTracking) { + push(`).cacheIndex = ${node.index},`); + newline(); + push(`${helper(SET_BLOCK_TRACKING)}(1),`); + newline(); + push(`_cache[${node.index}]`); + deindent(); + } + push(`)`); + if (needArraySpread) { + push(`)]`); + } +} +function genTemplateLiteral(node, context) { + const { push, indent, deindent } = context; + push("`"); + const l = node.elements.length; + const multilines = l > 3; + for (let i = 0; i < l; i++) { + const e = node.elements[i]; + if (shared.isString(e)) { + push(e.replace(/(`|\$|\\)/g, "\\$1"), -3 /* Unknown */); + } else { + push("${"); + if (multilines) indent(); + genNode(e, context); + if (multilines) deindent(); + push("}"); + } + } + push("`"); +} +function genIfStatement(node, context) { + const { push, indent, deindent } = context; + const { test, consequent, alternate } = node; + push(`if (`); + genNode(test, context); + push(`) {`); + indent(); + genNode(consequent, context); + deindent(); + push(`}`); + if (alternate) { + push(` else `); + if (alternate.type === 23) { + genIfStatement(alternate, context); + } else { + push(`{`); + indent(); + genNode(alternate, context); + deindent(); + push(`}`); + } + } +} +function genAssignmentExpression(node, context) { + genNode(node.left, context); + context.push(` = `); + genNode(node.right, context); +} +function genSequenceExpression(node, context) { + context.push(`(`); + genNodeList(node.expressions, context); + context.push(`)`); +} +function genReturnStatement({ returns }, context) { + context.push(`return `); + if (shared.isArray(returns)) { + genNodeListAsArray(returns, context); + } else { + genNode(returns, context); + } +} + +const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this"); +const transformExpression = (node, context) => { + if (node.type === 5) { + node.content = processExpression( + node.content, + context + ); + } else if (node.type === 1) { + const memo = findDir(node, "memo"); + for (let i = 0; i < node.props.length; i++) { + const dir = node.props[i]; + if (dir.type === 7 && dir.name !== "for") { + const exp = dir.exp; + const arg = dir.arg; + if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key has been processed in transformFor(vMemo + vFor) + !(memo && arg && arg.type === 4 && arg.content === "key")) { + dir.exp = processExpression( + exp, + context, + // slot args must be processed as function params + dir.name === "slot" + ); + } + if (arg && arg.type === 4 && !arg.isStatic) { + dir.arg = processExpression(arg, context); + } + } + } + } +}; +function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) { + if (!context.prefixIdentifiers || !node.content.trim()) { + return node; + } + const { inline, bindingMetadata } = context; + const rewriteIdentifier = (raw, parent, id) => { + const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw]; + if (inline) { + const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id; + const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id; + const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack); + const isNewExpression = parent && isInNewExpression(parentStack); + const wrapWithUnref = (raw2) => { + const wrapped = `${context.helperString(UNREF)}(${raw2})`; + return isNewExpression ? `(${wrapped})` : wrapped; + }; + if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) { + return raw; + } else if (type === "setup-ref") { + return `${raw}.value`; + } else if (type === "setup-maybe-ref") { + return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw); + } else if (type === "setup-let") { + if (isAssignmentLVal) { + const { right: rVal, operator } = parent; + const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1); + const rExpString = stringifyExpression( + processExpression( + createSimpleExpression(rExp, false), + context, + false, + false, + knownIds + ) + ); + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore +` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`; + } else if (isUpdateArg) { + id.start = parent.start; + id.end = parent.end; + const { prefix: isPrefix, operator } = parent; + const prefix = isPrefix ? operator : ``; + const postfix = isPrefix ? `` : operator; + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore +` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`; + } else if (isDestructureAssignment) { + return raw; + } else { + return wrapWithUnref(raw); + } + } else if (type === "props") { + return shared.genPropsAccessExp(raw); + } else if (type === "props-aliased") { + return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]); + } + } else { + if (type && type.startsWith("setup") || type === "literal-const") { + return `$setup.${raw}`; + } else if (type === "props-aliased") { + return `$props['${bindingMetadata.__propsAliases[raw]}']`; + } else if (type) { + return `$${type}.${raw}`; + } + } + return `_ctx.${raw}`; + }; + const rawExp = node.content; + let ast = node.ast; + if (ast === false) { + return node; + } + if (ast === null || !ast && isSimpleIdentifier(rawExp)) { + const isScopeVarReference = context.identifiers[rawExp]; + const isAllowedGlobal = shared.isGloballyAllowed(rawExp); + const isLiteral = isLiteralWhitelisted(rawExp); + if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) { + if (isConst(bindingMetadata[rawExp])) { + node.constType = 1; + } + node.content = rewriteIdentifier(rawExp); + } else if (!isScopeVarReference) { + if (isLiteral) { + node.constType = 3; + } else { + node.constType = 2; + } + } + return node; + } + if (!ast) { + const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`; + try { + ast = parser.parseExpression(source, { + sourceType: "module", + plugins: context.expressionPlugins + }); + } catch (e) { + context.onError( + createCompilerError( + 46, + node.loc, + void 0, + e.message + ) + ); + return node; + } + } + const ids = []; + const parentStack = []; + const knownIds = Object.create(context.identifiers); + walkIdentifiers( + ast, + (node2, parent, _, isReferenced, isLocal) => { + if (isStaticPropertyKey(node2, parent)) { + return; + } + if (node2.name.startsWith("_filter_")) { + return; + } + const needPrefix = isReferenced && canPrefix(node2); + if (needPrefix && !isLocal) { + if (isStaticProperty(parent) && parent.shorthand) { + node2.prefix = `${node2.name}: `; + } + node2.name = rewriteIdentifier(node2.name, parent, node2); + ids.push(node2); + } else { + if (!(needPrefix && isLocal) && (!parent || parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression")) { + node2.isConstant = true; + } + ids.push(node2); + } + }, + true, + // invoke on ALL identifiers + parentStack, + knownIds + ); + const children = []; + ids.sort((a, b) => a.start - b.start); + ids.forEach((id, i) => { + const start = id.start - 1; + const end = id.end - 1; + const last = ids[i - 1]; + const leadingText = rawExp.slice(last ? last.end - 1 : 0, start); + if (leadingText.length || id.prefix) { + children.push(leadingText + (id.prefix || ``)); + } + const source = rawExp.slice(start, end); + children.push( + createSimpleExpression( + id.name, + false, + { + start: advancePositionWithClone(node.loc.start, source, start), + end: advancePositionWithClone(node.loc.start, source, end), + source + }, + id.isConstant ? 3 : 0 + ) + ); + if (i === ids.length - 1 && end < rawExp.length) { + children.push(rawExp.slice(end)); + } + }); + let ret; + if (children.length) { + ret = createCompoundExpression(children, node.loc); + ret.ast = ast; + } else { + ret = node; + ret.constType = 3; + } + ret.identifiers = Object.keys(knownIds); + return ret; +} +function canPrefix(id) { + if (shared.isGloballyAllowed(id.name)) { + return false; + } + if (id.name === "require") { + return false; + } + return true; +} +function stringifyExpression(exp) { + if (shared.isString(exp)) { + return exp; + } else if (exp.type === 4) { + return exp.content; + } else { + return exp.children.map(stringifyExpression).join(""); + } +} +function isConst(type) { + return type === "setup-const" || type === "literal-const"; +} + +const transformIf = createStructuralDirectiveTransform( + /^(?:if|else|else-if)$/, + (node, dir, context) => { + return processIf(node, dir, context, (ifNode, branch, isRoot) => { + const siblings = context.parent.children; + let i = siblings.indexOf(ifNode); + let key = 0; + while (i-- >= 0) { + const sibling = siblings[i]; + if (sibling && sibling.type === 9) { + key += sibling.branches.length; + } + } + return () => { + if (isRoot) { + ifNode.codegenNode = createCodegenNodeForBranch( + branch, + key, + context + ); + } else { + const parentCondition = getParentCondition(ifNode.codegenNode); + parentCondition.alternate = createCodegenNodeForBranch( + branch, + key + ifNode.branches.length - 1, + context + ); + } + }; + }); + } +); +function processIf(node, dir, context, processCodegen) { + if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) { + const loc = dir.exp ? dir.exp.loc : node.loc; + context.onError( + createCompilerError(28, dir.loc) + ); + dir.exp = createSimpleExpression(`true`, false, loc); + } + if (context.prefixIdentifiers && dir.exp) { + dir.exp = processExpression(dir.exp, context); + } + if (dir.name === "if") { + const branch = createIfBranch(node, dir); + const ifNode = { + type: 9, + loc: cloneLoc(node.loc), + branches: [branch] + }; + context.replaceNode(ifNode); + if (processCodegen) { + return processCodegen(ifNode, branch, true); + } + } else { + const siblings = context.parent.children; + let i = siblings.indexOf(node); + while (i-- >= -1) { + const sibling = siblings[i]; + if (sibling && isCommentOrWhitespace(sibling)) { + context.removeNode(sibling); + continue; + } + if (sibling && sibling.type === 9) { + if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) { + context.onError( + createCompilerError(30, node.loc) + ); + } + context.removeNode(); + const branch = createIfBranch(node, dir); + { + const key = branch.userKey; + if (key) { + sibling.branches.forEach(({ userKey }) => { + if (isSameKey(userKey, key)) { + context.onError( + createCompilerError( + 29, + branch.userKey.loc + ) + ); + } + }); + } + } + sibling.branches.push(branch); + const onExit = processCodegen && processCodegen(sibling, branch, false); + traverseNode(branch, context); + if (onExit) onExit(); + context.currentNode = null; + } else { + context.onError( + createCompilerError(30, node.loc) + ); + } + break; + } + } +} +function createIfBranch(node, dir) { + const isTemplateIf = node.tagType === 3; + return { + type: 10, + loc: node.loc, + condition: dir.name === "else" ? void 0 : dir.exp, + children: isTemplateIf && !findDir(node, "for") ? node.children : [node], + userKey: findProp(node, `key`), + isTemplateIf + }; +} +function createCodegenNodeForBranch(branch, keyIndex, context) { + if (branch.condition) { + return createConditionalExpression( + branch.condition, + createChildrenCodegenNode(branch, keyIndex, context), + // make sure to pass in asBlock: true so that the comment node call + // closes the current block. + createCallExpression(context.helper(CREATE_COMMENT), [ + '""', + "true" + ]) + ); + } else { + return createChildrenCodegenNode(branch, keyIndex, context); + } +} +function createChildrenCodegenNode(branch, keyIndex, context) { + const { helper } = context; + const keyProperty = createObjectProperty( + `key`, + createSimpleExpression( + `${keyIndex}`, + false, + locStub, + 2 + ) + ); + const { children } = branch; + const firstChild = children[0]; + const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1; + if (needFragmentWrapper) { + if (children.length === 1 && firstChild.type === 11) { + const vnodeCall = firstChild.codegenNode; + injectProp(vnodeCall, keyProperty, context); + return vnodeCall; + } else { + let patchFlag = 64; + return createVNodeCall( + context, + helper(FRAGMENT), + createObjectExpression([keyProperty]), + children, + patchFlag, + void 0, + void 0, + true, + false, + false, + branch.loc + ); + } + } else { + const ret = firstChild.codegenNode; + const vnodeCall = getMemoedVNodeCall(ret); + if (vnodeCall.type === 13) { + convertToBlock(vnodeCall, context); + } + injectProp(vnodeCall, keyProperty, context); + return ret; + } +} +function isSameKey(a, b) { + if (!a || a.type !== b.type) { + return false; + } + if (a.type === 6) { + if (a.value.content !== b.value.content) { + return false; + } + } else { + const exp = a.exp; + const branchExp = b.exp; + if (exp.type !== branchExp.type) { + return false; + } + if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) { + return false; + } + } + return true; +} +function getParentCondition(node) { + while (true) { + if (node.type === 19) { + if (node.alternate.type === 19) { + node = node.alternate; + } else { + return node; + } + } else if (node.type === 20) { + node = node.value; + } + } +} + +const transformFor = createStructuralDirectiveTransform( + "for", + (node, dir, context) => { + const { helper, removeHelper } = context; + return processFor(node, dir, context, (forNode) => { + const renderExp = createCallExpression(helper(RENDER_LIST), [ + forNode.source + ]); + const isTemplate = isTemplateNode(node); + const memo = findDir(node, "memo"); + const keyProp = findProp(node, `key`, false, true); + const isDirKey = keyProp && keyProp.type === 7; + let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp); + if (memo && keyExp && isDirKey) { + { + keyProp.exp = keyExp = processExpression( + keyExp, + context + ); + } + } + const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null; + if (isTemplate) { + if (memo) { + memo.exp = processExpression( + memo.exp, + context + ); + } + if (keyProperty && keyProp.type !== 6) { + keyProperty.value = processExpression( + keyProperty.value, + context + ); + } + } + const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0; + const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256; + forNode.codegenNode = createVNodeCall( + context, + helper(FRAGMENT), + void 0, + renderExp, + fragmentFlag, + void 0, + void 0, + true, + !isStableFragment, + false, + node.loc + ); + return () => { + let childBlock; + const { children } = forNode; + if (isTemplate) { + node.children.some((c) => { + if (c.type === 1) { + const key = findProp(c, "key"); + if (key) { + context.onError( + createCompilerError( + 33, + key.loc + ) + ); + return true; + } + } + }); + } + const needFragmentWrapper = children.length !== 1 || children[0].type !== 1; + const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null; + if (slotOutlet) { + childBlock = slotOutlet.codegenNode; + if (isTemplate && keyProperty) { + injectProp(childBlock, keyProperty, context); + } + } else if (needFragmentWrapper) { + childBlock = createVNodeCall( + context, + helper(FRAGMENT), + keyProperty ? createObjectExpression([keyProperty]) : void 0, + node.children, + 64, + void 0, + void 0, + true, + void 0, + false + ); + } else { + childBlock = children[0].codegenNode; + if (isTemplate && keyProperty) { + injectProp(childBlock, keyProperty, context); + } + if (childBlock.isBlock !== !isStableFragment) { + if (childBlock.isBlock) { + removeHelper(OPEN_BLOCK); + removeHelper( + getVNodeBlockHelper(context.inSSR, childBlock.isComponent) + ); + } else { + removeHelper( + getVNodeHelper(context.inSSR, childBlock.isComponent) + ); + } + } + childBlock.isBlock = !isStableFragment; + if (childBlock.isBlock) { + helper(OPEN_BLOCK); + helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); + } else { + helper(getVNodeHelper(context.inSSR, childBlock.isComponent)); + } + } + if (memo) { + const loop = createFunctionExpression( + createForLoopParams(forNode.parseResult, [ + createSimpleExpression(`_cached`) + ]) + ); + loop.body = createBlockStatement([ + createCompoundExpression([`const _memo = (`, memo.exp, `)`]), + createCompoundExpression([ + `if (_cached`, + ...keyExp ? [` && _cached.key === `, keyExp] : [], + ` && ${context.helperString( + IS_MEMO_SAME + )}(_cached, _memo)) return _cached` + ]), + createCompoundExpression([`const _item = `, childBlock]), + createSimpleExpression(`_item.memo = _memo`), + createSimpleExpression(`return _item`) + ]); + renderExp.arguments.push( + loop, + createSimpleExpression(`_cache`), + createSimpleExpression(String(context.cached.length)) + ); + context.cached.push(null); + } else { + renderExp.arguments.push( + createFunctionExpression( + createForLoopParams(forNode.parseResult), + childBlock, + true + ) + ); + } + }; + }); + } +); +function processFor(node, dir, context, processCodegen) { + if (!dir.exp) { + context.onError( + createCompilerError(31, dir.loc) + ); + return; + } + const parseResult = dir.forParseResult; + if (!parseResult) { + context.onError( + createCompilerError(32, dir.loc) + ); + return; + } + finalizeForParseResult(parseResult, context); + const { addIdentifiers, removeIdentifiers, scopes } = context; + const { source, value, key, index } = parseResult; + const forNode = { + type: 11, + loc: dir.loc, + source, + valueAlias: value, + keyAlias: key, + objectIndexAlias: index, + parseResult, + children: isTemplateNode(node) ? node.children : [node] + }; + context.replaceNode(forNode); + scopes.vFor++; + if (context.prefixIdentifiers) { + value && addIdentifiers(value); + key && addIdentifiers(key); + index && addIdentifiers(index); + } + const onExit = processCodegen && processCodegen(forNode); + return () => { + scopes.vFor--; + if (context.prefixIdentifiers) { + value && removeIdentifiers(value); + key && removeIdentifiers(key); + index && removeIdentifiers(index); + } + if (onExit) onExit(); + }; +} +function finalizeForParseResult(result, context) { + if (result.finalized) return; + if (context.prefixIdentifiers) { + result.source = processExpression( + result.source, + context + ); + if (result.key) { + result.key = processExpression( + result.key, + context, + true + ); + } + if (result.index) { + result.index = processExpression( + result.index, + context, + true + ); + } + if (result.value) { + result.value = processExpression( + result.value, + context, + true + ); + } + } + result.finalized = true; +} +function createForLoopParams({ value, key, index }, memoArgs = []) { + return createParamsList([value, key, index, ...memoArgs]); +} +function createParamsList(args) { + let i = args.length; + while (i--) { + if (args[i]) break; + } + return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false)); +} + +const defaultFallback = createSimpleExpression(`undefined`, false); +const trackSlotScopes = (node, context) => { + if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) { + const vSlot = findDir(node, "slot"); + if (vSlot) { + const slotProps = vSlot.exp; + if (context.prefixIdentifiers) { + slotProps && context.addIdentifiers(slotProps); + } + context.scopes.vSlot++; + return () => { + if (context.prefixIdentifiers) { + slotProps && context.removeIdentifiers(slotProps); + } + context.scopes.vSlot--; + }; + } + } +}; +const trackVForSlotScopes = (node, context) => { + let vFor; + if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) { + const result = vFor.forParseResult; + if (result) { + finalizeForParseResult(result, context); + const { value, key, index } = result; + const { addIdentifiers, removeIdentifiers } = context; + value && addIdentifiers(value); + key && addIdentifiers(key); + index && addIdentifiers(index); + return () => { + value && removeIdentifiers(value); + key && removeIdentifiers(key); + index && removeIdentifiers(index); + }; + } + } +}; +const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression( + props, + children, + false, + true, + children.length ? children[0].loc : loc +); +function buildSlots(node, context, buildSlotFn = buildClientSlotFn) { + context.helper(WITH_CTX); + const { children, loc } = node; + const slotsProperties = []; + const dynamicSlots = []; + let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0; + if (!context.ssr && context.prefixIdentifiers) { + hasDynamicSlots = node.props.some( + (prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers)) + ) || children.some((child) => hasScopeRef(child, context.identifiers)); + } + const onComponentSlot = findDir(node, "slot", true); + if (onComponentSlot) { + const { arg, exp } = onComponentSlot; + if (arg && !isStaticExp(arg)) { + hasDynamicSlots = true; + } + slotsProperties.push( + createObjectProperty( + arg || createSimpleExpression("default", true), + buildSlotFn(exp, void 0, children, loc) + ) + ); + } + let hasTemplateSlots = false; + let hasNamedDefaultSlot = false; + const implicitDefaultChildren = []; + const seenSlotNames = /* @__PURE__ */ new Set(); + let conditionalBranchIndex = 0; + for (let i = 0; i < children.length; i++) { + const slotElement = children[i]; + let slotDir; + if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) { + if (slotElement.type !== 3) { + implicitDefaultChildren.push(slotElement); + } + continue; + } + if (onComponentSlot) { + context.onError( + createCompilerError(37, slotDir.loc) + ); + break; + } + hasTemplateSlots = true; + const { children: slotChildren, loc: slotLoc } = slotElement; + const { + arg: slotName = createSimpleExpression(`default`, true), + exp: slotProps, + loc: dirLoc + } = slotDir; + let staticSlotName; + if (isStaticExp(slotName)) { + staticSlotName = slotName ? slotName.content : `default`; + } else { + hasDynamicSlots = true; + } + const vFor = findDir(slotElement, "for"); + const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc); + let vIf; + let vElse; + if (vIf = findDir(slotElement, "if")) { + hasDynamicSlots = true; + dynamicSlots.push( + createConditionalExpression( + vIf.exp, + buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), + defaultFallback + ) + ); + } else if (vElse = findDir( + slotElement, + /^else(?:-if)?$/, + true + /* allowEmpty */ + )) { + let j = i; + let prev; + while (j--) { + prev = children[j]; + if (!isCommentOrWhitespace(prev)) { + break; + } + } + if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) { + let conditional = dynamicSlots[dynamicSlots.length - 1]; + while (conditional.alternate.type === 19) { + conditional = conditional.alternate; + } + conditional.alternate = vElse.exp ? createConditionalExpression( + vElse.exp, + buildDynamicSlot( + slotName, + slotFunction, + conditionalBranchIndex++ + ), + defaultFallback + ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++); + } else { + context.onError( + createCompilerError(30, vElse.loc) + ); + } + } else if (vFor) { + hasDynamicSlots = true; + const parseResult = vFor.forParseResult; + if (parseResult) { + finalizeForParseResult(parseResult, context); + dynamicSlots.push( + createCallExpression(context.helper(RENDER_LIST), [ + parseResult.source, + createFunctionExpression( + createForLoopParams(parseResult), + buildDynamicSlot(slotName, slotFunction), + true + ) + ]) + ); + } else { + context.onError( + createCompilerError( + 32, + vFor.loc + ) + ); + } + } else { + if (staticSlotName) { + if (seenSlotNames.has(staticSlotName)) { + context.onError( + createCompilerError( + 38, + dirLoc + ) + ); + continue; + } + seenSlotNames.add(staticSlotName); + if (staticSlotName === "default") { + hasNamedDefaultSlot = true; + } + } + slotsProperties.push(createObjectProperty(slotName, slotFunction)); + } + } + if (!onComponentSlot) { + const buildDefaultSlotProperty = (props, children2) => { + const fn = buildSlotFn(props, void 0, children2, loc); + if (context.compatConfig) { + fn.isNonScopedSlot = true; + } + return createObjectProperty(`default`, fn); + }; + if (!hasTemplateSlots) { + slotsProperties.push(buildDefaultSlotProperty(void 0, children)); + } else if (implicitDefaultChildren.length && // #3766 + // with whitespace: 'preserve', whitespaces between slots will end up in + // implicitDefaultChildren. Ignore if all implicit children are whitespaces. + !implicitDefaultChildren.every(isWhitespaceText)) { + if (hasNamedDefaultSlot) { + context.onError( + createCompilerError( + 39, + implicitDefaultChildren[0].loc + ) + ); + } else { + slotsProperties.push( + buildDefaultSlotProperty(void 0, implicitDefaultChildren) + ); + } + } + } + const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1; + let slots = createObjectExpression( + slotsProperties.concat( + createObjectProperty( + `_`, + // 2 = compiled but dynamic = can skip normalization, but must run diff + // 1 = compiled and static = can skip normalization AND diff as optimized + createSimpleExpression( + slotFlag + (``), + false + ) + ) + ), + loc + ); + if (dynamicSlots.length) { + slots = createCallExpression(context.helper(CREATE_SLOTS), [ + slots, + createArrayExpression(dynamicSlots) + ]); + } + return { + slots, + hasDynamicSlots + }; +} +function buildDynamicSlot(name, fn, index) { + const props = [ + createObjectProperty(`name`, name), + createObjectProperty(`fn`, fn) + ]; + if (index != null) { + props.push( + createObjectProperty(`key`, createSimpleExpression(String(index), true)) + ); + } + return createObjectExpression(props); +} +function hasForwardedSlots(children) { + for (let i = 0; i < children.length; i++) { + const child = children[i]; + switch (child.type) { + case 1: + if (child.tagType === 2 || hasForwardedSlots(child.children)) { + return true; + } + break; + case 9: + if (hasForwardedSlots(child.branches)) return true; + break; + case 10: + case 11: + if (hasForwardedSlots(child.children)) return true; + break; + } + } + return false; +} + +const directiveImportMap = /* @__PURE__ */ new WeakMap(); +const transformElement = (node, context) => { + return function postTransformElement() { + node = context.currentNode; + if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) { + return; + } + const { tag, props } = node; + const isComponent = node.tagType === 1; + let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`; + const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT; + let vnodeProps; + let vnodeChildren; + let patchFlag = 0; + let vnodeDynamicProps; + let dynamicPropNames; + let vnodeDirectives; + let shouldUseBlock = ( + // dynamic component may resolve to plain elements + isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block + // updates inside get proper isSVG flag at runtime. (#639, #643) + // This is technically web-specific, but splitting the logic out of core + // leads to too much unnecessary complexity. + (tag === "svg" || tag === "foreignObject" || tag === "math") + ); + if (props.length > 0) { + const propsBuildResult = buildProps( + node, + context, + void 0, + isComponent, + isDynamicComponent + ); + vnodeProps = propsBuildResult.props; + patchFlag = propsBuildResult.patchFlag; + dynamicPropNames = propsBuildResult.dynamicPropNames; + const directives = propsBuildResult.directives; + vnodeDirectives = directives && directives.length ? createArrayExpression( + directives.map((dir) => buildDirectiveArgs(dir, context)) + ) : void 0; + if (propsBuildResult.shouldUseBlock) { + shouldUseBlock = true; + } + } + if (node.children.length > 0) { + if (vnodeTag === KEEP_ALIVE) { + shouldUseBlock = true; + patchFlag |= 1024; + } + const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling + vnodeTag !== TELEPORT && // explained above. + vnodeTag !== KEEP_ALIVE; + if (shouldBuildAsSlots) { + const { slots, hasDynamicSlots } = buildSlots(node, context); + vnodeChildren = slots; + if (hasDynamicSlots) { + patchFlag |= 1024; + } + } else if (node.children.length === 1 && vnodeTag !== TELEPORT) { + const child = node.children[0]; + const type = child.type; + const hasDynamicTextChild = type === 5 || type === 8; + if (hasDynamicTextChild && getConstantType(child, context) === 0) { + patchFlag |= 1; + } + if (hasDynamicTextChild || type === 2) { + vnodeChildren = child; + } else { + vnodeChildren = node.children; + } + } else { + vnodeChildren = node.children; + } + } + if (dynamicPropNames && dynamicPropNames.length) { + vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames); + } + node.codegenNode = createVNodeCall( + context, + vnodeTag, + vnodeProps, + vnodeChildren, + patchFlag === 0 ? void 0 : patchFlag, + vnodeDynamicProps, + vnodeDirectives, + !!shouldUseBlock, + false, + isComponent, + node.loc + ); + }; +}; +function resolveComponentType(node, context, ssr = false) { + let { tag } = node; + const isExplicitDynamic = isComponentTag(tag); + const isProp = findProp( + node, + "is", + false, + true + /* allow empty */ + ); + if (isProp) { + if (isExplicitDynamic || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + )) { + let exp; + if (isProp.type === 6) { + exp = isProp.value && createSimpleExpression(isProp.value.content, true); + } else { + exp = isProp.exp; + if (!exp) { + exp = createSimpleExpression(`is`, false, isProp.arg.loc); + { + exp = isProp.exp = processExpression(exp, context); + } + } + } + if (exp) { + return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [ + exp + ]); + } + } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) { + tag = isProp.value.content.slice(4); + } + } + const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag); + if (builtIn) { + if (!ssr) context.helper(builtIn); + return builtIn; + } + { + const fromSetup = resolveSetupReference(tag, context); + if (fromSetup) { + return fromSetup; + } + const dotIndex = tag.indexOf("."); + if (dotIndex > 0) { + const ns = resolveSetupReference(tag.slice(0, dotIndex), context); + if (ns) { + return ns + tag.slice(dotIndex); + } + } + } + if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) { + context.helper(RESOLVE_COMPONENT); + context.components.add(tag + `__self`); + return toValidAssetId(tag, `component`); + } + context.helper(RESOLVE_COMPONENT); + context.components.add(tag); + return toValidAssetId(tag, `component`); +} +function resolveSetupReference(name, context) { + const bindings = context.bindingMetadata; + if (!bindings || bindings.__isScriptSetup === false) { + return; + } + const camelName = shared.camelize(name); + const PascalName = shared.capitalize(camelName); + const checkType = (type) => { + if (bindings[name] === type) { + return name; + } + if (bindings[camelName] === type) { + return camelName; + } + if (bindings[PascalName] === type) { + return PascalName; + } + }; + const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const"); + if (fromConst) { + return context.inline ? ( + // in inline mode, const setup bindings (e.g. imports) can be used as-is + fromConst + ) : `$setup[${JSON.stringify(fromConst)}]`; + } + const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref"); + if (fromMaybeRef) { + return context.inline ? ( + // setup scope bindings that may be refs need to be unrefed + `${context.helperString(UNREF)}(${fromMaybeRef})` + ) : `$setup[${JSON.stringify(fromMaybeRef)}]`; + } + const fromProps = checkType("props"); + if (fromProps) { + return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`; + } +} +function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) { + const { tag, loc: elementLoc, children } = node; + let properties = []; + const mergeArgs = []; + const runtimeDirectives = []; + const hasChildren = children.length > 0; + let shouldUseBlock = false; + let patchFlag = 0; + let hasRef = false; + let hasClassBinding = false; + let hasStyleBinding = false; + let hasHydrationEventBinding = false; + let hasDynamicKeys = false; + let hasVnodeHook = false; + const dynamicPropNames = []; + const pushMergeArg = (arg) => { + if (properties.length) { + mergeArgs.push( + createObjectExpression(dedupeProperties(properties), elementLoc) + ); + properties = []; + } + if (arg) mergeArgs.push(arg); + }; + const pushRefVForMarker = () => { + if (context.scopes.vFor > 0) { + properties.push( + createObjectProperty( + createSimpleExpression("ref_for", true), + createSimpleExpression("true") + ) + ); + } + }; + const analyzePatchFlag = ({ key, value }) => { + if (isStaticExp(key)) { + const name = key.content; + const isEventHandler = shared.isOn(name); + if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click + // dedicated fast path. + name.toLowerCase() !== "onclick" && // omit v-model handlers + name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks + !shared.isReservedProp(name)) { + hasHydrationEventBinding = true; + } + if (isEventHandler && shared.isReservedProp(name)) { + hasVnodeHook = true; + } + if (isEventHandler && value.type === 14) { + value = value.arguments[0]; + } + if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) { + return; + } + if (name === "ref") { + hasRef = true; + } else if (name === "class") { + hasClassBinding = true; + } else if (name === "style") { + hasStyleBinding = true; + } else if (name !== "key" && !dynamicPropNames.includes(name)) { + dynamicPropNames.push(name); + } + if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) { + dynamicPropNames.push(name); + } + } else { + hasDynamicKeys = true; + } + }; + for (let i = 0; i < props.length; i++) { + const prop = props[i]; + if (prop.type === 6) { + const { loc, name, nameLoc, value } = prop; + let isStatic = true; + if (name === "ref") { + hasRef = true; + pushRefVForMarker(); + if (value && context.inline) { + const binding = context.bindingMetadata[value.content]; + if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") { + isStatic = false; + properties.push( + createObjectProperty( + createSimpleExpression("ref_key", true), + createSimpleExpression(value.content, true, value.loc) + ) + ); + } + } + } + if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + ))) { + continue; + } + properties.push( + createObjectProperty( + createSimpleExpression(name, true, nameLoc), + createSimpleExpression( + value ? value.content : "", + isStatic, + value ? value.loc : loc + ) + ) + ); + } else { + const { name, arg, exp, loc, modifiers } = prop; + const isVBind = name === "bind"; + const isVOn = name === "on"; + if (name === "slot") { + if (!isComponent) { + context.onError( + createCompilerError(40, loc) + ); + } + continue; + } + if (name === "once" || name === "memo") { + continue; + } + if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + ))) { + continue; + } + if (isVOn && ssr) { + continue; + } + if ( + // #938: elements with dynamic keys should be forced into blocks + isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked + // before children + isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update") + ) { + shouldUseBlock = true; + } + if (isVBind && isStaticArgOf(arg, "ref")) { + pushRefVForMarker(); + } + if (!arg && (isVBind || isVOn)) { + hasDynamicKeys = true; + if (exp) { + if (isVBind) { + { + pushMergeArg(); + if (isCompatEnabled( + "COMPILER_V_BIND_OBJECT_ORDER", + context + )) { + mergeArgs.unshift(exp); + continue; + } + } + pushRefVForMarker(); + pushMergeArg(); + mergeArgs.push(exp); + } else { + pushMergeArg({ + type: 14, + loc, + callee: context.helper(TO_HANDLERS), + arguments: isComponent ? [exp] : [exp, `true`] + }); + } + } else { + context.onError( + createCompilerError( + isVBind ? 34 : 35, + loc + ) + ); + } + continue; + } + if (isVBind && modifiers.some((mod) => mod.content === "prop")) { + patchFlag |= 32; + } + const directiveTransform = context.directiveTransforms[name]; + if (directiveTransform) { + const { props: props2, needRuntime } = directiveTransform(prop, node, context); + !ssr && props2.forEach(analyzePatchFlag); + if (isVOn && arg && !isStaticExp(arg)) { + pushMergeArg(createObjectExpression(props2, elementLoc)); + } else { + properties.push(...props2); + } + if (needRuntime) { + runtimeDirectives.push(prop); + if (shared.isSymbol(needRuntime)) { + directiveImportMap.set(prop, needRuntime); + } + } + } else if (!shared.isBuiltInDirective(name)) { + runtimeDirectives.push(prop); + if (hasChildren) { + shouldUseBlock = true; + } + } + } + } + let propsExpression = void 0; + if (mergeArgs.length) { + pushMergeArg(); + if (mergeArgs.length > 1) { + propsExpression = createCallExpression( + context.helper(MERGE_PROPS), + mergeArgs, + elementLoc + ); + } else { + propsExpression = mergeArgs[0]; + } + } else if (properties.length) { + propsExpression = createObjectExpression( + dedupeProperties(properties), + elementLoc + ); + } + if (hasDynamicKeys) { + patchFlag |= 16; + } else { + if (hasClassBinding && !isComponent) { + patchFlag |= 2; + } + if (hasStyleBinding && !isComponent) { + patchFlag |= 4; + } + if (dynamicPropNames.length) { + patchFlag |= 8; + } + if (hasHydrationEventBinding) { + patchFlag |= 32; + } + } + if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) { + patchFlag |= 512; + } + if (!context.inSSR && propsExpression) { + switch (propsExpression.type) { + case 15: + let classKeyIndex = -1; + let styleKeyIndex = -1; + let hasDynamicKey = false; + for (let i = 0; i < propsExpression.properties.length; i++) { + const key = propsExpression.properties[i].key; + if (isStaticExp(key)) { + if (key.content === "class") { + classKeyIndex = i; + } else if (key.content === "style") { + styleKeyIndex = i; + } + } else if (!key.isHandlerKey) { + hasDynamicKey = true; + } + } + const classProp = propsExpression.properties[classKeyIndex]; + const styleProp = propsExpression.properties[styleKeyIndex]; + if (!hasDynamicKey) { + if (classProp && !isStaticExp(classProp.value)) { + classProp.value = createCallExpression( + context.helper(NORMALIZE_CLASS), + [classProp.value] + ); + } + if (styleProp && // the static style is compiled into an object, + // so use `hasStyleBinding` to ensure that it is a dynamic style binding + (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist, + // v-bind:style with static literal object + styleProp.value.type === 17)) { + styleProp.value = createCallExpression( + context.helper(NORMALIZE_STYLE), + [styleProp.value] + ); + } + } else { + propsExpression = createCallExpression( + context.helper(NORMALIZE_PROPS), + [propsExpression] + ); + } + break; + case 14: + break; + default: + propsExpression = createCallExpression( + context.helper(NORMALIZE_PROPS), + [ + createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [ + propsExpression + ]) + ] + ); + break; + } + } + return { + props: propsExpression, + directives: runtimeDirectives, + patchFlag, + dynamicPropNames, + shouldUseBlock + }; +} +function dedupeProperties(properties) { + const knownProps = /* @__PURE__ */ new Map(); + const deduped = []; + for (let i = 0; i < properties.length; i++) { + const prop = properties[i]; + if (prop.key.type === 8 || !prop.key.isStatic) { + deduped.push(prop); + continue; + } + const name = prop.key.content; + const existing = knownProps.get(name); + if (existing) { + if (name === "style" || name === "class" || shared.isOn(name)) { + mergeAsArray(existing, prop); + } + } else { + knownProps.set(name, prop); + deduped.push(prop); + } + } + return deduped; +} +function mergeAsArray(existing, incoming) { + if (existing.value.type === 17) { + existing.value.elements.push(incoming.value); + } else { + existing.value = createArrayExpression( + [existing.value, incoming.value], + existing.loc + ); + } +} +function buildDirectiveArgs(dir, context) { + const dirArgs = []; + const runtime = directiveImportMap.get(dir); + if (runtime) { + dirArgs.push(context.helperString(runtime)); + } else { + const fromSetup = resolveSetupReference("v-" + dir.name, context); + if (fromSetup) { + dirArgs.push(fromSetup); + } else { + context.helper(RESOLVE_DIRECTIVE); + context.directives.add(dir.name); + dirArgs.push(toValidAssetId(dir.name, `directive`)); + } + } + const { loc } = dir; + if (dir.exp) dirArgs.push(dir.exp); + if (dir.arg) { + if (!dir.exp) { + dirArgs.push(`void 0`); + } + dirArgs.push(dir.arg); + } + if (Object.keys(dir.modifiers).length) { + if (!dir.arg) { + if (!dir.exp) { + dirArgs.push(`void 0`); + } + dirArgs.push(`void 0`); + } + const trueExpression = createSimpleExpression(`true`, false, loc); + dirArgs.push( + createObjectExpression( + dir.modifiers.map( + (modifier) => createObjectProperty(modifier, trueExpression) + ), + loc + ) + ); + } + return createArrayExpression(dirArgs, dir.loc); +} +function stringifyDynamicPropNames(props) { + let propsNamesString = `[`; + for (let i = 0, l = props.length; i < l; i++) { + propsNamesString += JSON.stringify(props[i]); + if (i < l - 1) propsNamesString += ", "; + } + return propsNamesString + `]`; +} +function isComponentTag(tag) { + return tag === "component" || tag === "Component"; +} + +const transformSlotOutlet = (node, context) => { + if (isSlotOutlet(node)) { + const { children, loc } = node; + const { slotName, slotProps } = processSlotOutlet(node, context); + const slotArgs = [ + context.prefixIdentifiers ? `_ctx.$slots` : `$slots`, + slotName, + "{}", + "undefined", + "true" + ]; + let expectedLen = 2; + if (slotProps) { + slotArgs[2] = slotProps; + expectedLen = 3; + } + if (children.length) { + slotArgs[3] = createFunctionExpression([], children, false, false, loc); + expectedLen = 4; + } + if (context.scopeId && !context.slotted) { + expectedLen = 5; + } + slotArgs.splice(expectedLen); + node.codegenNode = createCallExpression( + context.helper(RENDER_SLOT), + slotArgs, + loc + ); + } +}; +function processSlotOutlet(node, context) { + let slotName = `"default"`; + let slotProps = void 0; + const nonNameProps = []; + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + if (p.value) { + if (p.name === "name") { + slotName = JSON.stringify(p.value.content); + } else { + p.name = shared.camelize(p.name); + nonNameProps.push(p); + } + } + } else { + if (p.name === "bind" && isStaticArgOf(p.arg, "name")) { + if (p.exp) { + slotName = p.exp; + } else if (p.arg && p.arg.type === 4) { + const name = shared.camelize(p.arg.content); + slotName = p.exp = createSimpleExpression(name, false, p.arg.loc); + { + slotName = p.exp = processExpression(p.exp, context); + } + } + } else { + if (p.name === "bind" && p.arg && isStaticExp(p.arg)) { + p.arg.content = shared.camelize(p.arg.content); + } + nonNameProps.push(p); + } + } + } + if (nonNameProps.length > 0) { + const { props, directives } = buildProps( + node, + context, + nonNameProps, + false, + false + ); + slotProps = props; + if (directives.length) { + context.onError( + createCompilerError( + 36, + directives[0].loc + ) + ); + } + } + return { + slotName, + slotProps + }; +} + +const transformOn = (dir, node, context, augmentor) => { + const { loc, modifiers, arg } = dir; + if (!dir.exp && !modifiers.length) { + context.onError(createCompilerError(35, loc)); + } + let eventName; + if (arg.type === 4) { + if (arg.isStatic) { + let rawName = arg.content; + if (rawName.startsWith("vue:")) { + rawName = `vnode-${rawName.slice(4)}`; + } + const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? ( + // for non-element and vnode lifecycle event listeners, auto convert + // it to camelCase. See issue #2249 + shared.toHandlerKey(shared.camelize(rawName)) + ) : ( + // preserve case for plain element listeners that have uppercase + // letters, as these may be custom elements' custom events + `on:${rawName}` + ); + eventName = createSimpleExpression(eventString, true, arg.loc); + } else { + eventName = createCompoundExpression([ + `${context.helperString(TO_HANDLER_KEY)}(`, + arg, + `)` + ]); + } + } else { + eventName = arg; + eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`); + eventName.children.push(`)`); + } + let exp = dir.exp; + if (exp && !exp.content.trim()) { + exp = void 0; + } + let shouldCache = context.cacheHandlers && !exp && !context.inVOnce; + if (exp) { + const isMemberExp = isMemberExpression(exp, context); + const isInlineStatement = !(isMemberExp || isFnExpression(exp, context)); + const hasMultipleStatements = exp.content.includes(`;`); + if (context.prefixIdentifiers) { + isInlineStatement && context.addIdentifiers(`$event`); + exp = dir.exp = processExpression( + exp, + context, + false, + hasMultipleStatements + ); + isInlineStatement && context.removeIdentifiers(`$event`); + shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once + !context.inVOnce && // runtime constants don't need to be cached + // (this is analyzed by compileScript in SFC <script setup>) + !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component - + // we need to use the original function to preserve arity, + // e.g. <transition> relies on checking cb.length to determine + // transition end handling. Inline function is ok since its arity + // is preserved even when cached. + !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot) + // it must be passed fresh to avoid stale values. + !hasScopeRef(exp, context.identifiers); + if (shouldCache && isMemberExp) { + if (exp.type === 4) { + exp.content = `${exp.content} && ${exp.content}(...args)`; + } else { + exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`]; + } + } + } + if (isInlineStatement || shouldCache && isMemberExp) { + exp = createCompoundExpression([ + `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? ` +//@ts-ignore +` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`, + exp, + hasMultipleStatements ? `}` : `)` + ]); + } + } + let ret = { + props: [ + createObjectProperty( + eventName, + exp || createSimpleExpression(`() => {}`, false, loc) + ) + ] + }; + if (augmentor) { + ret = augmentor(ret); + } + if (shouldCache) { + ret.props[0].value = context.cache(ret.props[0].value); + } + ret.props.forEach((p) => p.key.isHandlerKey = true); + return ret; +}; + +const transformBind = (dir, _node, context) => { + const { modifiers, loc } = dir; + const arg = dir.arg; + let { exp } = dir; + if (exp && exp.type === 4 && !exp.content.trim()) { + { + context.onError( + createCompilerError(34, loc) + ); + return { + props: [ + createObjectProperty(arg, createSimpleExpression("", true, loc)) + ] + }; + } + } + if (arg.type !== 4) { + arg.children.unshift(`(`); + arg.children.push(`) || ""`); + } else if (!arg.isStatic) { + arg.content = arg.content ? `${arg.content} || ""` : `""`; + } + if (modifiers.some((mod) => mod.content === "camel")) { + if (arg.type === 4) { + if (arg.isStatic) { + arg.content = shared.camelize(arg.content); + } else { + arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`; + } + } else { + arg.children.unshift(`${context.helperString(CAMELIZE)}(`); + arg.children.push(`)`); + } + } + if (!context.inSSR) { + if (modifiers.some((mod) => mod.content === "prop")) { + injectPrefix(arg, "."); + } + if (modifiers.some((mod) => mod.content === "attr")) { + injectPrefix(arg, "^"); + } + } + return { + props: [createObjectProperty(arg, exp)] + }; +}; +const injectPrefix = (arg, prefix) => { + if (arg.type === 4) { + if (arg.isStatic) { + arg.content = prefix + arg.content; + } else { + arg.content = `\`${prefix}\${${arg.content}}\``; + } + } else { + arg.children.unshift(`'${prefix}' + (`); + arg.children.push(`)`); + } +}; + +const transformText = (node, context) => { + if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) { + return () => { + const children = node.children; + let currentContainer = void 0; + let hasText = false; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isText$1(child)) { + hasText = true; + for (let j = i + 1; j < children.length; j++) { + const next = children[j]; + if (isText$1(next)) { + if (!currentContainer) { + currentContainer = children[i] = createCompoundExpression( + [child], + child.loc + ); + } + currentContainer.children.push(` + `, next); + children.splice(j, 1); + j--; + } else { + currentContainer = void 0; + break; + } + } + } + } + if (!hasText || // if this is a plain element with a single text child, leave it + // as-is since the runtime has dedicated fast path for this by directly + // setting textContent of the element. + // for component root it's always normalized anyway. + children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756 + // custom directives can potentially add DOM elements arbitrarily, + // we need to avoid setting textContent of the element at runtime + // to avoid accidentally overwriting the DOM elements added + // by the user through custom directives. + !node.props.find( + (p) => p.type === 7 && !context.directiveTransforms[p.name] + ) && // in compat mode, <template> tags with no special directives + // will be rendered as a fragment so its children must be + // converted into vnodes. + !(node.tag === "template"))) { + return; + } + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isText$1(child) || child.type === 8) { + const callArgs = []; + if (child.type !== 2 || child.content !== " ") { + callArgs.push(child); + } + if (!context.ssr && getConstantType(child, context) === 0) { + callArgs.push( + 1 + (``) + ); + } + children[i] = { + type: 12, + content: child, + loc: child.loc, + codegenNode: createCallExpression( + context.helper(CREATE_TEXT), + callArgs + ) + }; + } + } + }; + } +}; + +const seen$1 = /* @__PURE__ */ new WeakSet(); +const transformOnce = (node, context) => { + if (node.type === 1 && findDir(node, "once", true)) { + if (seen$1.has(node) || context.inVOnce || context.inSSR) { + return; + } + seen$1.add(node); + context.inVOnce = true; + context.helper(SET_BLOCK_TRACKING); + return () => { + context.inVOnce = false; + const cur = context.currentNode; + if (cur.codegenNode) { + cur.codegenNode = context.cache( + cur.codegenNode, + true, + true + ); + } + }; + } +}; + +const transformModel = (dir, node, context) => { + const { exp, arg } = dir; + if (!exp) { + context.onError( + createCompilerError(41, dir.loc) + ); + return createTransformProps(); + } + const rawExp = exp.loc.source.trim(); + const expString = exp.type === 4 ? exp.content : rawExp; + const bindingType = context.bindingMetadata[rawExp]; + if (bindingType === "props" || bindingType === "props-aliased") { + context.onError(createCompilerError(44, exp.loc)); + return createTransformProps(); + } + if (bindingType === "literal-const" || bindingType === "setup-const") { + context.onError(createCompilerError(45, exp.loc)); + return createTransformProps(); + } + const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref"); + if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) { + context.onError( + createCompilerError(42, exp.loc) + ); + return createTransformProps(); + } + if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) { + context.onError( + createCompilerError(43, exp.loc) + ); + return createTransformProps(); + } + const propName = arg ? arg : createSimpleExpression("modelValue", true); + const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`; + let assignmentExp; + const eventArg = context.isTS ? `($event: any)` : `$event`; + if (maybeRef) { + if (bindingType === "setup-ref") { + assignmentExp = createCompoundExpression([ + `${eventArg} => ((`, + createSimpleExpression(rawExp, false, exp.loc), + `).value = $event)` + ]); + } else { + const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`; + assignmentExp = createCompoundExpression([ + `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`, + createSimpleExpression(rawExp, false, exp.loc), + `).value = $event : ${altAssignment})` + ]); + } + } else { + assignmentExp = createCompoundExpression([ + `${eventArg} => ((`, + exp, + `) = $event)` + ]); + } + const props = [ + // modelValue: foo + createObjectProperty(propName, dir.exp), + // "onUpdate:modelValue": $event => (foo = $event) + createObjectProperty(eventName, assignmentExp) + ]; + if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) { + props[1].value = context.cache(props[1].value); + } + if (dir.modifiers.length && node.tagType === 1) { + const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `); + const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`; + props.push( + createObjectProperty( + modifiersKey, + createSimpleExpression( + `{ ${modifiers} }`, + false, + dir.loc, + 2 + ) + ) + ); + } + return createTransformProps(props); +}; +function createTransformProps(props = []) { + return { props }; +} + +const validDivisionCharRE = /[\w).+\-_$\]]/; +const transformFilter = (node, context) => { + if (!isCompatEnabled("COMPILER_FILTERS", context)) { + return; + } + if (node.type === 5) { + rewriteFilter(node.content, context); + } else if (node.type === 1) { + node.props.forEach((prop) => { + if (prop.type === 7 && prop.name !== "for" && prop.exp) { + rewriteFilter(prop.exp, context); + } + }); + } +}; +function rewriteFilter(node, context) { + if (node.type === 4) { + parseFilter(node, context); + } else { + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (typeof child !== "object") continue; + if (child.type === 4) { + parseFilter(child, context); + } else if (child.type === 8) { + rewriteFilter(node, context); + } else if (child.type === 5) { + rewriteFilter(child.content, context); + } + } + } +} +function parseFilter(node, context) { + const exp = node.content; + let inSingle = false; + let inDouble = false; + let inTemplateString = false; + let inRegex = false; + let curly = 0; + let square = 0; + let paren = 0; + let lastFilterIndex = 0; + let c, prev, i, expression, filters = []; + for (i = 0; i < exp.length; i++) { + prev = c; + c = exp.charCodeAt(i); + if (inSingle) { + if (c === 39 && prev !== 92) inSingle = false; + } else if (inDouble) { + if (c === 34 && prev !== 92) inDouble = false; + } else if (inTemplateString) { + if (c === 96 && prev !== 92) inTemplateString = false; + } else if (inRegex) { + if (c === 47 && prev !== 92) inRegex = false; + } else if (c === 124 && // pipe + exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) { + if (expression === void 0) { + lastFilterIndex = i + 1; + expression = exp.slice(0, i).trim(); + } else { + pushFilter(); + } + } else { + switch (c) { + case 34: + inDouble = true; + break; + // " + case 39: + inSingle = true; + break; + // ' + case 96: + inTemplateString = true; + break; + // ` + case 40: + paren++; + break; + // ( + case 41: + paren--; + break; + // ) + case 91: + square++; + break; + // [ + case 93: + square--; + break; + // ] + case 123: + curly++; + break; + // { + case 125: + curly--; + break; + } + if (c === 47) { + let j = i - 1; + let p; + for (; j >= 0; j--) { + p = exp.charAt(j); + if (p !== " ") break; + } + if (!p || !validDivisionCharRE.test(p)) { + inRegex = true; + } + } + } + } + if (expression === void 0) { + expression = exp.slice(0, i).trim(); + } else if (lastFilterIndex !== 0) { + pushFilter(); + } + function pushFilter() { + filters.push(exp.slice(lastFilterIndex, i).trim()); + lastFilterIndex = i + 1; + } + if (filters.length) { + for (i = 0; i < filters.length; i++) { + expression = wrapFilter(expression, filters[i], context); + } + node.content = expression; + node.ast = void 0; + } +} +function wrapFilter(exp, filter, context) { + context.helper(RESOLVE_FILTER); + const i = filter.indexOf("("); + if (i < 0) { + context.filters.add(filter); + return `${toValidAssetId(filter, "filter")}(${exp})`; + } else { + const name = filter.slice(0, i); + const args = filter.slice(i + 1); + context.filters.add(name); + return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`; + } +} + +const seen = /* @__PURE__ */ new WeakSet(); +const transformMemo = (node, context) => { + if (node.type === 1) { + const dir = findDir(node, "memo"); + if (!dir || seen.has(node) || context.inSSR) { + return; + } + seen.add(node); + return () => { + const codegenNode = node.codegenNode || context.currentNode.codegenNode; + if (codegenNode && codegenNode.type === 13) { + if (node.tagType !== 1) { + convertToBlock(codegenNode, context); + } + node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [ + dir.exp, + createFunctionExpression(void 0, codegenNode), + `_cache`, + String(context.cached.length) + ]); + context.cached.push(null); + } + }; + } +}; + +const transformVBindShorthand = (node, context) => { + if (node.type === 1) { + for (const prop of node.props) { + if (prop.type === 7 && prop.name === "bind" && (!prop.exp || // #13930 :foo in in-DOM templates will be parsed into :foo="" by browser + false) && prop.arg) { + const arg = prop.arg; + if (arg.type !== 4 || !arg.isStatic) { + context.onError( + createCompilerError( + 53, + arg.loc + ) + ); + prop.exp = createSimpleExpression("", true, arg.loc); + } else { + const propName = shared.camelize(arg.content); + if (validFirstIdentCharRE.test(propName[0]) || // allow hyphen first char for https://github.com/vuejs/language-tools/pull/3424 + propName[0] === "-") { + prop.exp = createSimpleExpression(propName, false, arg.loc); + } + } + } + } + } +}; + +function getBaseTransformPreset(prefixIdentifiers) { + return [ + [ + transformVBindShorthand, + transformOnce, + transformIf, + transformMemo, + transformFor, + ...[transformFilter] , + ...prefixIdentifiers ? [ + // order is important + trackVForSlotScopes, + transformExpression + ] : [], + transformSlotOutlet, + transformElement, + trackSlotScopes, + transformText + ], + { + on: transformOn, + bind: transformBind, + model: transformModel + } + ]; +} +function baseCompile(source, options = {}) { + const onError = options.onError || defaultOnError; + const isModuleMode = options.mode === "module"; + const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode; + if (!prefixIdentifiers && options.cacheHandlers) { + onError(createCompilerError(50)); + } + if (options.scopeId && !isModuleMode) { + onError(createCompilerError(51)); + } + const resolvedOptions = shared.extend({}, options, { + prefixIdentifiers + }); + const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source; + const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers); + if (options.isTS) { + const { expressionPlugins } = options; + if (!expressionPlugins || !expressionPlugins.includes("typescript")) { + options.expressionPlugins = [...expressionPlugins || [], "typescript"]; + } + } + transform( + ast, + shared.extend({}, resolvedOptions, { + nodeTransforms: [ + ...nodeTransforms, + ...options.nodeTransforms || [] + // user transforms + ], + directiveTransforms: shared.extend( + {}, + directiveTransforms, + options.directiveTransforms || {} + // user transforms + ) + }) + ); + return generate(ast, resolvedOptions); +} + +const BindingTypes = { + "DATA": "data", + "PROPS": "props", + "PROPS_ALIASED": "props-aliased", + "SETUP_LET": "setup-let", + "SETUP_CONST": "setup-const", + "SETUP_REACTIVE_CONST": "setup-reactive-const", + "SETUP_MAYBE_REF": "setup-maybe-ref", + "SETUP_REF": "setup-ref", + "OPTIONS": "options", + "LITERAL_CONST": "literal-const" +}; + +const noopDirectiveTransform = () => ({ props: [] }); + +exports.generateCodeFrame = shared.generateCodeFrame; +exports.BASE_TRANSITION = BASE_TRANSITION; +exports.BindingTypes = BindingTypes; +exports.CAMELIZE = CAMELIZE; +exports.CAPITALIZE = CAPITALIZE; +exports.CREATE_BLOCK = CREATE_BLOCK; +exports.CREATE_COMMENT = CREATE_COMMENT; +exports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK; +exports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE; +exports.CREATE_SLOTS = CREATE_SLOTS; +exports.CREATE_STATIC = CREATE_STATIC; +exports.CREATE_TEXT = CREATE_TEXT; +exports.CREATE_VNODE = CREATE_VNODE; +exports.CompilerDeprecationTypes = CompilerDeprecationTypes; +exports.ConstantTypes = ConstantTypes; +exports.ElementTypes = ElementTypes; +exports.ErrorCodes = ErrorCodes; +exports.FRAGMENT = FRAGMENT; +exports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS; +exports.IS_MEMO_SAME = IS_MEMO_SAME; +exports.IS_REF = IS_REF; +exports.KEEP_ALIVE = KEEP_ALIVE; +exports.MERGE_PROPS = MERGE_PROPS; +exports.NORMALIZE_CLASS = NORMALIZE_CLASS; +exports.NORMALIZE_PROPS = NORMALIZE_PROPS; +exports.NORMALIZE_STYLE = NORMALIZE_STYLE; +exports.Namespaces = Namespaces; +exports.NodeTypes = NodeTypes; +exports.OPEN_BLOCK = OPEN_BLOCK; +exports.POP_SCOPE_ID = POP_SCOPE_ID; +exports.PUSH_SCOPE_ID = PUSH_SCOPE_ID; +exports.RENDER_LIST = RENDER_LIST; +exports.RENDER_SLOT = RENDER_SLOT; +exports.RESOLVE_COMPONENT = RESOLVE_COMPONENT; +exports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE; +exports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT; +exports.RESOLVE_FILTER = RESOLVE_FILTER; +exports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING; +exports.SUSPENSE = SUSPENSE; +exports.TELEPORT = TELEPORT; +exports.TO_DISPLAY_STRING = TO_DISPLAY_STRING; +exports.TO_HANDLERS = TO_HANDLERS; +exports.TO_HANDLER_KEY = TO_HANDLER_KEY; +exports.TS_NODE_TYPES = TS_NODE_TYPES; +exports.UNREF = UNREF; +exports.WITH_CTX = WITH_CTX; +exports.WITH_DIRECTIVES = WITH_DIRECTIVES; +exports.WITH_MEMO = WITH_MEMO; +exports.advancePositionWithClone = advancePositionWithClone; +exports.advancePositionWithMutation = advancePositionWithMutation; +exports.assert = assert; +exports.baseCompile = baseCompile; +exports.baseParse = baseParse; +exports.buildDirectiveArgs = buildDirectiveArgs; +exports.buildProps = buildProps; +exports.buildSlots = buildSlots; +exports.checkCompatEnabled = checkCompatEnabled; +exports.convertToBlock = convertToBlock; +exports.createArrayExpression = createArrayExpression; +exports.createAssignmentExpression = createAssignmentExpression; +exports.createBlockStatement = createBlockStatement; +exports.createCacheExpression = createCacheExpression; +exports.createCallExpression = createCallExpression; +exports.createCompilerError = createCompilerError; +exports.createCompoundExpression = createCompoundExpression; +exports.createConditionalExpression = createConditionalExpression; +exports.createForLoopParams = createForLoopParams; +exports.createFunctionExpression = createFunctionExpression; +exports.createIfStatement = createIfStatement; +exports.createInterpolation = createInterpolation; +exports.createObjectExpression = createObjectExpression; +exports.createObjectProperty = createObjectProperty; +exports.createReturnStatement = createReturnStatement; +exports.createRoot = createRoot; +exports.createSequenceExpression = createSequenceExpression; +exports.createSimpleExpression = createSimpleExpression; +exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform; +exports.createTemplateLiteral = createTemplateLiteral; +exports.createTransformContext = createTransformContext; +exports.createVNodeCall = createVNodeCall; +exports.errorMessages = errorMessages; +exports.extractIdentifiers = extractIdentifiers; +exports.findDir = findDir; +exports.findProp = findProp; +exports.forAliasRE = forAliasRE; +exports.generate = generate; +exports.getBaseTransformPreset = getBaseTransformPreset; +exports.getConstantType = getConstantType; +exports.getMemoedVNodeCall = getMemoedVNodeCall; +exports.getVNodeBlockHelper = getVNodeBlockHelper; +exports.getVNodeHelper = getVNodeHelper; +exports.hasDynamicKeyVBind = hasDynamicKeyVBind; +exports.hasScopeRef = hasScopeRef; +exports.helperNameMap = helperNameMap; +exports.injectProp = injectProp; +exports.isAllWhitespace = isAllWhitespace; +exports.isCommentOrWhitespace = isCommentOrWhitespace; +exports.isCoreComponent = isCoreComponent; +exports.isFnExpression = isFnExpression; +exports.isFnExpressionBrowser = isFnExpressionBrowser; +exports.isFnExpressionNode = isFnExpressionNode; +exports.isFunctionType = isFunctionType; +exports.isInDestructureAssignment = isInDestructureAssignment; +exports.isInNewExpression = isInNewExpression; +exports.isMemberExpression = isMemberExpression; +exports.isMemberExpressionBrowser = isMemberExpressionBrowser; +exports.isMemberExpressionNode = isMemberExpressionNode; +exports.isReferencedIdentifier = isReferencedIdentifier; +exports.isSimpleIdentifier = isSimpleIdentifier; +exports.isSlotOutlet = isSlotOutlet; +exports.isStaticArgOf = isStaticArgOf; +exports.isStaticExp = isStaticExp; +exports.isStaticProperty = isStaticProperty; +exports.isStaticPropertyKey = isStaticPropertyKey; +exports.isTemplateNode = isTemplateNode; +exports.isText = isText$1; +exports.isVPre = isVPre; +exports.isVSlot = isVSlot; +exports.isWhitespaceText = isWhitespaceText; +exports.locStub = locStub; +exports.noopDirectiveTransform = noopDirectiveTransform; +exports.processExpression = processExpression; +exports.processFor = processFor; +exports.processIf = processIf; +exports.processSlotOutlet = processSlotOutlet; +exports.registerRuntimeHelpers = registerRuntimeHelpers; +exports.resolveComponentType = resolveComponentType; +exports.stringifyExpression = stringifyExpression; +exports.toValidAssetId = toValidAssetId; +exports.trackSlotScopes = trackSlotScopes; +exports.trackVForSlotScopes = trackVForSlotScopes; +exports.transform = transform; +exports.transformBind = transformBind; +exports.transformElement = transformElement; +exports.transformExpression = transformExpression; +exports.transformModel = transformModel; +exports.transformOn = transformOn; +exports.transformVBindShorthand = transformVBindShorthand; +exports.traverseNode = traverseNode; +exports.unwrapTSNode = unwrapTSNode; +exports.validFirstIdentCharRE = validFirstIdentCharRE; +exports.walkBlockDeclarations = walkBlockDeclarations; +exports.walkFunctionParams = walkFunctionParams; +exports.walkIdentifiers = walkIdentifiers; +exports.warnDeprecation = warnDeprecation; + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509107, function(require, module, exports) { +/** +* @vue/compiler-core v3.5.28 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var shared = require('@vue/shared'); +var decode = require('entities/decode'); +var parser = require('@babel/parser'); +var estreeWalker = require('estree-walker'); +var sourceMapJs = require('source-map-js'); + +const FRAGMENT = /* @__PURE__ */ Symbol(`Fragment` ); +const TELEPORT = /* @__PURE__ */ Symbol(`Teleport` ); +const SUSPENSE = /* @__PURE__ */ Symbol(`Suspense` ); +const KEEP_ALIVE = /* @__PURE__ */ Symbol(`KeepAlive` ); +const BASE_TRANSITION = /* @__PURE__ */ Symbol( + `BaseTransition` +); +const OPEN_BLOCK = /* @__PURE__ */ Symbol(`openBlock` ); +const CREATE_BLOCK = /* @__PURE__ */ Symbol(`createBlock` ); +const CREATE_ELEMENT_BLOCK = /* @__PURE__ */ Symbol( + `createElementBlock` +); +const CREATE_VNODE = /* @__PURE__ */ Symbol(`createVNode` ); +const CREATE_ELEMENT_VNODE = /* @__PURE__ */ Symbol( + `createElementVNode` +); +const CREATE_COMMENT = /* @__PURE__ */ Symbol( + `createCommentVNode` +); +const CREATE_TEXT = /* @__PURE__ */ Symbol( + `createTextVNode` +); +const CREATE_STATIC = /* @__PURE__ */ Symbol( + `createStaticVNode` +); +const RESOLVE_COMPONENT = /* @__PURE__ */ Symbol( + `resolveComponent` +); +const RESOLVE_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol( + `resolveDynamicComponent` +); +const RESOLVE_DIRECTIVE = /* @__PURE__ */ Symbol( + `resolveDirective` +); +const RESOLVE_FILTER = /* @__PURE__ */ Symbol( + `resolveFilter` +); +const WITH_DIRECTIVES = /* @__PURE__ */ Symbol( + `withDirectives` +); +const RENDER_LIST = /* @__PURE__ */ Symbol(`renderList` ); +const RENDER_SLOT = /* @__PURE__ */ Symbol(`renderSlot` ); +const CREATE_SLOTS = /* @__PURE__ */ Symbol(`createSlots` ); +const TO_DISPLAY_STRING = /* @__PURE__ */ Symbol( + `toDisplayString` +); +const MERGE_PROPS = /* @__PURE__ */ Symbol(`mergeProps` ); +const NORMALIZE_CLASS = /* @__PURE__ */ Symbol( + `normalizeClass` +); +const NORMALIZE_STYLE = /* @__PURE__ */ Symbol( + `normalizeStyle` +); +const NORMALIZE_PROPS = /* @__PURE__ */ Symbol( + `normalizeProps` +); +const GUARD_REACTIVE_PROPS = /* @__PURE__ */ Symbol( + `guardReactiveProps` +); +const TO_HANDLERS = /* @__PURE__ */ Symbol(`toHandlers` ); +const CAMELIZE = /* @__PURE__ */ Symbol(`camelize` ); +const CAPITALIZE = /* @__PURE__ */ Symbol(`capitalize` ); +const TO_HANDLER_KEY = /* @__PURE__ */ Symbol( + `toHandlerKey` +); +const SET_BLOCK_TRACKING = /* @__PURE__ */ Symbol( + `setBlockTracking` +); +const PUSH_SCOPE_ID = /* @__PURE__ */ Symbol(`pushScopeId` ); +const POP_SCOPE_ID = /* @__PURE__ */ Symbol(`popScopeId` ); +const WITH_CTX = /* @__PURE__ */ Symbol(`withCtx` ); +const UNREF = /* @__PURE__ */ Symbol(`unref` ); +const IS_REF = /* @__PURE__ */ Symbol(`isRef` ); +const WITH_MEMO = /* @__PURE__ */ Symbol(`withMemo` ); +const IS_MEMO_SAME = /* @__PURE__ */ Symbol(`isMemoSame` ); +const helperNameMap = { + [FRAGMENT]: `Fragment`, + [TELEPORT]: `Teleport`, + [SUSPENSE]: `Suspense`, + [KEEP_ALIVE]: `KeepAlive`, + [BASE_TRANSITION]: `BaseTransition`, + [OPEN_BLOCK]: `openBlock`, + [CREATE_BLOCK]: `createBlock`, + [CREATE_ELEMENT_BLOCK]: `createElementBlock`, + [CREATE_VNODE]: `createVNode`, + [CREATE_ELEMENT_VNODE]: `createElementVNode`, + [CREATE_COMMENT]: `createCommentVNode`, + [CREATE_TEXT]: `createTextVNode`, + [CREATE_STATIC]: `createStaticVNode`, + [RESOLVE_COMPONENT]: `resolveComponent`, + [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`, + [RESOLVE_DIRECTIVE]: `resolveDirective`, + [RESOLVE_FILTER]: `resolveFilter`, + [WITH_DIRECTIVES]: `withDirectives`, + [RENDER_LIST]: `renderList`, + [RENDER_SLOT]: `renderSlot`, + [CREATE_SLOTS]: `createSlots`, + [TO_DISPLAY_STRING]: `toDisplayString`, + [MERGE_PROPS]: `mergeProps`, + [NORMALIZE_CLASS]: `normalizeClass`, + [NORMALIZE_STYLE]: `normalizeStyle`, + [NORMALIZE_PROPS]: `normalizeProps`, + [GUARD_REACTIVE_PROPS]: `guardReactiveProps`, + [TO_HANDLERS]: `toHandlers`, + [CAMELIZE]: `camelize`, + [CAPITALIZE]: `capitalize`, + [TO_HANDLER_KEY]: `toHandlerKey`, + [SET_BLOCK_TRACKING]: `setBlockTracking`, + [PUSH_SCOPE_ID]: `pushScopeId`, + [POP_SCOPE_ID]: `popScopeId`, + [WITH_CTX]: `withCtx`, + [UNREF]: `unref`, + [IS_REF]: `isRef`, + [WITH_MEMO]: `withMemo`, + [IS_MEMO_SAME]: `isMemoSame` +}; +function registerRuntimeHelpers(helpers) { + Object.getOwnPropertySymbols(helpers).forEach((s) => { + helperNameMap[s] = helpers[s]; + }); +} + +const Namespaces = { + "HTML": 0, + "0": "HTML", + "SVG": 1, + "1": "SVG", + "MATH_ML": 2, + "2": "MATH_ML" +}; +const NodeTypes = { + "ROOT": 0, + "0": "ROOT", + "ELEMENT": 1, + "1": "ELEMENT", + "TEXT": 2, + "2": "TEXT", + "COMMENT": 3, + "3": "COMMENT", + "SIMPLE_EXPRESSION": 4, + "4": "SIMPLE_EXPRESSION", + "INTERPOLATION": 5, + "5": "INTERPOLATION", + "ATTRIBUTE": 6, + "6": "ATTRIBUTE", + "DIRECTIVE": 7, + "7": "DIRECTIVE", + "COMPOUND_EXPRESSION": 8, + "8": "COMPOUND_EXPRESSION", + "IF": 9, + "9": "IF", + "IF_BRANCH": 10, + "10": "IF_BRANCH", + "FOR": 11, + "11": "FOR", + "TEXT_CALL": 12, + "12": "TEXT_CALL", + "VNODE_CALL": 13, + "13": "VNODE_CALL", + "JS_CALL_EXPRESSION": 14, + "14": "JS_CALL_EXPRESSION", + "JS_OBJECT_EXPRESSION": 15, + "15": "JS_OBJECT_EXPRESSION", + "JS_PROPERTY": 16, + "16": "JS_PROPERTY", + "JS_ARRAY_EXPRESSION": 17, + "17": "JS_ARRAY_EXPRESSION", + "JS_FUNCTION_EXPRESSION": 18, + "18": "JS_FUNCTION_EXPRESSION", + "JS_CONDITIONAL_EXPRESSION": 19, + "19": "JS_CONDITIONAL_EXPRESSION", + "JS_CACHE_EXPRESSION": 20, + "20": "JS_CACHE_EXPRESSION", + "JS_BLOCK_STATEMENT": 21, + "21": "JS_BLOCK_STATEMENT", + "JS_TEMPLATE_LITERAL": 22, + "22": "JS_TEMPLATE_LITERAL", + "JS_IF_STATEMENT": 23, + "23": "JS_IF_STATEMENT", + "JS_ASSIGNMENT_EXPRESSION": 24, + "24": "JS_ASSIGNMENT_EXPRESSION", + "JS_SEQUENCE_EXPRESSION": 25, + "25": "JS_SEQUENCE_EXPRESSION", + "JS_RETURN_STATEMENT": 26, + "26": "JS_RETURN_STATEMENT" +}; +const ElementTypes = { + "ELEMENT": 0, + "0": "ELEMENT", + "COMPONENT": 1, + "1": "COMPONENT", + "SLOT": 2, + "2": "SLOT", + "TEMPLATE": 3, + "3": "TEMPLATE" +}; +const ConstantTypes = { + "NOT_CONSTANT": 0, + "0": "NOT_CONSTANT", + "CAN_SKIP_PATCH": 1, + "1": "CAN_SKIP_PATCH", + "CAN_CACHE": 2, + "2": "CAN_CACHE", + "CAN_STRINGIFY": 3, + "3": "CAN_STRINGIFY" +}; +const locStub = { + start: { line: 1, column: 1, offset: 0 }, + end: { line: 1, column: 1, offset: 0 }, + source: "" +}; +function createRoot(children, source = "") { + return { + type: 0, + source, + children, + helpers: /* @__PURE__ */ new Set(), + components: [], + directives: [], + hoists: [], + imports: [], + cached: [], + temps: 0, + codegenNode: void 0, + loc: locStub + }; +} +function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) { + if (context) { + if (isBlock) { + context.helper(OPEN_BLOCK); + context.helper(getVNodeBlockHelper(context.inSSR, isComponent)); + } else { + context.helper(getVNodeHelper(context.inSSR, isComponent)); + } + if (directives) { + context.helper(WITH_DIRECTIVES); + } + } + return { + type: 13, + tag, + props, + children, + patchFlag, + dynamicProps, + directives, + isBlock, + disableTracking, + isComponent, + loc + }; +} +function createArrayExpression(elements, loc = locStub) { + return { + type: 17, + loc, + elements + }; +} +function createObjectExpression(properties, loc = locStub) { + return { + type: 15, + loc, + properties + }; +} +function createObjectProperty(key, value) { + return { + type: 16, + loc: locStub, + key: shared.isString(key) ? createSimpleExpression(key, true) : key, + value + }; +} +function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) { + return { + type: 4, + loc, + content, + isStatic, + constType: isStatic ? 3 : constType + }; +} +function createInterpolation(content, loc) { + return { + type: 5, + loc, + content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content + }; +} +function createCompoundExpression(children, loc = locStub) { + return { + type: 8, + loc, + children + }; +} +function createCallExpression(callee, args = [], loc = locStub) { + return { + type: 14, + loc, + callee, + arguments: args + }; +} +function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) { + return { + type: 18, + params, + returns, + newline, + isSlot, + loc + }; +} +function createConditionalExpression(test, consequent, alternate, newline = true) { + return { + type: 19, + test, + consequent, + alternate, + newline, + loc: locStub + }; +} +function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) { + return { + type: 20, + index, + value, + needPauseTracking, + inVOnce, + needArraySpread: false, + loc: locStub + }; +} +function createBlockStatement(body) { + return { + type: 21, + body, + loc: locStub + }; +} +function createTemplateLiteral(elements) { + return { + type: 22, + elements, + loc: locStub + }; +} +function createIfStatement(test, consequent, alternate) { + return { + type: 23, + test, + consequent, + alternate, + loc: locStub + }; +} +function createAssignmentExpression(left, right) { + return { + type: 24, + left, + right, + loc: locStub + }; +} +function createSequenceExpression(expressions) { + return { + type: 25, + expressions, + loc: locStub + }; +} +function createReturnStatement(returns) { + return { + type: 26, + returns, + loc: locStub + }; +} +function getVNodeHelper(ssr, isComponent) { + return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE; +} +function getVNodeBlockHelper(ssr, isComponent) { + return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK; +} +function convertToBlock(node, { helper, removeHelper, inSSR }) { + if (!node.isBlock) { + node.isBlock = true; + removeHelper(getVNodeHelper(inSSR, node.isComponent)); + helper(OPEN_BLOCK); + helper(getVNodeBlockHelper(inSSR, node.isComponent)); + } +} + +const defaultDelimitersOpen = new Uint8Array([123, 123]); +const defaultDelimitersClose = new Uint8Array([125, 125]); +function isTagStartChar(c) { + return c >= 97 && c <= 122 || c >= 65 && c <= 90; +} +function isWhitespace(c) { + return c === 32 || c === 10 || c === 9 || c === 12 || c === 13; +} +function isEndOfTagSection(c) { + return c === 47 || c === 62 || isWhitespace(c); +} +function toCharCodes(str) { + const ret = new Uint8Array(str.length); + for (let i = 0; i < str.length; i++) { + ret[i] = str.charCodeAt(i); + } + return ret; +} +const Sequences = { + Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]), + // CDATA[ + CdataEnd: new Uint8Array([93, 93, 62]), + // ]]> + CommentEnd: new Uint8Array([45, 45, 62]), + // `-->` + ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]), + // `<\/script` + StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]), + // `</style` + TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]), + // `</title` + TextareaEnd: new Uint8Array([ + 60, + 47, + 116, + 101, + 120, + 116, + 97, + 114, + 101, + 97 + ]) + // `</textarea +}; +class Tokenizer { + constructor(stack, cbs) { + this.stack = stack; + this.cbs = cbs; + /** The current state the tokenizer is in. */ + this.state = 1; + /** The read buffer. */ + this.buffer = ""; + /** The beginning of the section that is currently being read. */ + this.sectionStart = 0; + /** The index within the buffer that we are currently looking at. */ + this.index = 0; + /** The start of the last entity. */ + this.entityStart = 0; + /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */ + this.baseState = 1; + /** For special parsing behavior inside of script and style tags. */ + this.inRCDATA = false; + /** For disabling RCDATA tags handling */ + this.inXML = false; + /** For disabling interpolation parsing in v-pre */ + this.inVPre = false; + /** Record newline positions for fast line / column calculation */ + this.newlines = []; + this.mode = 0; + this.delimiterOpen = defaultDelimitersOpen; + this.delimiterClose = defaultDelimitersClose; + this.delimiterIndex = -1; + this.currentSequence = void 0; + this.sequenceIndex = 0; + { + this.entityDecoder = new decode.EntityDecoder( + decode.htmlDecodeTree, + (cp, consumed) => this.emitCodePoint(cp, consumed) + ); + } + } + get inSFCRoot() { + return this.mode === 2 && this.stack.length === 0; + } + reset() { + this.state = 1; + this.mode = 0; + this.buffer = ""; + this.sectionStart = 0; + this.index = 0; + this.baseState = 1; + this.inRCDATA = false; + this.currentSequence = void 0; + this.newlines.length = 0; + this.delimiterOpen = defaultDelimitersOpen; + this.delimiterClose = defaultDelimitersClose; + } + /** + * Generate Position object with line / column information using recorded + * newline positions. We know the index is always going to be an already + * processed index, so all the newlines up to this index should have been + * recorded. + */ + getPos(index) { + let line = 1; + let column = index + 1; + const length = this.newlines.length; + let j = -1; + if (length > 100) { + let l = -1; + let r = length; + while (l + 1 < r) { + const m = l + r >>> 1; + this.newlines[m] < index ? l = m : r = m; + } + j = l; + } else { + for (let i = length - 1; i >= 0; i--) { + if (index > this.newlines[i]) { + j = i; + break; + } + } + } + if (j >= 0) { + line = j + 2; + column = index - this.newlines[j]; + } + return { + column, + line, + offset: index + }; + } + peek() { + return this.buffer.charCodeAt(this.index + 1); + } + stateText(c) { + if (c === 60) { + if (this.index > this.sectionStart) { + this.cbs.ontext(this.sectionStart, this.index); + } + this.state = 5; + this.sectionStart = this.index; + } else if (c === 38) { + this.startEntity(); + } else if (!this.inVPre && c === this.delimiterOpen[0]) { + this.state = 2; + this.delimiterIndex = 0; + this.stateInterpolationOpen(c); + } + } + stateInterpolationOpen(c) { + if (c === this.delimiterOpen[this.delimiterIndex]) { + if (this.delimiterIndex === this.delimiterOpen.length - 1) { + const start = this.index + 1 - this.delimiterOpen.length; + if (start > this.sectionStart) { + this.cbs.ontext(this.sectionStart, start); + } + this.state = 3; + this.sectionStart = start; + } else { + this.delimiterIndex++; + } + } else if (this.inRCDATA) { + this.state = 32; + this.stateInRCDATA(c); + } else { + this.state = 1; + this.stateText(c); + } + } + stateInterpolation(c) { + if (c === this.delimiterClose[0]) { + this.state = 4; + this.delimiterIndex = 0; + this.stateInterpolationClose(c); + } + } + stateInterpolationClose(c) { + if (c === this.delimiterClose[this.delimiterIndex]) { + if (this.delimiterIndex === this.delimiterClose.length - 1) { + this.cbs.oninterpolation(this.sectionStart, this.index + 1); + if (this.inRCDATA) { + this.state = 32; + } else { + this.state = 1; + } + this.sectionStart = this.index + 1; + } else { + this.delimiterIndex++; + } + } else { + this.state = 3; + this.stateInterpolation(c); + } + } + stateSpecialStartSequence(c) { + const isEnd = this.sequenceIndex === this.currentSequence.length; + const isMatch = isEnd ? ( + // If we are at the end of the sequence, make sure the tag name has ended + isEndOfTagSection(c) + ) : ( + // Otherwise, do a case-insensitive comparison + (c | 32) === this.currentSequence[this.sequenceIndex] + ); + if (!isMatch) { + this.inRCDATA = false; + } else if (!isEnd) { + this.sequenceIndex++; + return; + } + this.sequenceIndex = 0; + this.state = 6; + this.stateInTagName(c); + } + /** Look for an end tag. For <title> and <textarea>, also decode entities. */ + stateInRCDATA(c) { + if (this.sequenceIndex === this.currentSequence.length) { + if (c === 62 || isWhitespace(c)) { + const endOfText = this.index - this.currentSequence.length; + if (this.sectionStart < endOfText) { + const actualIndex = this.index; + this.index = endOfText; + this.cbs.ontext(this.sectionStart, endOfText); + this.index = actualIndex; + } + this.sectionStart = endOfText + 2; + this.stateInClosingTagName(c); + this.inRCDATA = false; + return; + } + this.sequenceIndex = 0; + } + if ((c | 32) === this.currentSequence[this.sequenceIndex]) { + this.sequenceIndex += 1; + } else if (this.sequenceIndex === 0) { + if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) { + if (c === 38) { + this.startEntity(); + } else if (!this.inVPre && c === this.delimiterOpen[0]) { + this.state = 2; + this.delimiterIndex = 0; + this.stateInterpolationOpen(c); + } + } else if (this.fastForwardTo(60)) { + this.sequenceIndex = 1; + } + } else { + this.sequenceIndex = Number(c === 60); + } + } + stateCDATASequence(c) { + if (c === Sequences.Cdata[this.sequenceIndex]) { + if (++this.sequenceIndex === Sequences.Cdata.length) { + this.state = 28; + this.currentSequence = Sequences.CdataEnd; + this.sequenceIndex = 0; + this.sectionStart = this.index + 1; + } + } else { + this.sequenceIndex = 0; + this.state = 23; + this.stateInDeclaration(c); + } + } + /** + * When we wait for one specific character, we can speed things up + * by skipping through the buffer until we find it. + * + * @returns Whether the character was found. + */ + fastForwardTo(c) { + while (++this.index < this.buffer.length) { + const cc = this.buffer.charCodeAt(this.index); + if (cc === 10) { + this.newlines.push(this.index); + } + if (cc === c) { + return true; + } + } + this.index = this.buffer.length - 1; + return false; + } + /** + * Comments and CDATA end with `-->` and `]]>`. + * + * Their common qualities are: + * - Their end sequences have a distinct character they start with. + * - That character is then repeated, so we have to check multiple repeats. + * - All characters but the start character of the sequence can be skipped. + */ + stateInCommentLike(c) { + if (c === this.currentSequence[this.sequenceIndex]) { + if (++this.sequenceIndex === this.currentSequence.length) { + if (this.currentSequence === Sequences.CdataEnd) { + this.cbs.oncdata(this.sectionStart, this.index - 2); + } else { + this.cbs.oncomment(this.sectionStart, this.index - 2); + } + this.sequenceIndex = 0; + this.sectionStart = this.index + 1; + this.state = 1; + } + } else if (this.sequenceIndex === 0) { + if (this.fastForwardTo(this.currentSequence[0])) { + this.sequenceIndex = 1; + } + } else if (c !== this.currentSequence[this.sequenceIndex - 1]) { + this.sequenceIndex = 0; + } + } + startSpecial(sequence, offset) { + this.enterRCDATA(sequence, offset); + this.state = 31; + } + enterRCDATA(sequence, offset) { + this.inRCDATA = true; + this.currentSequence = sequence; + this.sequenceIndex = offset; + } + stateBeforeTagName(c) { + if (c === 33) { + this.state = 22; + this.sectionStart = this.index + 1; + } else if (c === 63) { + this.state = 24; + this.sectionStart = this.index + 1; + } else if (isTagStartChar(c)) { + this.sectionStart = this.index; + if (this.mode === 0) { + this.state = 6; + } else if (this.inSFCRoot) { + this.state = 34; + } else if (!this.inXML) { + if (c === 116) { + this.state = 30; + } else { + this.state = c === 115 ? 29 : 6; + } + } else { + this.state = 6; + } + } else if (c === 47) { + this.state = 8; + } else { + this.state = 1; + this.stateText(c); + } + } + stateInTagName(c) { + if (isEndOfTagSection(c)) { + this.handleTagName(c); + } + } + stateInSFCRootTagName(c) { + if (isEndOfTagSection(c)) { + const tag = this.buffer.slice(this.sectionStart, this.index); + if (tag !== "template") { + this.enterRCDATA(toCharCodes(`</` + tag), 0); + } + this.handleTagName(c); + } + } + handleTagName(c) { + this.cbs.onopentagname(this.sectionStart, this.index); + this.sectionStart = -1; + this.state = 11; + this.stateBeforeAttrName(c); + } + stateBeforeClosingTagName(c) { + if (isWhitespace(c)) ; else if (c === 62) { + { + this.cbs.onerr(14, this.index); + } + this.state = 1; + this.sectionStart = this.index + 1; + } else { + this.state = isTagStartChar(c) ? 9 : 27; + this.sectionStart = this.index; + } + } + stateInClosingTagName(c) { + if (c === 62 || isWhitespace(c)) { + this.cbs.onclosetag(this.sectionStart, this.index); + this.sectionStart = -1; + this.state = 10; + this.stateAfterClosingTagName(c); + } + } + stateAfterClosingTagName(c) { + if (c === 62) { + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeAttrName(c) { + if (c === 62) { + this.cbs.onopentagend(this.index); + if (this.inRCDATA) { + this.state = 32; + } else { + this.state = 1; + } + this.sectionStart = this.index + 1; + } else if (c === 47) { + this.state = 7; + if (this.peek() !== 62) { + this.cbs.onerr(22, this.index); + } + } else if (c === 60 && this.peek() === 47) { + this.cbs.onopentagend(this.index); + this.state = 5; + this.sectionStart = this.index; + } else if (!isWhitespace(c)) { + if (c === 61) { + this.cbs.onerr( + 19, + this.index + ); + } + this.handleAttrStart(c); + } + } + handleAttrStart(c) { + if (c === 118 && this.peek() === 45) { + this.state = 13; + this.sectionStart = this.index; + } else if (c === 46 || c === 58 || c === 64 || c === 35) { + this.cbs.ondirname(this.index, this.index + 1); + this.state = 14; + this.sectionStart = this.index + 1; + } else { + this.state = 12; + this.sectionStart = this.index; + } + } + stateInSelfClosingTag(c) { + if (c === 62) { + this.cbs.onselfclosingtag(this.index); + this.state = 1; + this.sectionStart = this.index + 1; + this.inRCDATA = false; + } else if (!isWhitespace(c)) { + this.state = 11; + this.stateBeforeAttrName(c); + } + } + stateInAttrName(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.onattribname(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 34 || c === 39 || c === 60) { + this.cbs.onerr( + 17, + this.index + ); + } + } + stateInDirName(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirname(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 58) { + this.cbs.ondirname(this.sectionStart, this.index); + this.state = 14; + this.sectionStart = this.index + 1; + } else if (c === 46) { + this.cbs.ondirname(this.sectionStart, this.index); + this.state = 16; + this.sectionStart = this.index + 1; + } + } + stateInDirArg(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirarg(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 91) { + this.state = 15; + } else if (c === 46) { + this.cbs.ondirarg(this.sectionStart, this.index); + this.state = 16; + this.sectionStart = this.index + 1; + } + } + stateInDynamicDirArg(c) { + if (c === 93) { + this.state = 14; + } else if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirarg(this.sectionStart, this.index + 1); + this.handleAttrNameEnd(c); + { + this.cbs.onerr( + 27, + this.index + ); + } + } + } + stateInDirModifier(c) { + if (c === 61 || isEndOfTagSection(c)) { + this.cbs.ondirmodifier(this.sectionStart, this.index); + this.handleAttrNameEnd(c); + } else if (c === 46) { + this.cbs.ondirmodifier(this.sectionStart, this.index); + this.sectionStart = this.index + 1; + } + } + handleAttrNameEnd(c) { + this.sectionStart = this.index; + this.state = 17; + this.cbs.onattribnameend(this.index); + this.stateAfterAttrName(c); + } + stateAfterAttrName(c) { + if (c === 61) { + this.state = 18; + } else if (c === 47 || c === 62) { + this.cbs.onattribend(0, this.sectionStart); + this.sectionStart = -1; + this.state = 11; + this.stateBeforeAttrName(c); + } else if (!isWhitespace(c)) { + this.cbs.onattribend(0, this.sectionStart); + this.handleAttrStart(c); + } + } + stateBeforeAttrValue(c) { + if (c === 34) { + this.state = 19; + this.sectionStart = this.index + 1; + } else if (c === 39) { + this.state = 20; + this.sectionStart = this.index + 1; + } else if (!isWhitespace(c)) { + this.sectionStart = this.index; + this.state = 21; + this.stateInAttrValueNoQuotes(c); + } + } + handleInAttrValue(c, quote) { + if (c === quote || false) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = -1; + this.cbs.onattribend( + quote === 34 ? 3 : 2, + this.index + 1 + ); + this.state = 11; + } else if (c === 38) { + this.startEntity(); + } + } + stateInAttrValueDoubleQuotes(c) { + this.handleInAttrValue(c, 34); + } + stateInAttrValueSingleQuotes(c) { + this.handleInAttrValue(c, 39); + } + stateInAttrValueNoQuotes(c) { + if (isWhitespace(c) || c === 62) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = -1; + this.cbs.onattribend(1, this.index); + this.state = 11; + this.stateBeforeAttrName(c); + } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) { + this.cbs.onerr( + 18, + this.index + ); + } else if (c === 38) { + this.startEntity(); + } + } + stateBeforeDeclaration(c) { + if (c === 91) { + this.state = 26; + this.sequenceIndex = 0; + } else { + this.state = c === 45 ? 25 : 23; + } + } + stateInDeclaration(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateInProcessingInstruction(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.cbs.onprocessinginstruction(this.sectionStart, this.index); + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeComment(c) { + if (c === 45) { + this.state = 28; + this.currentSequence = Sequences.CommentEnd; + this.sequenceIndex = 2; + this.sectionStart = this.index + 1; + } else { + this.state = 23; + } + } + stateInSpecialComment(c) { + if (c === 62 || this.fastForwardTo(62)) { + this.cbs.oncomment(this.sectionStart, this.index); + this.state = 1; + this.sectionStart = this.index + 1; + } + } + stateBeforeSpecialS(c) { + if (c === Sequences.ScriptEnd[3]) { + this.startSpecial(Sequences.ScriptEnd, 4); + } else if (c === Sequences.StyleEnd[3]) { + this.startSpecial(Sequences.StyleEnd, 4); + } else { + this.state = 6; + this.stateInTagName(c); + } + } + stateBeforeSpecialT(c) { + if (c === Sequences.TitleEnd[3]) { + this.startSpecial(Sequences.TitleEnd, 4); + } else if (c === Sequences.TextareaEnd[3]) { + this.startSpecial(Sequences.TextareaEnd, 4); + } else { + this.state = 6; + this.stateInTagName(c); + } + } + startEntity() { + { + this.baseState = this.state; + this.state = 33; + this.entityStart = this.index; + this.entityDecoder.startEntity( + this.baseState === 1 || this.baseState === 32 ? decode.DecodingMode.Legacy : decode.DecodingMode.Attribute + ); + } + } + stateInEntity() { + { + const length = this.entityDecoder.write(this.buffer, this.index); + if (length >= 0) { + this.state = this.baseState; + if (length === 0) { + this.index = this.entityStart; + } + } else { + this.index = this.buffer.length - 1; + } + } + } + /** + * Iterates through the buffer, calling the function corresponding to the current state. + * + * States that are more likely to be hit are higher up, as a performance improvement. + */ + parse(input) { + this.buffer = input; + while (this.index < this.buffer.length) { + const c = this.buffer.charCodeAt(this.index); + if (c === 10 && this.state !== 33) { + this.newlines.push(this.index); + } + switch (this.state) { + case 1: { + this.stateText(c); + break; + } + case 2: { + this.stateInterpolationOpen(c); + break; + } + case 3: { + this.stateInterpolation(c); + break; + } + case 4: { + this.stateInterpolationClose(c); + break; + } + case 31: { + this.stateSpecialStartSequence(c); + break; + } + case 32: { + this.stateInRCDATA(c); + break; + } + case 26: { + this.stateCDATASequence(c); + break; + } + case 19: { + this.stateInAttrValueDoubleQuotes(c); + break; + } + case 12: { + this.stateInAttrName(c); + break; + } + case 13: { + this.stateInDirName(c); + break; + } + case 14: { + this.stateInDirArg(c); + break; + } + case 15: { + this.stateInDynamicDirArg(c); + break; + } + case 16: { + this.stateInDirModifier(c); + break; + } + case 28: { + this.stateInCommentLike(c); + break; + } + case 27: { + this.stateInSpecialComment(c); + break; + } + case 11: { + this.stateBeforeAttrName(c); + break; + } + case 6: { + this.stateInTagName(c); + break; + } + case 34: { + this.stateInSFCRootTagName(c); + break; + } + case 9: { + this.stateInClosingTagName(c); + break; + } + case 5: { + this.stateBeforeTagName(c); + break; + } + case 17: { + this.stateAfterAttrName(c); + break; + } + case 20: { + this.stateInAttrValueSingleQuotes(c); + break; + } + case 18: { + this.stateBeforeAttrValue(c); + break; + } + case 8: { + this.stateBeforeClosingTagName(c); + break; + } + case 10: { + this.stateAfterClosingTagName(c); + break; + } + case 29: { + this.stateBeforeSpecialS(c); + break; + } + case 30: { + this.stateBeforeSpecialT(c); + break; + } + case 21: { + this.stateInAttrValueNoQuotes(c); + break; + } + case 7: { + this.stateInSelfClosingTag(c); + break; + } + case 23: { + this.stateInDeclaration(c); + break; + } + case 22: { + this.stateBeforeDeclaration(c); + break; + } + case 25: { + this.stateBeforeComment(c); + break; + } + case 24: { + this.stateInProcessingInstruction(c); + break; + } + case 33: { + this.stateInEntity(); + break; + } + } + this.index++; + } + this.cleanup(); + this.finish(); + } + /** + * Remove data that has already been consumed from the buffer. + */ + cleanup() { + if (this.sectionStart !== this.index) { + if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) { + this.cbs.ontext(this.sectionStart, this.index); + this.sectionStart = this.index; + } else if (this.state === 19 || this.state === 20 || this.state === 21) { + this.cbs.onattribdata(this.sectionStart, this.index); + this.sectionStart = this.index; + } + } + } + finish() { + if (this.state === 33) { + this.entityDecoder.end(); + this.state = this.baseState; + } + this.handleTrailingData(); + this.cbs.onend(); + } + /** Handle any trailing data. */ + handleTrailingData() { + const endIndex = this.buffer.length; + if (this.sectionStart >= endIndex) { + return; + } + if (this.state === 28) { + if (this.currentSequence === Sequences.CdataEnd) { + this.cbs.oncdata(this.sectionStart, endIndex); + } else { + this.cbs.oncomment(this.sectionStart, endIndex); + } + } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else { + this.cbs.ontext(this.sectionStart, endIndex); + } + } + emitCodePoint(cp, consumed) { + { + if (this.baseState !== 1 && this.baseState !== 32) { + if (this.sectionStart < this.entityStart) { + this.cbs.onattribdata(this.sectionStart, this.entityStart); + } + this.sectionStart = this.entityStart + consumed; + this.index = this.sectionStart - 1; + this.cbs.onattribentity( + decode.fromCodePoint(cp), + this.entityStart, + this.sectionStart + ); + } else { + if (this.sectionStart < this.entityStart) { + this.cbs.ontext(this.sectionStart, this.entityStart); + } + this.sectionStart = this.entityStart + consumed; + this.index = this.sectionStart - 1; + this.cbs.ontextentity( + decode.fromCodePoint(cp), + this.entityStart, + this.sectionStart + ); + } + } + } +} + +const CompilerDeprecationTypes = { + "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT", + "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC", + "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER", + "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE", + "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE", + "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE", + "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE", + "COMPILER_FILTERS": "COMPILER_FILTERS" +}; +const deprecationData = { + ["COMPILER_IS_ON_ELEMENT"]: { + message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`, + link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html` + }, + ["COMPILER_V_BIND_SYNC"]: { + message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html` + }, + ["COMPILER_V_BIND_OBJECT_ORDER"]: { + message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html` + }, + ["COMPILER_V_ON_NATIVE"]: { + message: `.native modifier for v-on has been removed as is no longer necessary.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html` + }, + ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: { + message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`, + link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html` + }, + ["COMPILER_NATIVE_TEMPLATE"]: { + message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.` + }, + ["COMPILER_INLINE_TEMPLATE"]: { + message: `"inline-template" has been removed in Vue 3.`, + link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html` + }, + ["COMPILER_FILTERS"]: { + message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`, + link: `https://v3-migration.vuejs.org/breaking-changes/filters.html` + } +}; +function getCompatValue(key, { compatConfig }) { + const value = compatConfig && compatConfig[key]; + if (key === "MODE") { + return value || 3; + } else { + return value; + } +} +function isCompatEnabled(key, context) { + const mode = getCompatValue("MODE", context); + const value = getCompatValue(key, context); + return mode === 3 ? value === true : value !== false; +} +function checkCompatEnabled(key, context, loc, ...args) { + const enabled = isCompatEnabled(key, context); + if (enabled) { + warnDeprecation(key, context, loc, ...args); + } + return enabled; +} +function warnDeprecation(key, context, loc, ...args) { + const val = getCompatValue(key, context); + if (val === "suppress-warning") { + return; + } + const { message, link } = deprecationData[key]; + const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? ` + Details: ${link}` : ``}`; + const err = new SyntaxError(msg); + err.code = key; + if (loc) err.loc = loc; + context.onWarn(err); +} + +function defaultOnError(error) { + throw error; +} +function defaultOnWarn(msg) { + console.warn(`[Vue warn] ${msg.message}`); +} +function createCompilerError(code, loc, messages, additionalMessage) { + const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ; + const error = new SyntaxError(String(msg)); + error.code = code; + error.loc = loc; + return error; +} +const ErrorCodes = { + "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0, + "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT", + "CDATA_IN_HTML_CONTENT": 1, + "1": "CDATA_IN_HTML_CONTENT", + "DUPLICATE_ATTRIBUTE": 2, + "2": "DUPLICATE_ATTRIBUTE", + "END_TAG_WITH_ATTRIBUTES": 3, + "3": "END_TAG_WITH_ATTRIBUTES", + "END_TAG_WITH_TRAILING_SOLIDUS": 4, + "4": "END_TAG_WITH_TRAILING_SOLIDUS", + "EOF_BEFORE_TAG_NAME": 5, + "5": "EOF_BEFORE_TAG_NAME", + "EOF_IN_CDATA": 6, + "6": "EOF_IN_CDATA", + "EOF_IN_COMMENT": 7, + "7": "EOF_IN_COMMENT", + "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8, + "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT", + "EOF_IN_TAG": 9, + "9": "EOF_IN_TAG", + "INCORRECTLY_CLOSED_COMMENT": 10, + "10": "INCORRECTLY_CLOSED_COMMENT", + "INCORRECTLY_OPENED_COMMENT": 11, + "11": "INCORRECTLY_OPENED_COMMENT", + "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12, + "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME", + "MISSING_ATTRIBUTE_VALUE": 13, + "13": "MISSING_ATTRIBUTE_VALUE", + "MISSING_END_TAG_NAME": 14, + "14": "MISSING_END_TAG_NAME", + "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15, + "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES", + "NESTED_COMMENT": 16, + "16": "NESTED_COMMENT", + "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17, + "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME", + "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18, + "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE", + "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19, + "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME", + "UNEXPECTED_NULL_CHARACTER": 20, + "20": "UNEXPECTED_NULL_CHARACTER", + "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21, + "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME", + "UNEXPECTED_SOLIDUS_IN_TAG": 22, + "22": "UNEXPECTED_SOLIDUS_IN_TAG", + "X_INVALID_END_TAG": 23, + "23": "X_INVALID_END_TAG", + "X_MISSING_END_TAG": 24, + "24": "X_MISSING_END_TAG", + "X_MISSING_INTERPOLATION_END": 25, + "25": "X_MISSING_INTERPOLATION_END", + "X_MISSING_DIRECTIVE_NAME": 26, + "26": "X_MISSING_DIRECTIVE_NAME", + "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27, + "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END", + "X_V_IF_NO_EXPRESSION": 28, + "28": "X_V_IF_NO_EXPRESSION", + "X_V_IF_SAME_KEY": 29, + "29": "X_V_IF_SAME_KEY", + "X_V_ELSE_NO_ADJACENT_IF": 30, + "30": "X_V_ELSE_NO_ADJACENT_IF", + "X_V_FOR_NO_EXPRESSION": 31, + "31": "X_V_FOR_NO_EXPRESSION", + "X_V_FOR_MALFORMED_EXPRESSION": 32, + "32": "X_V_FOR_MALFORMED_EXPRESSION", + "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33, + "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT", + "X_V_BIND_NO_EXPRESSION": 34, + "34": "X_V_BIND_NO_EXPRESSION", + "X_V_ON_NO_EXPRESSION": 35, + "35": "X_V_ON_NO_EXPRESSION", + "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36, + "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET", + "X_V_SLOT_MIXED_SLOT_USAGE": 37, + "37": "X_V_SLOT_MIXED_SLOT_USAGE", + "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38, + "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES", + "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39, + "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN", + "X_V_SLOT_MISPLACED": 40, + "40": "X_V_SLOT_MISPLACED", + "X_V_MODEL_NO_EXPRESSION": 41, + "41": "X_V_MODEL_NO_EXPRESSION", + "X_V_MODEL_MALFORMED_EXPRESSION": 42, + "42": "X_V_MODEL_MALFORMED_EXPRESSION", + "X_V_MODEL_ON_SCOPE_VARIABLE": 43, + "43": "X_V_MODEL_ON_SCOPE_VARIABLE", + "X_V_MODEL_ON_PROPS": 44, + "44": "X_V_MODEL_ON_PROPS", + "X_V_MODEL_ON_CONST": 45, + "45": "X_V_MODEL_ON_CONST", + "X_INVALID_EXPRESSION": 46, + "46": "X_INVALID_EXPRESSION", + "X_KEEP_ALIVE_INVALID_CHILDREN": 47, + "47": "X_KEEP_ALIVE_INVALID_CHILDREN", + "X_PREFIX_ID_NOT_SUPPORTED": 48, + "48": "X_PREFIX_ID_NOT_SUPPORTED", + "X_MODULE_MODE_NOT_SUPPORTED": 49, + "49": "X_MODULE_MODE_NOT_SUPPORTED", + "X_CACHE_HANDLER_NOT_SUPPORTED": 50, + "50": "X_CACHE_HANDLER_NOT_SUPPORTED", + "X_SCOPE_ID_NOT_SUPPORTED": 51, + "51": "X_SCOPE_ID_NOT_SUPPORTED", + "X_VNODE_HOOKS": 52, + "52": "X_VNODE_HOOKS", + "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 53, + "53": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT", + "__EXTEND_POINT__": 54, + "54": "__EXTEND_POINT__" +}; +const errorMessages = { + // parse errors + [0]: "Illegal comment.", + [1]: "CDATA section is allowed only in XML context.", + [2]: "Duplicate attribute.", + [3]: "End tag cannot have attributes.", + [4]: "Illegal '/' in tags.", + [5]: "Unexpected EOF in tag.", + [6]: "Unexpected EOF in CDATA section.", + [7]: "Unexpected EOF in comment.", + [8]: "Unexpected EOF in script.", + [9]: "Unexpected EOF in tag.", + [10]: "Incorrectly closed comment.", + [11]: "Incorrectly opened comment.", + [12]: "Illegal tag name. Use '<' to print '<'.", + [13]: "Attribute value was expected.", + [14]: "End tag name was expected.", + [15]: "Whitespace was expected.", + [16]: "Unexpected '<!--' in comment.", + [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`, + [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).", + [19]: "Attribute name cannot start with '='.", + [21]: "'<?' is allowed only in XML context.", + [20]: `Unexpected null character.`, + [22]: "Illegal '/' in tags.", + // Vue-specific parse errors + [23]: "Invalid end tag.", + [24]: "Element is missing end tag.", + [25]: "Interpolation end sign was not found.", + [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.", + [26]: "Legal directive name was expected.", + // transform errors + [28]: `v-if/v-else-if is missing expression.`, + [29]: `v-if/else branches must use unique keys.`, + [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`, + [31]: `v-for is missing expression.`, + [32]: `v-for has invalid expression.`, + [33]: `<template v-for> key should be placed on the <template> tag.`, + [34]: `v-bind is missing expression.`, + [53]: `v-bind with same-name shorthand only allows static argument.`, + [35]: `v-on is missing expression.`, + [36]: `Unexpected custom directive on <slot> outlet.`, + [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`, + [38]: `Duplicate slot names found. `, + [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`, + [40]: `v-slot can only be used on components or <template> tags.`, + [41]: `v-model is missing expression.`, + [42]: `v-model value must be a valid JavaScript member expression.`, + [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`, + [44]: `v-model cannot be used on a prop, because local prop bindings are not writable. +Use a v-bind binding combined with a v-on listener that emits update:x event instead.`, + [45]: `v-model cannot be used on a const binding because it is not writable.`, + [46]: `Error parsing JavaScript expression: `, + [47]: `<KeepAlive> expects exactly one child component.`, + [52]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`, + // generic errors + [48]: `"prefixIdentifiers" option is not supported in this build of compiler.`, + [49]: `ES module mode is not supported in this build of compiler.`, + [50]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`, + [51]: `"scopeId" option is only supported in module mode.`, + // just to fulfill types + [54]: `` +}; + +function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) { + const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root; + estreeWalker.walk(root, { + enter(node, parent) { + parent && parentStack.push(parent); + if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) { + return this.skip(); + } + if (node.type === "Identifier") { + const isLocal = !!knownIds[node.name]; + const isRefed = isReferencedIdentifier(node, parent, parentStack); + if (includeAll || isRefed && !isLocal) { + onIdentifier(node, parent, parentStack, isRefed, isLocal); + } + } else if (node.type === "ObjectProperty" && // eslint-disable-next-line no-restricted-syntax + (parent == null ? void 0 : parent.type) === "ObjectPattern") { + node.inPattern = true; + } else if (isFunctionType(node)) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkFunctionParams( + node, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "BlockStatement") { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkBlockDeclarations( + node, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "SwitchStatement") { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkSwitchStatement( + node, + false, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } else if (node.type === "CatchClause" && node.param) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + for (const id of extractIdentifiers(node.param)) { + markScopeIdentifier(node, id, knownIds); + } + } + } else if (isForStatement(node)) { + if (node.scopeIds) { + node.scopeIds.forEach((id) => markKnownIds(id, knownIds)); + } else { + walkForStatement( + node, + false, + (id) => markScopeIdentifier(node, id, knownIds) + ); + } + } + }, + leave(node, parent) { + parent && parentStack.pop(); + if (node !== rootExp && node.scopeIds) { + for (const id of node.scopeIds) { + knownIds[id]--; + if (knownIds[id] === 0) { + delete knownIds[id]; + } + } + } + } + }); +} +function isReferencedIdentifier(id, parent, parentStack) { + if (!parent) { + return true; + } + if (id.name === "arguments") { + return false; + } + if (isReferenced(id, parent, parentStack[parentStack.length - 2])) { + return true; + } + switch (parent.type) { + case "AssignmentExpression": + case "AssignmentPattern": + return true; + case "ObjectProperty": + return parent.key !== id && isInDestructureAssignment(parent, parentStack); + case "ArrayPattern": + return isInDestructureAssignment(parent, parentStack); + } + return false; +} +function isInDestructureAssignment(parent, parentStack) { + if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) { + let i = parentStack.length; + while (i--) { + const p = parentStack[i]; + if (p.type === "AssignmentExpression") { + return true; + } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) { + break; + } + } + } + return false; +} +function isInNewExpression(parentStack) { + let i = parentStack.length; + while (i--) { + const p = parentStack[i]; + if (p.type === "NewExpression") { + return true; + } else if (p.type !== "MemberExpression") { + break; + } + } + return false; +} +function walkFunctionParams(node, onIdent) { + for (const p of node.params) { + for (const id of extractIdentifiers(p)) { + onIdent(id); + } + } +} +function walkBlockDeclarations(block, onIdent) { + const body = block.type === "SwitchCase" ? block.consequent : block.body; + for (const stmt of body) { + if (stmt.type === "VariableDeclaration") { + if (stmt.declare) continue; + for (const decl of stmt.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") { + if (stmt.declare || !stmt.id) continue; + onIdent(stmt.id); + } else if (isForStatement(stmt)) { + walkForStatement(stmt, true, onIdent); + } else if (stmt.type === "SwitchStatement") { + walkSwitchStatement(stmt, true, onIdent); + } + } +} +function isForStatement(stmt) { + return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement"; +} +function walkForStatement(stmt, isVar, onIdent) { + const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left; + if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) { + for (const decl of variable.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } +} +function walkSwitchStatement(stmt, isVar, onIdent) { + for (const cs of stmt.cases) { + for (const stmt2 of cs.consequent) { + if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) { + for (const decl of stmt2.declarations) { + for (const id of extractIdentifiers(decl.id)) { + onIdent(id); + } + } + } + } + walkBlockDeclarations(cs, onIdent); + } +} +function extractIdentifiers(param, nodes = []) { + switch (param.type) { + case "Identifier": + nodes.push(param); + break; + case "MemberExpression": + let object = param; + while (object.type === "MemberExpression") { + object = object.object; + } + nodes.push(object); + break; + case "ObjectPattern": + for (const prop of param.properties) { + if (prop.type === "RestElement") { + extractIdentifiers(prop.argument, nodes); + } else { + extractIdentifiers(prop.value, nodes); + } + } + break; + case "ArrayPattern": + param.elements.forEach((element) => { + if (element) extractIdentifiers(element, nodes); + }); + break; + case "RestElement": + extractIdentifiers(param.argument, nodes); + break; + case "AssignmentPattern": + extractIdentifiers(param.left, nodes); + break; + } + return nodes; +} +function markKnownIds(name, knownIds) { + if (name in knownIds) { + knownIds[name]++; + } else { + knownIds[name] = 1; + } +} +function markScopeIdentifier(node, child, knownIds) { + const { name } = child; + if (node.scopeIds && node.scopeIds.has(name)) { + return; + } + markKnownIds(name, knownIds); + (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name); +} +const isFunctionType = (node) => { + return /Function(?:Expression|Declaration)$|Method$/.test(node.type); +}; +const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed; +const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node; +function isReferenced(node, parent, grandparent) { + switch (parent.type) { + // yes: PARENT[NODE] + // yes: NODE.child + // no: parent.NODE + case "MemberExpression": + case "OptionalMemberExpression": + if (parent.property === node) { + return !!parent.computed; + } + return parent.object === node; + case "JSXMemberExpression": + return parent.object === node; + // no: let NODE = init; + // yes: let id = NODE; + case "VariableDeclarator": + return parent.init === node; + // yes: () => NODE + // no: (NODE) => {} + case "ArrowFunctionExpression": + return parent.body === node; + // no: class { #NODE; } + // no: class { get #NODE() {} } + // no: class { #NODE() {} } + // no: class { fn() { return this.#NODE; } } + case "PrivateName": + return false; + // no: class { NODE() {} } + // yes: class { [NODE]() {} } + // no: class { foo(NODE) {} } + case "ClassMethod": + case "ClassPrivateMethod": + case "ObjectMethod": + if (parent.key === node) { + return !!parent.computed; + } + return false; + // yes: { [NODE]: "" } + // no: { NODE: "" } + // depends: { NODE } + // depends: { key: NODE } + case "ObjectProperty": + if (parent.key === node) { + return !!parent.computed; + } + return !grandparent || grandparent.type !== "ObjectPattern"; + // no: class { NODE = value; } + // yes: class { [NODE] = value; } + // yes: class { key = NODE; } + case "ClassProperty": + if (parent.key === node) { + return !!parent.computed; + } + return true; + case "ClassPrivateProperty": + return parent.key !== node; + // no: class NODE {} + // yes: class Foo extends NODE {} + case "ClassDeclaration": + case "ClassExpression": + return parent.superClass === node; + // yes: left = NODE; + // no: NODE = right; + case "AssignmentExpression": + return parent.right === node; + // no: [NODE = foo] = []; + // yes: [foo = NODE] = []; + case "AssignmentPattern": + return parent.right === node; + // no: NODE: for (;;) {} + case "LabeledStatement": + return false; + // no: try {} catch (NODE) {} + case "CatchClause": + return false; + // no: function foo(...NODE) {} + case "RestElement": + return false; + case "BreakStatement": + case "ContinueStatement": + return false; + // no: function NODE() {} + // no: function foo(NODE) {} + case "FunctionDeclaration": + case "FunctionExpression": + return false; + // no: export NODE from "foo"; + // no: export * as NODE from "foo"; + case "ExportNamespaceSpecifier": + case "ExportDefaultSpecifier": + return false; + // no: export { foo as NODE }; + // yes: export { NODE as foo }; + // no: export { NODE as foo } from "foo"; + case "ExportSpecifier": + if (grandparent == null ? void 0 : grandparent.source) { + return false; + } + return parent.local === node; + // no: import NODE from "foo"; + // no: import * as NODE from "foo"; + // no: import { NODE as foo } from "foo"; + // no: import { foo as NODE } from "foo"; + // no: import NODE from "bar"; + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "ImportSpecifier": + return false; + // no: import "foo" assert { NODE: "json" } + case "ImportAttribute": + return false; + // no: <div NODE="foo" /> + case "JSXAttribute": + return false; + // no: [NODE] = []; + // no: ({ NODE }) = []; + case "ObjectPattern": + case "ArrayPattern": + return false; + // no: new.NODE + // no: NODE.target + case "MetaProperty": + return false; + // yes: type X = { someProperty: NODE } + // no: type X = { NODE: OtherType } + case "ObjectTypeProperty": + return parent.key !== node; + // yes: enum X { Foo = NODE } + // no: enum X { NODE } + case "TSEnumMember": + return parent.id !== node; + // yes: { [NODE]: value } + // no: { NODE: value } + case "TSPropertySignature": + if (parent.key === node) { + return !!parent.computed; + } + return true; + } + return true; +} +const TS_NODE_TYPES = [ + "TSAsExpression", + // foo as number + "TSTypeAssertion", + // (<number>foo) + "TSNonNullExpression", + // foo! + "TSInstantiationExpression", + // foo<string> + "TSSatisfiesExpression" + // foo satisfies T +]; +function unwrapTSNode(node) { + if (TS_NODE_TYPES.includes(node.type)) { + return unwrapTSNode(node.expression); + } else { + return node; + } +} + +const isStaticExp = (p) => p.type === 4 && p.isStatic; +function isCoreComponent(tag) { + switch (tag) { + case "Teleport": + case "teleport": + return TELEPORT; + case "Suspense": + case "suspense": + return SUSPENSE; + case "KeepAlive": + case "keep-alive": + return KEEP_ALIVE; + case "BaseTransition": + case "base-transition": + return BASE_TRANSITION; + } +} +const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/; +const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name); +const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/; +const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/; +const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g; +const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source; +const isMemberExpressionBrowser = (exp) => { + const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim()); + let state = 0 /* inMemberExp */; + let stateStack = []; + let currentOpenBracketCount = 0; + let currentOpenParensCount = 0; + let currentStringType = null; + for (let i = 0; i < path.length; i++) { + const char = path.charAt(i); + switch (state) { + case 0 /* inMemberExp */: + if (char === "[") { + stateStack.push(state); + state = 1 /* inBrackets */; + currentOpenBracketCount++; + } else if (char === "(") { + stateStack.push(state); + state = 2 /* inParens */; + currentOpenParensCount++; + } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) { + return false; + } + break; + case 1 /* inBrackets */: + if (char === `'` || char === `"` || char === "`") { + stateStack.push(state); + state = 3 /* inString */; + currentStringType = char; + } else if (char === `[`) { + currentOpenBracketCount++; + } else if (char === `]`) { + if (!--currentOpenBracketCount) { + state = stateStack.pop(); + } + } + break; + case 2 /* inParens */: + if (char === `'` || char === `"` || char === "`") { + stateStack.push(state); + state = 3 /* inString */; + currentStringType = char; + } else if (char === `(`) { + currentOpenParensCount++; + } else if (char === `)`) { + if (i === path.length - 1) { + return false; + } + if (!--currentOpenParensCount) { + state = stateStack.pop(); + } + } + break; + case 3 /* inString */: + if (char === currentStringType) { + state = stateStack.pop(); + currentStringType = null; + } + break; + } + } + return !currentOpenBracketCount && !currentOpenParensCount; +}; +const isMemberExpressionNode = (exp, context) => { + try { + let ret = exp.ast || parser.parseExpression(getExpSource(exp), { + plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] + }); + ret = unwrapTSNode(ret); + return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined"; + } catch (e) { + return false; + } +}; +const isMemberExpression = isMemberExpressionNode; +const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/; +const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp)); +const isFnExpressionNode = (exp, context) => { + try { + let ret = exp.ast || parser.parseExpression(getExpSource(exp), { + plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] + }); + if (ret.type === "Program") { + ret = ret.body[0]; + if (ret.type === "ExpressionStatement") { + ret = ret.expression; + } + } + ret = unwrapTSNode(ret); + return ret.type === "FunctionExpression" || ret.type === "ArrowFunctionExpression"; + } catch (e) { + return false; + } +}; +const isFnExpression = isFnExpressionNode; +function advancePositionWithClone(pos, source, numberOfCharacters = source.length) { + return advancePositionWithMutation( + { + offset: pos.offset, + line: pos.line, + column: pos.column + }, + source, + numberOfCharacters + ); +} +function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) { + let linesCount = 0; + let lastNewLinePos = -1; + for (let i = 0; i < numberOfCharacters; i++) { + if (source.charCodeAt(i) === 10) { + linesCount++; + lastNewLinePos = i; + } + } + pos.offset += numberOfCharacters; + pos.line += linesCount; + pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos; + return pos; +} +function assert(condition, msg) { + if (!condition) { + throw new Error(msg || `unexpected compiler condition`); + } +} +function findDir(node, name, allowEmpty = false) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) { + return p; + } + } +} +function findProp(node, name, dynamicOnly = false, allowEmpty = false) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + if (dynamicOnly) continue; + if (p.name === name && (p.value || allowEmpty)) { + return p; + } + } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) { + return p; + } + } +} +function isStaticArgOf(arg, name) { + return !!(arg && isStaticExp(arg) && arg.content === name); +} +function hasDynamicKeyVBind(node) { + return node.props.some( + (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj" + p.arg.type !== 4 || // v-bind:[_ctx.foo] + !p.arg.isStatic) + // v-bind:[foo] + ); +} +function isText$1(node) { + return node.type === 5 || node.type === 2; +} +function isVPre(p) { + return p.type === 7 && p.name === "pre"; +} +function isVSlot(p) { + return p.type === 7 && p.name === "slot"; +} +function isTemplateNode(node) { + return node.type === 1 && node.tagType === 3; +} +function isSlotOutlet(node) { + return node.type === 1 && node.tagType === 2; +} +const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]); +function getUnnormalizedProps(props, callPath = []) { + if (props && !shared.isString(props) && props.type === 14) { + const callee = props.callee; + if (!shared.isString(callee) && propsHelperSet.has(callee)) { + return getUnnormalizedProps( + props.arguments[0], + callPath.concat(props) + ); + } + } + return [props, callPath]; +} +function injectProp(node, prop, context) { + let propsWithInjection; + let props = node.type === 13 ? node.props : node.arguments[2]; + let callPath = []; + let parentCall; + if (props && !shared.isString(props) && props.type === 14) { + const ret = getUnnormalizedProps(props); + props = ret[0]; + callPath = ret[1]; + parentCall = callPath[callPath.length - 1]; + } + if (props == null || shared.isString(props)) { + propsWithInjection = createObjectExpression([prop]); + } else if (props.type === 14) { + const first = props.arguments[0]; + if (!shared.isString(first) && first.type === 15) { + if (!hasProp(prop, first)) { + first.properties.unshift(prop); + } + } else { + if (props.callee === TO_HANDLERS) { + propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ + createObjectExpression([prop]), + props + ]); + } else { + props.arguments.unshift(createObjectExpression([prop])); + } + } + !propsWithInjection && (propsWithInjection = props); + } else if (props.type === 15) { + if (!hasProp(prop, props)) { + props.properties.unshift(prop); + } + propsWithInjection = props; + } else { + propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ + createObjectExpression([prop]), + props + ]); + if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) { + parentCall = callPath[callPath.length - 2]; + } + } + if (node.type === 13) { + if (parentCall) { + parentCall.arguments[0] = propsWithInjection; + } else { + node.props = propsWithInjection; + } + } else { + if (parentCall) { + parentCall.arguments[0] = propsWithInjection; + } else { + node.arguments[2] = propsWithInjection; + } + } +} +function hasProp(prop, props) { + let result = false; + if (prop.key.type === 4) { + const propKeyName = prop.key.content; + result = props.properties.some( + (p) => p.key.type === 4 && p.key.content === propKeyName + ); + } + return result; +} +function toValidAssetId(name, type) { + return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => { + return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString(); + })}`; +} +function hasScopeRef(node, ids) { + if (!node || Object.keys(ids).length === 0) { + return false; + } + switch (node.type) { + case 1: + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) { + return true; + } + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 11: + if (hasScopeRef(node.source, ids)) { + return true; + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 9: + return node.branches.some((b) => hasScopeRef(b, ids)); + case 10: + if (hasScopeRef(node.condition, ids)) { + return true; + } + return node.children.some((c) => hasScopeRef(c, ids)); + case 4: + return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content]; + case 8: + return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids)); + case 5: + case 12: + return hasScopeRef(node.content, ids); + case 2: + case 3: + case 20: + return false; + default: + return false; + } +} +function getMemoedVNodeCall(node) { + if (node.type === 14 && node.callee === WITH_MEMO) { + return node.arguments[1].returns; + } else { + return node; + } +} +const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/; +function isAllWhitespace(str) { + for (let i = 0; i < str.length; i++) { + if (!isWhitespace(str.charCodeAt(i))) { + return false; + } + } + return true; +} +function isWhitespaceText(node) { + return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content); +} +function isCommentOrWhitespace(node) { + return node.type === 3 || isWhitespaceText(node); +} + +const defaultParserOptions = { + parseMode: "base", + ns: 0, + delimiters: [`{{`, `}}`], + getNamespace: () => 0, + isVoidTag: shared.NO, + isPreTag: shared.NO, + isIgnoreNewlineTag: shared.NO, + isCustomElement: shared.NO, + onError: defaultOnError, + onWarn: defaultOnWarn, + comments: true, + prefixIdentifiers: false +}; +let currentOptions = defaultParserOptions; +let currentRoot = null; +let currentInput = ""; +let currentOpenTag = null; +let currentProp = null; +let currentAttrValue = ""; +let currentAttrStartIndex = -1; +let currentAttrEndIndex = -1; +let inPre = 0; +let inVPre = false; +let currentVPreBoundary = null; +const stack = []; +const tokenizer = new Tokenizer(stack, { + onerr: emitError, + ontext(start, end) { + onText(getSlice(start, end), start, end); + }, + ontextentity(char, start, end) { + onText(char, start, end); + }, + oninterpolation(start, end) { + if (inVPre) { + return onText(getSlice(start, end), start, end); + } + let innerStart = start + tokenizer.delimiterOpen.length; + let innerEnd = end - tokenizer.delimiterClose.length; + while (isWhitespace(currentInput.charCodeAt(innerStart))) { + innerStart++; + } + while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) { + innerEnd--; + } + let exp = getSlice(innerStart, innerEnd); + if (exp.includes("&")) { + { + exp = decode.decodeHTML(exp); + } + } + addNode({ + type: 5, + content: createExp(exp, false, getLoc(innerStart, innerEnd)), + loc: getLoc(start, end) + }); + }, + onopentagname(start, end) { + const name = getSlice(start, end); + currentOpenTag = { + type: 1, + tag: name, + ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns), + tagType: 0, + // will be refined on tag close + props: [], + children: [], + loc: getLoc(start - 1, end), + codegenNode: void 0 + }; + }, + onopentagend(end) { + endOpenTag(end); + }, + onclosetag(start, end) { + const name = getSlice(start, end); + if (!currentOptions.isVoidTag(name)) { + let found = false; + for (let i = 0; i < stack.length; i++) { + const e = stack[i]; + if (e.tag.toLowerCase() === name.toLowerCase()) { + found = true; + if (i > 0) { + emitError(24, stack[0].loc.start.offset); + } + for (let j = 0; j <= i; j++) { + const el = stack.shift(); + onCloseTag(el, end, j < i); + } + break; + } + } + if (!found) { + emitError(23, backTrack(start, 60)); + } + } + }, + onselfclosingtag(end) { + const name = currentOpenTag.tag; + currentOpenTag.isSelfClosing = true; + endOpenTag(end); + if (stack[0] && stack[0].tag === name) { + onCloseTag(stack.shift(), end); + } + }, + onattribname(start, end) { + currentProp = { + type: 6, + name: getSlice(start, end), + nameLoc: getLoc(start, end), + value: void 0, + loc: getLoc(start) + }; + }, + ondirname(start, end) { + const raw = getSlice(start, end); + const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2); + if (!inVPre && name === "") { + emitError(26, start); + } + if (inVPre || name === "") { + currentProp = { + type: 6, + name: raw, + nameLoc: getLoc(start, end), + value: void 0, + loc: getLoc(start) + }; + } else { + currentProp = { + type: 7, + name, + rawName: raw, + exp: void 0, + arg: void 0, + modifiers: raw === "." ? [createSimpleExpression("prop")] : [], + loc: getLoc(start) + }; + if (name === "pre") { + inVPre = tokenizer.inVPre = true; + currentVPreBoundary = currentOpenTag; + const props = currentOpenTag.props; + for (let i = 0; i < props.length; i++) { + if (props[i].type === 7) { + props[i] = dirToAttr(props[i]); + } + } + } + } + }, + ondirarg(start, end) { + if (start === end) return; + const arg = getSlice(start, end); + if (inVPre && !isVPre(currentProp)) { + currentProp.name += arg; + setLocEnd(currentProp.nameLoc, end); + } else { + const isStatic = arg[0] !== `[`; + currentProp.arg = createExp( + isStatic ? arg : arg.slice(1, -1), + isStatic, + getLoc(start, end), + isStatic ? 3 : 0 + ); + } + }, + ondirmodifier(start, end) { + const mod = getSlice(start, end); + if (inVPre && !isVPre(currentProp)) { + currentProp.name += "." + mod; + setLocEnd(currentProp.nameLoc, end); + } else if (currentProp.name === "slot") { + const arg = currentProp.arg; + if (arg) { + arg.content += "." + mod; + setLocEnd(arg.loc, end); + } + } else { + const exp = createSimpleExpression(mod, true, getLoc(start, end)); + currentProp.modifiers.push(exp); + } + }, + onattribdata(start, end) { + currentAttrValue += getSlice(start, end); + if (currentAttrStartIndex < 0) currentAttrStartIndex = start; + currentAttrEndIndex = end; + }, + onattribentity(char, start, end) { + currentAttrValue += char; + if (currentAttrStartIndex < 0) currentAttrStartIndex = start; + currentAttrEndIndex = end; + }, + onattribnameend(end) { + const start = currentProp.loc.start.offset; + const name = getSlice(start, end); + if (currentProp.type === 7) { + currentProp.rawName = name; + } + if (currentOpenTag.props.some( + (p) => (p.type === 7 ? p.rawName : p.name) === name + )) { + emitError(2, start); + } + }, + onattribend(quote, end) { + if (currentOpenTag && currentProp) { + setLocEnd(currentProp.loc, end); + if (quote !== 0) { + if (currentProp.type === 6) { + if (currentProp.name === "class") { + currentAttrValue = condense(currentAttrValue).trim(); + } + if (quote === 1 && !currentAttrValue) { + emitError(13, end); + } + currentProp.value = { + type: 2, + content: currentAttrValue, + loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1) + }; + if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") { + tokenizer.enterRCDATA(toCharCodes(`</template`), 0); + } + } else { + let expParseMode = 0 /* Normal */; + { + if (currentProp.name === "for") { + expParseMode = 3 /* Skip */; + } else if (currentProp.name === "slot") { + expParseMode = 1 /* Params */; + } else if (currentProp.name === "on" && currentAttrValue.includes(";")) { + expParseMode = 2 /* Statements */; + } + } + currentProp.exp = createExp( + currentAttrValue, + false, + getLoc(currentAttrStartIndex, currentAttrEndIndex), + 0, + expParseMode + ); + if (currentProp.name === "for") { + currentProp.forParseResult = parseForExpression(currentProp.exp); + } + let syncIndex = -1; + if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex( + (mod) => mod.content === "sync" + )) > -1 && checkCompatEnabled( + "COMPILER_V_BIND_SYNC", + currentOptions, + currentProp.loc, + currentProp.arg.loc.source + )) { + currentProp.name = "model"; + currentProp.modifiers.splice(syncIndex, 1); + } + } + } + if (currentProp.type !== 7 || currentProp.name !== "pre") { + currentOpenTag.props.push(currentProp); + } + } + currentAttrValue = ""; + currentAttrStartIndex = currentAttrEndIndex = -1; + }, + oncomment(start, end) { + if (currentOptions.comments) { + addNode({ + type: 3, + content: getSlice(start, end), + loc: getLoc(start - 4, end + 3) + }); + } + }, + onend() { + const end = currentInput.length; + if (tokenizer.state !== 1) { + switch (tokenizer.state) { + case 5: + case 8: + emitError(5, end); + break; + case 3: + case 4: + emitError( + 25, + tokenizer.sectionStart + ); + break; + case 28: + if (tokenizer.currentSequence === Sequences.CdataEnd) { + emitError(6, end); + } else { + emitError(7, end); + } + break; + case 6: + case 7: + case 9: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + // " + case 20: + // ' + case 21: + emitError(9, end); + break; + } + } + for (let index = 0; index < stack.length; index++) { + onCloseTag(stack[index], end - 1); + emitError(24, stack[index].loc.start.offset); + } + }, + oncdata(start, end) { + if (stack[0].ns !== 0) { + onText(getSlice(start, end), start, end); + } else { + emitError(1, start - 9); + } + }, + onprocessinginstruction(start) { + if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) { + emitError( + 21, + start - 1 + ); + } + } +}); +const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; +const stripParensRE = /^\(|\)$/g; +function parseForExpression(input) { + const loc = input.loc; + const exp = input.content; + const inMatch = exp.match(forAliasRE); + if (!inMatch) return; + const [, LHS, RHS] = inMatch; + const createAliasExpression = (content, offset, asParam = false) => { + const start = loc.start.offset + offset; + const end = start + content.length; + return createExp( + content, + false, + getLoc(start, end), + 0, + asParam ? 1 /* Params */ : 0 /* Normal */ + ); + }; + const result = { + source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)), + value: void 0, + key: void 0, + index: void 0, + finalized: false + }; + let valueContent = LHS.trim().replace(stripParensRE, "").trim(); + const trimmedOffset = LHS.indexOf(valueContent); + const iteratorMatch = valueContent.match(forIteratorRE); + if (iteratorMatch) { + valueContent = valueContent.replace(forIteratorRE, "").trim(); + const keyContent = iteratorMatch[1].trim(); + let keyOffset; + if (keyContent) { + keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length); + result.key = createAliasExpression(keyContent, keyOffset, true); + } + if (iteratorMatch[2]) { + const indexContent = iteratorMatch[2].trim(); + if (indexContent) { + result.index = createAliasExpression( + indexContent, + exp.indexOf( + indexContent, + result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length + ), + true + ); + } + } + } + if (valueContent) { + result.value = createAliasExpression(valueContent, trimmedOffset, true); + } + return result; +} +function getSlice(start, end) { + return currentInput.slice(start, end); +} +function endOpenTag(end) { + if (tokenizer.inSFCRoot) { + currentOpenTag.innerLoc = getLoc(end + 1, end + 1); + } + addNode(currentOpenTag); + const { tag, ns } = currentOpenTag; + if (ns === 0 && currentOptions.isPreTag(tag)) { + inPre++; + } + if (currentOptions.isVoidTag(tag)) { + onCloseTag(currentOpenTag, end); + } else { + stack.unshift(currentOpenTag); + if (ns === 1 || ns === 2) { + tokenizer.inXML = true; + } + } + currentOpenTag = null; +} +function onText(content, start, end) { + const parent = stack[0] || currentRoot; + const lastNode = parent.children[parent.children.length - 1]; + if (lastNode && lastNode.type === 2) { + lastNode.content += content; + setLocEnd(lastNode.loc, end); + } else { + parent.children.push({ + type: 2, + content, + loc: getLoc(start, end) + }); + } +} +function onCloseTag(el, end, isImplied = false) { + if (isImplied) { + setLocEnd(el.loc, backTrack(end, 60)); + } else { + setLocEnd(el.loc, lookAhead(end, 62) + 1); + } + if (tokenizer.inSFCRoot) { + if (el.children.length) { + el.innerLoc.end = shared.extend({}, el.children[el.children.length - 1].loc.end); + } else { + el.innerLoc.end = shared.extend({}, el.innerLoc.start); + } + el.innerLoc.source = getSlice( + el.innerLoc.start.offset, + el.innerLoc.end.offset + ); + } + const { tag, ns, children } = el; + if (!inVPre) { + if (tag === "slot") { + el.tagType = 2; + } else if (isFragmentTemplate(el)) { + el.tagType = 3; + } else if (isComponent(el)) { + el.tagType = 1; + } + } + if (!tokenizer.inRCDATA) { + el.children = condenseWhitespace(children); + } + if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) { + const first = children[0]; + if (first && first.type === 2) { + first.content = first.content.replace(/^\r?\n/, ""); + } + } + if (ns === 0 && currentOptions.isPreTag(tag)) { + inPre--; + } + if (currentVPreBoundary === el) { + inVPre = tokenizer.inVPre = false; + currentVPreBoundary = null; + } + if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) { + tokenizer.inXML = false; + } + { + const props = el.props; + if (isCompatEnabled( + "COMPILER_V_IF_V_FOR_PRECEDENCE", + currentOptions + )) { + let hasIf = false; + let hasFor = false; + for (let i = 0; i < props.length; i++) { + const p = props[i]; + if (p.type === 7) { + if (p.name === "if") { + hasIf = true; + } else if (p.name === "for") { + hasFor = true; + } + } + if (hasIf && hasFor) { + warnDeprecation( + "COMPILER_V_IF_V_FOR_PRECEDENCE", + currentOptions, + el.loc + ); + break; + } + } + } + if (!tokenizer.inSFCRoot && isCompatEnabled( + "COMPILER_NATIVE_TEMPLATE", + currentOptions + ) && el.tag === "template" && !isFragmentTemplate(el)) { + warnDeprecation( + "COMPILER_NATIVE_TEMPLATE", + currentOptions, + el.loc + ); + const parent = stack[0] || currentRoot; + const index = parent.children.indexOf(el); + parent.children.splice(index, 1, ...el.children); + } + const inlineTemplateProp = props.find( + (p) => p.type === 6 && p.name === "inline-template" + ); + if (inlineTemplateProp && checkCompatEnabled( + "COMPILER_INLINE_TEMPLATE", + currentOptions, + inlineTemplateProp.loc + ) && el.children.length) { + inlineTemplateProp.value = { + type: 2, + content: getSlice( + el.children[0].loc.start.offset, + el.children[el.children.length - 1].loc.end.offset + ), + loc: inlineTemplateProp.loc + }; + } + } +} +function lookAhead(index, c) { + let i = index; + while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++; + return i; +} +function backTrack(index, c) { + let i = index; + while (currentInput.charCodeAt(i) !== c && i >= 0) i--; + return i; +} +const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]); +function isFragmentTemplate({ tag, props }) { + if (tag === "template") { + for (let i = 0; i < props.length; i++) { + if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) { + return true; + } + } + } + return false; +} +function isComponent({ tag, props }) { + if (currentOptions.isCustomElement(tag)) { + return false; + } + if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) { + return true; + } + for (let i = 0; i < props.length; i++) { + const p = props[i]; + if (p.type === 6) { + if (p.name === "is" && p.value) { + if (p.value.content.startsWith("vue:")) { + return true; + } else if (checkCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + currentOptions, + p.loc + )) { + return true; + } + } + } else if (// :is on plain element - only treat as component in compat mode + p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + currentOptions, + p.loc + )) { + return true; + } + } + return false; +} +function isUpperCase(c) { + return c > 64 && c < 91; +} +const windowsNewlineRE = /\r\n/g; +function condenseWhitespace(nodes) { + const shouldCondense = currentOptions.whitespace !== "preserve"; + let removedWhitespace = false; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (node.type === 2) { + if (!inPre) { + if (isAllWhitespace(node.content)) { + const prev = nodes[i - 1] && nodes[i - 1].type; + const next = nodes[i + 1] && nodes[i + 1].type; + if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) { + removedWhitespace = true; + nodes[i] = null; + } else { + node.content = " "; + } + } else if (shouldCondense) { + node.content = condense(node.content); + } + } else { + node.content = node.content.replace(windowsNewlineRE, "\n"); + } + } + } + return removedWhitespace ? nodes.filter(Boolean) : nodes; +} +function hasNewlineChar(str) { + for (let i = 0; i < str.length; i++) { + const c = str.charCodeAt(i); + if (c === 10 || c === 13) { + return true; + } + } + return false; +} +function condense(str) { + let ret = ""; + let prevCharIsWhitespace = false; + for (let i = 0; i < str.length; i++) { + if (isWhitespace(str.charCodeAt(i))) { + if (!prevCharIsWhitespace) { + ret += " "; + prevCharIsWhitespace = true; + } + } else { + ret += str[i]; + prevCharIsWhitespace = false; + } + } + return ret; +} +function addNode(node) { + (stack[0] || currentRoot).children.push(node); +} +function getLoc(start, end) { + return { + start: tokenizer.getPos(start), + // @ts-expect-error allow late attachment + end: end == null ? end : tokenizer.getPos(end), + // @ts-expect-error allow late attachment + source: end == null ? end : getSlice(start, end) + }; +} +function cloneLoc(loc) { + return getLoc(loc.start.offset, loc.end.offset); +} +function setLocEnd(loc, end) { + loc.end = tokenizer.getPos(end); + loc.source = getSlice(loc.start.offset, end); +} +function dirToAttr(dir) { + const attr = { + type: 6, + name: dir.rawName, + nameLoc: getLoc( + dir.loc.start.offset, + dir.loc.start.offset + dir.rawName.length + ), + value: void 0, + loc: dir.loc + }; + if (dir.exp) { + const loc = dir.exp.loc; + if (loc.end.offset < dir.loc.end.offset) { + loc.start.offset--; + loc.start.column--; + loc.end.offset++; + loc.end.column++; + } + attr.value = { + type: 2, + content: dir.exp.content, + loc + }; + } + return attr; +} +function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) { + const exp = createSimpleExpression(content, isStatic, loc, constType); + if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 /* Skip */ && content.trim()) { + if (isSimpleIdentifier(content)) { + exp.ast = null; + return exp; + } + try { + const plugins = currentOptions.expressionPlugins; + const options = { + plugins: plugins ? [...plugins, "typescript"] : ["typescript"] + }; + if (parseMode === 2 /* Statements */) { + exp.ast = parser.parse(` ${content} `, options).program; + } else if (parseMode === 1 /* Params */) { + exp.ast = parser.parseExpression(`(${content})=>{}`, options); + } else { + exp.ast = parser.parseExpression(`(${content})`, options); + } + } catch (e) { + exp.ast = false; + emitError(46, loc.start.offset, e.message); + } + } + return exp; +} +function emitError(code, index, message) { + currentOptions.onError( + createCompilerError(code, getLoc(index, index), void 0, message) + ); +} +function reset() { + tokenizer.reset(); + currentOpenTag = null; + currentProp = null; + currentAttrValue = ""; + currentAttrStartIndex = -1; + currentAttrEndIndex = -1; + stack.length = 0; +} +function baseParse(input, options) { + reset(); + currentInput = input; + currentOptions = shared.extend({}, defaultParserOptions); + if (options) { + let key; + for (key in options) { + if (options[key] != null) { + currentOptions[key] = options[key]; + } + } + } + { + if (currentOptions.decodeEntities) { + console.warn( + `[@vue/compiler-core] decodeEntities option is passed but will be ignored in non-browser builds.` + ); + } + } + tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0; + tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2; + const delimiters = options && options.delimiters; + if (delimiters) { + tokenizer.delimiterOpen = toCharCodes(delimiters[0]); + tokenizer.delimiterClose = toCharCodes(delimiters[1]); + } + const root = currentRoot = createRoot([], input); + tokenizer.parse(currentInput); + root.loc = getLoc(0, input.length); + root.children = condenseWhitespace(root.children); + currentRoot = null; + return root; +} + +function cacheStatic(root, context) { + walk( + root, + void 0, + context, + // Root node is unfortunately non-hoistable due to potential parent + // fallthrough attributes. + !!getSingleElementRoot(root) + ); +} +function getSingleElementRoot(root) { + const children = root.children.filter((x) => x.type !== 3); + return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null; +} +function walk(node, parent, context, doNotHoistNode = false, inFor = false) { + const { children } = node; + const toCache = []; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (child.type === 1 && child.tagType === 0) { + const constantType = doNotHoistNode ? 0 : getConstantType(child, context); + if (constantType > 0) { + if (constantType >= 2) { + child.codegenNode.patchFlag = -1; + toCache.push(child); + continue; + } + } else { + const codegenNode = child.codegenNode; + if (codegenNode.type === 13) { + const flag = codegenNode.patchFlag; + if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) { + const props = getNodeProps(child); + if (props) { + codegenNode.props = context.hoist(props); + } + } + if (codegenNode.dynamicProps) { + codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps); + } + } + } + } else if (child.type === 12) { + const constantType = doNotHoistNode ? 0 : getConstantType(child, context); + if (constantType >= 2) { + if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) { + child.codegenNode.arguments.push( + -1 + (` /* ${shared.PatchFlagNames[-1]} */` ) + ); + } + toCache.push(child); + continue; + } + } + if (child.type === 1) { + const isComponent = child.tagType === 1; + if (isComponent) { + context.scopes.vSlot++; + } + walk(child, node, context, false, inFor); + if (isComponent) { + context.scopes.vSlot--; + } + } else if (child.type === 11) { + walk(child, node, context, child.children.length === 1, true); + } else if (child.type === 9) { + for (let i2 = 0; i2 < child.branches.length; i2++) { + walk( + child.branches[i2], + node, + context, + child.branches[i2].children.length === 1, + inFor + ); + } + } + } + let cachedAsArray = false; + if (toCache.length === children.length && node.type === 1) { + if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) { + node.codegenNode.children = getCacheExpression( + createArrayExpression(node.codegenNode.children) + ); + cachedAsArray = true; + } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared.isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) { + const slot = getSlotNode(node.codegenNode, "default"); + if (slot) { + slot.returns = getCacheExpression( + createArrayExpression(slot.returns) + ); + cachedAsArray = true; + } + } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) { + const slotName = findDir(node, "slot", true); + const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg); + if (slot) { + slot.returns = getCacheExpression( + createArrayExpression(slot.returns) + ); + cachedAsArray = true; + } + } + } + if (!cachedAsArray) { + for (const child of toCache) { + child.codegenNode = context.cache(child.codegenNode); + } + } + function getCacheExpression(value) { + const exp = context.cache(value); + exp.needArraySpread = true; + return exp; + } + function getSlotNode(node2, name) { + if (node2.children && !shared.isArray(node2.children) && node2.children.type === 15) { + const slot = node2.children.properties.find( + (p) => p.key === name || p.key.content === name + ); + return slot && slot.value; + } + } + if (toCache.length && context.transformHoist) { + context.transformHoist(children, context, node); + } +} +function getConstantType(node, context) { + const { constantCache } = context; + switch (node.type) { + case 1: + if (node.tagType !== 0) { + return 0; + } + const cached = constantCache.get(node); + if (cached !== void 0) { + return cached; + } + const codegenNode = node.codegenNode; + if (codegenNode.type !== 13) { + return 0; + } + if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") { + return 0; + } + if (codegenNode.patchFlag === void 0) { + let returnType2 = 3; + const generatedPropsType = getGeneratedPropsConstantType(node, context); + if (generatedPropsType === 0) { + constantCache.set(node, 0); + return 0; + } + if (generatedPropsType < returnType2) { + returnType2 = generatedPropsType; + } + for (let i = 0; i < node.children.length; i++) { + const childType = getConstantType(node.children[i], context); + if (childType === 0) { + constantCache.set(node, 0); + return 0; + } + if (childType < returnType2) { + returnType2 = childType; + } + } + if (returnType2 > 1) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7 && p.name === "bind" && p.exp) { + const expType = getConstantType(p.exp, context); + if (expType === 0) { + constantCache.set(node, 0); + return 0; + } + if (expType < returnType2) { + returnType2 = expType; + } + } + } + } + if (codegenNode.isBlock) { + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 7) { + constantCache.set(node, 0); + return 0; + } + } + context.removeHelper(OPEN_BLOCK); + context.removeHelper( + getVNodeBlockHelper(context.inSSR, codegenNode.isComponent) + ); + codegenNode.isBlock = false; + context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent)); + } + constantCache.set(node, returnType2); + return returnType2; + } else { + constantCache.set(node, 0); + return 0; + } + case 2: + case 3: + return 3; + case 9: + case 11: + case 10: + return 0; + case 5: + case 12: + return getConstantType(node.content, context); + case 4: + return node.constType; + case 8: + let returnType = 3; + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (shared.isString(child) || shared.isSymbol(child)) { + continue; + } + const childType = getConstantType(child, context); + if (childType === 0) { + return 0; + } else if (childType < returnType) { + returnType = childType; + } + } + return returnType; + case 20: + return 2; + default: + return 0; + } +} +const allowHoistedHelperSet = /* @__PURE__ */ new Set([ + NORMALIZE_CLASS, + NORMALIZE_STYLE, + NORMALIZE_PROPS, + GUARD_REACTIVE_PROPS +]); +function getConstantTypeOfHelperCall(value, context) { + if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) { + const arg = value.arguments[0]; + if (arg.type === 4) { + return getConstantType(arg, context); + } else if (arg.type === 14) { + return getConstantTypeOfHelperCall(arg, context); + } + } + return 0; +} +function getGeneratedPropsConstantType(node, context) { + let returnType = 3; + const props = getNodeProps(node); + if (props && props.type === 15) { + const { properties } = props; + for (let i = 0; i < properties.length; i++) { + const { key, value } = properties[i]; + const keyType = getConstantType(key, context); + if (keyType === 0) { + return keyType; + } + if (keyType < returnType) { + returnType = keyType; + } + let valueType; + if (value.type === 4) { + valueType = getConstantType(value, context); + } else if (value.type === 14) { + valueType = getConstantTypeOfHelperCall(value, context); + } else { + valueType = 0; + } + if (valueType === 0) { + return valueType; + } + if (valueType < returnType) { + returnType = valueType; + } + } + } + return returnType; +} +function getNodeProps(node) { + const codegenNode = node.codegenNode; + if (codegenNode.type === 13) { + return codegenNode.props; + } +} + +function createTransformContext(root, { + filename = "", + prefixIdentifiers = false, + hoistStatic = false, + hmr = false, + cacheHandlers = false, + nodeTransforms = [], + directiveTransforms = {}, + transformHoist = null, + isBuiltInComponent = shared.NOOP, + isCustomElement = shared.NOOP, + expressionPlugins = [], + scopeId = null, + slotted = true, + ssr = false, + inSSR = false, + ssrCssVars = ``, + bindingMetadata = shared.EMPTY_OBJ, + inline = false, + isTS = false, + onError = defaultOnError, + onWarn = defaultOnWarn, + compatConfig +}) { + const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/); + const context = { + // options + filename, + selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])), + prefixIdentifiers, + hoistStatic, + hmr, + cacheHandlers, + nodeTransforms, + directiveTransforms, + transformHoist, + isBuiltInComponent, + isCustomElement, + expressionPlugins, + scopeId, + slotted, + ssr, + inSSR, + ssrCssVars, + bindingMetadata, + inline, + isTS, + onError, + onWarn, + compatConfig, + // state + root, + helpers: /* @__PURE__ */ new Map(), + components: /* @__PURE__ */ new Set(), + directives: /* @__PURE__ */ new Set(), + hoists: [], + imports: [], + cached: [], + constantCache: /* @__PURE__ */ new WeakMap(), + temps: 0, + identifiers: /* @__PURE__ */ Object.create(null), + scopes: { + vFor: 0, + vSlot: 0, + vPre: 0, + vOnce: 0 + }, + parent: null, + grandParent: null, + currentNode: root, + childIndex: 0, + inVOnce: false, + // methods + helper(name) { + const count = context.helpers.get(name) || 0; + context.helpers.set(name, count + 1); + return name; + }, + removeHelper(name) { + const count = context.helpers.get(name); + if (count) { + const currentCount = count - 1; + if (!currentCount) { + context.helpers.delete(name); + } else { + context.helpers.set(name, currentCount); + } + } + }, + helperString(name) { + return `_${helperNameMap[context.helper(name)]}`; + }, + replaceNode(node) { + { + if (!context.currentNode) { + throw new Error(`Node being replaced is already removed.`); + } + if (!context.parent) { + throw new Error(`Cannot replace root node.`); + } + } + context.parent.children[context.childIndex] = context.currentNode = node; + }, + removeNode(node) { + if (!context.parent) { + throw new Error(`Cannot remove root node.`); + } + const list = context.parent.children; + const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1; + if (removalIndex < 0) { + throw new Error(`node being removed is not a child of current parent`); + } + if (!node || node === context.currentNode) { + context.currentNode = null; + context.onNodeRemoved(); + } else { + if (context.childIndex > removalIndex) { + context.childIndex--; + context.onNodeRemoved(); + } + } + context.parent.children.splice(removalIndex, 1); + }, + onNodeRemoved: shared.NOOP, + addIdentifiers(exp) { + { + if (shared.isString(exp)) { + addId(exp); + } else if (exp.identifiers) { + exp.identifiers.forEach(addId); + } else if (exp.type === 4) { + addId(exp.content); + } + } + }, + removeIdentifiers(exp) { + { + if (shared.isString(exp)) { + removeId(exp); + } else if (exp.identifiers) { + exp.identifiers.forEach(removeId); + } else if (exp.type === 4) { + removeId(exp.content); + } + } + }, + hoist(exp) { + if (shared.isString(exp)) exp = createSimpleExpression(exp); + context.hoists.push(exp); + const identifier = createSimpleExpression( + `_hoisted_${context.hoists.length}`, + false, + exp.loc, + 2 + ); + identifier.hoisted = exp; + return identifier; + }, + cache(exp, isVNode = false, inVOnce = false) { + const cacheExp = createCacheExpression( + context.cached.length, + exp, + isVNode, + inVOnce + ); + context.cached.push(cacheExp); + return cacheExp; + } + }; + { + context.filters = /* @__PURE__ */ new Set(); + } + function addId(id) { + const { identifiers } = context; + if (identifiers[id] === void 0) { + identifiers[id] = 0; + } + identifiers[id]++; + } + function removeId(id) { + context.identifiers[id]--; + } + return context; +} +function transform(root, options) { + const context = createTransformContext(root, options); + traverseNode(root, context); + if (options.hoistStatic) { + cacheStatic(root, context); + } + if (!options.ssr) { + createRootCodegen(root, context); + } + root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]); + root.components = [...context.components]; + root.directives = [...context.directives]; + root.imports = context.imports; + root.hoists = context.hoists; + root.temps = context.temps; + root.cached = context.cached; + root.transformed = true; + { + root.filters = [...context.filters]; + } +} +function createRootCodegen(root, context) { + const { helper } = context; + const { children } = root; + if (children.length === 1) { + const singleElementRootChild = getSingleElementRoot(root); + if (singleElementRootChild && singleElementRootChild.codegenNode) { + const codegenNode = singleElementRootChild.codegenNode; + if (codegenNode.type === 13) { + convertToBlock(codegenNode, context); + } + root.codegenNode = codegenNode; + } else { + root.codegenNode = children[0]; + } + } else if (children.length > 1) { + let patchFlag = 64; + if (children.filter((c) => c.type !== 3).length === 1) { + patchFlag |= 2048; + } + root.codegenNode = createVNodeCall( + context, + helper(FRAGMENT), + void 0, + root.children, + patchFlag, + void 0, + void 0, + true, + void 0, + false + ); + } else ; +} +function traverseChildren(parent, context) { + let i = 0; + const nodeRemoved = () => { + i--; + }; + for (; i < parent.children.length; i++) { + const child = parent.children[i]; + if (shared.isString(child)) continue; + context.grandParent = context.parent; + context.parent = parent; + context.childIndex = i; + context.onNodeRemoved = nodeRemoved; + traverseNode(child, context); + } +} +function traverseNode(node, context) { + context.currentNode = node; + const { nodeTransforms } = context; + const exitFns = []; + for (let i2 = 0; i2 < nodeTransforms.length; i2++) { + const onExit = nodeTransforms[i2](node, context); + if (onExit) { + if (shared.isArray(onExit)) { + exitFns.push(...onExit); + } else { + exitFns.push(onExit); + } + } + if (!context.currentNode) { + return; + } else { + node = context.currentNode; + } + } + switch (node.type) { + case 3: + if (!context.ssr) { + context.helper(CREATE_COMMENT); + } + break; + case 5: + if (!context.ssr) { + context.helper(TO_DISPLAY_STRING); + } + break; + // for container types, further traverse downwards + case 9: + for (let i2 = 0; i2 < node.branches.length; i2++) { + traverseNode(node.branches[i2], context); + } + break; + case 10: + case 11: + case 1: + case 0: + traverseChildren(node, context); + break; + } + context.currentNode = node; + let i = exitFns.length; + while (i--) { + exitFns[i](); + } +} +function createStructuralDirectiveTransform(name, fn) { + const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n); + return (node, context) => { + if (node.type === 1) { + const { props } = node; + if (node.tagType === 3 && props.some(isVSlot)) { + return; + } + const exitFns = []; + for (let i = 0; i < props.length; i++) { + const prop = props[i]; + if (prop.type === 7 && matches(prop.name)) { + props.splice(i, 1); + i--; + const onExit = fn(node, prop, context); + if (onExit) exitFns.push(onExit); + } + } + return exitFns; + } + }; +} + +const PURE_ANNOTATION = `/*@__PURE__*/`; +const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`; +function createCodegenContext(ast, { + mode = "function", + prefixIdentifiers = mode === "module", + sourceMap = false, + filename = `template.vue.html`, + scopeId = null, + optimizeImports = false, + runtimeGlobalName = `Vue`, + runtimeModuleName = `vue`, + ssrRuntimeModuleName = "vue/server-renderer", + ssr = false, + isTS = false, + inSSR = false +}) { + const context = { + mode, + prefixIdentifiers, + sourceMap, + filename, + scopeId, + optimizeImports, + runtimeGlobalName, + runtimeModuleName, + ssrRuntimeModuleName, + ssr, + isTS, + inSSR, + source: ast.source, + code: ``, + column: 1, + line: 1, + offset: 0, + indentLevel: 0, + pure: false, + map: void 0, + helper(key) { + return `_${helperNameMap[key]}`; + }, + push(code, newlineIndex = -2 /* None */, node) { + context.code += code; + if (context.map) { + if (node) { + let name; + if (node.type === 4 && !node.isStatic) { + const content = node.content.replace(/^_ctx\./, ""); + if (content !== node.content && isSimpleIdentifier(content)) { + name = content; + } + } + if (node.loc.source) { + addMapping(node.loc.start, name); + } + } + if (newlineIndex === -3 /* Unknown */) { + advancePositionWithMutation(context, code); + } else { + context.offset += code.length; + if (newlineIndex === -2 /* None */) { + context.column += code.length; + } else { + if (newlineIndex === -1 /* End */) { + newlineIndex = code.length - 1; + } + context.line++; + context.column = code.length - newlineIndex; + } + } + if (node && node.loc !== locStub && node.loc.source) { + addMapping(node.loc.end); + } + } + }, + indent() { + newline(++context.indentLevel); + }, + deindent(withoutNewLine = false) { + if (withoutNewLine) { + --context.indentLevel; + } else { + newline(--context.indentLevel); + } + }, + newline() { + newline(context.indentLevel); + } + }; + function newline(n) { + context.push("\n" + ` `.repeat(n), 0 /* Start */); + } + function addMapping(loc, name = null) { + const { _names, _mappings } = context.map; + if (name !== null && !_names.has(name)) _names.add(name); + _mappings.add({ + originalLine: loc.line, + originalColumn: loc.column - 1, + // source-map column is 0 based + generatedLine: context.line, + generatedColumn: context.column - 1, + source: filename, + name + }); + } + if (sourceMap) { + context.map = new sourceMapJs.SourceMapGenerator(); + context.map.setSourceContent(filename, context.source); + context.map._sources.add(filename); + } + return context; +} +function generate(ast, options = {}) { + const context = createCodegenContext(ast, options); + if (options.onContextCreated) options.onContextCreated(context); + const { + mode, + push, + prefixIdentifiers, + indent, + deindent, + newline, + scopeId, + ssr + } = context; + const helpers = Array.from(ast.helpers); + const hasHelpers = helpers.length > 0; + const useWithBlock = !prefixIdentifiers && mode !== "module"; + const genScopeId = scopeId != null && mode === "module"; + const isSetupInlined = !!options.inline; + const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context; + if (mode === "module") { + genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined); + } else { + genFunctionPreamble(ast, preambleContext); + } + const functionName = ssr ? `ssrRender` : `render`; + const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"]; + if (options.bindingMetadata && !options.inline) { + args.push("$props", "$setup", "$data", "$options"); + } + const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", "); + if (isSetupInlined) { + push(`(${signature}) => {`); + } else { + push(`function ${functionName}(${signature}) {`); + } + indent(); + if (useWithBlock) { + push(`with (_ctx) {`); + indent(); + if (hasHelpers) { + push( + `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue +`, + -1 /* End */ + ); + newline(); + } + } + if (ast.components.length) { + genAssets(ast.components, "component", context); + if (ast.directives.length || ast.temps > 0) { + newline(); + } + } + if (ast.directives.length) { + genAssets(ast.directives, "directive", context); + if (ast.temps > 0) { + newline(); + } + } + if (ast.filters && ast.filters.length) { + newline(); + genAssets(ast.filters, "filter", context); + newline(); + } + if (ast.temps > 0) { + push(`let `); + for (let i = 0; i < ast.temps; i++) { + push(`${i > 0 ? `, ` : ``}_temp${i}`); + } + } + if (ast.components.length || ast.directives.length || ast.temps) { + push(` +`, 0 /* Start */); + newline(); + } + if (!ssr) { + push(`return `); + } + if (ast.codegenNode) { + genNode(ast.codegenNode, context); + } else { + push(`null`); + } + if (useWithBlock) { + deindent(); + push(`}`); + } + deindent(); + push(`}`); + return { + ast, + code: context.code, + preamble: isSetupInlined ? preambleContext.code : ``, + map: context.map ? context.map.toJSON() : void 0 + }; +} +function genFunctionPreamble(ast, context) { + const { + ssr, + prefixIdentifiers, + push, + newline, + runtimeModuleName, + runtimeGlobalName, + ssrRuntimeModuleName + } = context; + const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName; + const helpers = Array.from(ast.helpers); + if (helpers.length > 0) { + if (prefixIdentifiers) { + push( + `const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding} +`, + -1 /* End */ + ); + } else { + push(`const _Vue = ${VueBinding} +`, -1 /* End */); + if (ast.hoists.length) { + const staticHelpers = [ + CREATE_VNODE, + CREATE_ELEMENT_VNODE, + CREATE_COMMENT, + CREATE_TEXT, + CREATE_STATIC + ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", "); + push(`const { ${staticHelpers} } = _Vue +`, -1 /* End */); + } + } + } + if (ast.ssrHelpers && ast.ssrHelpers.length) { + push( + `const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}") +`, + -1 /* End */ + ); + } + genHoists(ast.hoists, context); + newline(); + push(`return `); +} +function genModulePreamble(ast, context, genScopeId, inline) { + const { + push, + newline, + optimizeImports, + runtimeModuleName, + ssrRuntimeModuleName + } = context; + if (ast.helpers.size) { + const helpers = Array.from(ast.helpers); + if (optimizeImports) { + push( + `import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)} +`, + -1 /* End */ + ); + push( + ` +// Binding optimization for webpack code-split +const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")} +`, + -1 /* End */ + ); + } else { + push( + `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)} +`, + -1 /* End */ + ); + } + } + if (ast.ssrHelpers && ast.ssrHelpers.length) { + push( + `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}" +`, + -1 /* End */ + ); + } + if (ast.imports.length) { + genImports(ast.imports, context); + newline(); + } + genHoists(ast.hoists, context); + newline(); + if (!inline) { + push(`export `); + } +} +function genAssets(assets, type, { helper, push, newline, isTS }) { + const resolver = helper( + type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE + ); + for (let i = 0; i < assets.length; i++) { + let id = assets[i]; + const maybeSelfReference = id.endsWith("__self"); + if (maybeSelfReference) { + id = id.slice(0, -6); + } + push( + `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}` + ); + if (i < assets.length - 1) { + newline(); + } + } +} +function genHoists(hoists, context) { + if (!hoists.length) { + return; + } + context.pure = true; + const { push, newline } = context; + newline(); + for (let i = 0; i < hoists.length; i++) { + const exp = hoists[i]; + if (exp) { + push(`const _hoisted_${i + 1} = `); + genNode(exp, context); + newline(); + } + } + context.pure = false; +} +function genImports(importsOptions, context) { + if (!importsOptions.length) { + return; + } + importsOptions.forEach((imports) => { + context.push(`import `); + genNode(imports.exp, context); + context.push(` from '${imports.path}'`); + context.newline(); + }); +} +function isText(n) { + return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8; +} +function genNodeListAsArray(nodes, context) { + const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n)); + context.push(`[`); + multilines && context.indent(); + genNodeList(nodes, context, multilines); + multilines && context.deindent(); + context.push(`]`); +} +function genNodeList(nodes, context, multilines = false, comma = true) { + const { push, newline } = context; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + if (shared.isString(node)) { + push(node, -3 /* Unknown */); + } else if (shared.isArray(node)) { + genNodeListAsArray(node, context); + } else { + genNode(node, context); + } + if (i < nodes.length - 1) { + if (multilines) { + comma && push(","); + newline(); + } else { + comma && push(", "); + } + } + } +} +function genNode(node, context) { + if (shared.isString(node)) { + context.push(node, -3 /* Unknown */); + return; + } + if (shared.isSymbol(node)) { + context.push(context.helper(node)); + return; + } + switch (node.type) { + case 1: + case 9: + case 11: + assert( + node.codegenNode != null, + `Codegen node is missing for element/if/for node. Apply appropriate transforms first.` + ); + genNode(node.codegenNode, context); + break; + case 2: + genText(node, context); + break; + case 4: + genExpression(node, context); + break; + case 5: + genInterpolation(node, context); + break; + case 12: + genNode(node.codegenNode, context); + break; + case 8: + genCompoundExpression(node, context); + break; + case 3: + genComment(node, context); + break; + case 13: + genVNodeCall(node, context); + break; + case 14: + genCallExpression(node, context); + break; + case 15: + genObjectExpression(node, context); + break; + case 17: + genArrayExpression(node, context); + break; + case 18: + genFunctionExpression(node, context); + break; + case 19: + genConditionalExpression(node, context); + break; + case 20: + genCacheExpression(node, context); + break; + case 21: + genNodeList(node.body, context, true, false); + break; + // SSR only types + case 22: + genTemplateLiteral(node, context); + break; + case 23: + genIfStatement(node, context); + break; + case 24: + genAssignmentExpression(node, context); + break; + case 25: + genSequenceExpression(node, context); + break; + case 26: + genReturnStatement(node, context); + break; + /* v8 ignore start */ + case 10: + break; + default: + { + assert(false, `unhandled codegen node type: ${node.type}`); + const exhaustiveCheck = node; + return exhaustiveCheck; + } + } +} +function genText(node, context) { + context.push(JSON.stringify(node.content), -3 /* Unknown */, node); +} +function genExpression(node, context) { + const { content, isStatic } = node; + context.push( + isStatic ? JSON.stringify(content) : content, + -3 /* Unknown */, + node + ); +} +function genInterpolation(node, context) { + const { push, helper, pure } = context; + if (pure) push(PURE_ANNOTATION); + push(`${helper(TO_DISPLAY_STRING)}(`); + genNode(node.content, context); + push(`)`); +} +function genCompoundExpression(node, context) { + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (shared.isString(child)) { + context.push(child, -3 /* Unknown */); + } else { + genNode(child, context); + } + } +} +function genExpressionAsPropertyKey(node, context) { + const { push } = context; + if (node.type === 8) { + push(`[`); + genCompoundExpression(node, context); + push(`]`); + } else if (node.isStatic) { + const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content); + push(text, -2 /* None */, node); + } else { + push(`[${node.content}]`, -3 /* Unknown */, node); + } +} +function genComment(node, context) { + const { push, helper, pure } = context; + if (pure) { + push(PURE_ANNOTATION); + } + push( + `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, + -3 /* Unknown */, + node + ); +} +function genVNodeCall(node, context) { + const { push, helper, pure } = context; + const { + tag, + props, + children, + patchFlag, + dynamicProps, + directives, + isBlock, + disableTracking, + isComponent + } = node; + let patchFlagString; + if (patchFlag) { + { + if (patchFlag < 0) { + patchFlagString = patchFlag + ` /* ${shared.PatchFlagNames[patchFlag]} */`; + } else { + const flagNames = Object.keys(shared.PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => shared.PatchFlagNames[n]).join(`, `); + patchFlagString = patchFlag + ` /* ${flagNames} */`; + } + } + } + if (directives) { + push(helper(WITH_DIRECTIVES) + `(`); + } + if (isBlock) { + push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `); + } + if (pure) { + push(PURE_ANNOTATION); + } + const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent); + push(helper(callHelper) + `(`, -2 /* None */, node); + genNodeList( + genNullableArgs([tag, props, children, patchFlagString, dynamicProps]), + context + ); + push(`)`); + if (isBlock) { + push(`)`); + } + if (directives) { + push(`, `); + genNode(directives, context); + push(`)`); + } +} +function genNullableArgs(args) { + let i = args.length; + while (i--) { + if (args[i] != null) break; + } + return args.slice(0, i + 1).map((arg) => arg || `null`); +} +function genCallExpression(node, context) { + const { push, helper, pure } = context; + const callee = shared.isString(node.callee) ? node.callee : helper(node.callee); + if (pure) { + push(PURE_ANNOTATION); + } + push(callee + `(`, -2 /* None */, node); + genNodeList(node.arguments, context); + push(`)`); +} +function genObjectExpression(node, context) { + const { push, indent, deindent, newline } = context; + const { properties } = node; + if (!properties.length) { + push(`{}`, -2 /* None */, node); + return; + } + const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4); + push(multilines ? `{` : `{ `); + multilines && indent(); + for (let i = 0; i < properties.length; i++) { + const { key, value } = properties[i]; + genExpressionAsPropertyKey(key, context); + push(`: `); + genNode(value, context); + if (i < properties.length - 1) { + push(`,`); + newline(); + } + } + multilines && deindent(); + push(multilines ? `}` : ` }`); +} +function genArrayExpression(node, context) { + genNodeListAsArray(node.elements, context); +} +function genFunctionExpression(node, context) { + const { push, indent, deindent } = context; + const { params, returns, body, newline, isSlot } = node; + if (isSlot) { + push(`_${helperNameMap[WITH_CTX]}(`); + } + push(`(`, -2 /* None */, node); + if (shared.isArray(params)) { + genNodeList(params, context); + } else if (params) { + genNode(params, context); + } + push(`) => `); + if (newline || body) { + push(`{`); + indent(); + } + if (returns) { + if (newline) { + push(`return `); + } + if (shared.isArray(returns)) { + genNodeListAsArray(returns, context); + } else { + genNode(returns, context); + } + } else if (body) { + genNode(body, context); + } + if (newline || body) { + deindent(); + push(`}`); + } + if (isSlot) { + if (node.isNonScopedSlot) { + push(`, undefined, true`); + } + push(`)`); + } +} +function genConditionalExpression(node, context) { + const { test, consequent, alternate, newline: needNewline } = node; + const { push, indent, deindent, newline } = context; + if (test.type === 4) { + const needsParens = !isSimpleIdentifier(test.content); + needsParens && push(`(`); + genExpression(test, context); + needsParens && push(`)`); + } else { + push(`(`); + genNode(test, context); + push(`)`); + } + needNewline && indent(); + context.indentLevel++; + needNewline || push(` `); + push(`? `); + genNode(consequent, context); + context.indentLevel--; + needNewline && newline(); + needNewline || push(` `); + push(`: `); + const isNested = alternate.type === 19; + if (!isNested) { + context.indentLevel++; + } + genNode(alternate, context); + if (!isNested) { + context.indentLevel--; + } + needNewline && deindent( + true + /* without newline */ + ); +} +function genCacheExpression(node, context) { + const { push, helper, indent, deindent, newline } = context; + const { needPauseTracking, needArraySpread } = node; + if (needArraySpread) { + push(`[...(`); + } + push(`_cache[${node.index}] || (`); + if (needPauseTracking) { + indent(); + push(`${helper(SET_BLOCK_TRACKING)}(-1`); + if (node.inVOnce) push(`, true`); + push(`),`); + newline(); + push(`(`); + } + push(`_cache[${node.index}] = `); + genNode(node.value, context); + if (needPauseTracking) { + push(`).cacheIndex = ${node.index},`); + newline(); + push(`${helper(SET_BLOCK_TRACKING)}(1),`); + newline(); + push(`_cache[${node.index}]`); + deindent(); + } + push(`)`); + if (needArraySpread) { + push(`)]`); + } +} +function genTemplateLiteral(node, context) { + const { push, indent, deindent } = context; + push("`"); + const l = node.elements.length; + const multilines = l > 3; + for (let i = 0; i < l; i++) { + const e = node.elements[i]; + if (shared.isString(e)) { + push(e.replace(/(`|\$|\\)/g, "\\$1"), -3 /* Unknown */); + } else { + push("${"); + if (multilines) indent(); + genNode(e, context); + if (multilines) deindent(); + push("}"); + } + } + push("`"); +} +function genIfStatement(node, context) { + const { push, indent, deindent } = context; + const { test, consequent, alternate } = node; + push(`if (`); + genNode(test, context); + push(`) {`); + indent(); + genNode(consequent, context); + deindent(); + push(`}`); + if (alternate) { + push(` else `); + if (alternate.type === 23) { + genIfStatement(alternate, context); + } else { + push(`{`); + indent(); + genNode(alternate, context); + deindent(); + push(`}`); + } + } +} +function genAssignmentExpression(node, context) { + genNode(node.left, context); + context.push(` = `); + genNode(node.right, context); +} +function genSequenceExpression(node, context) { + context.push(`(`); + genNodeList(node.expressions, context); + context.push(`)`); +} +function genReturnStatement({ returns }, context) { + context.push(`return `); + if (shared.isArray(returns)) { + genNodeListAsArray(returns, context); + } else { + genNode(returns, context); + } +} + +const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this"); +const transformExpression = (node, context) => { + if (node.type === 5) { + node.content = processExpression( + node.content, + context + ); + } else if (node.type === 1) { + const memo = findDir(node, "memo"); + for (let i = 0; i < node.props.length; i++) { + const dir = node.props[i]; + if (dir.type === 7 && dir.name !== "for") { + const exp = dir.exp; + const arg = dir.arg; + if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key has been processed in transformFor(vMemo + vFor) + !(memo && arg && arg.type === 4 && arg.content === "key")) { + dir.exp = processExpression( + exp, + context, + // slot args must be processed as function params + dir.name === "slot" + ); + } + if (arg && arg.type === 4 && !arg.isStatic) { + dir.arg = processExpression(arg, context); + } + } + } + } +}; +function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) { + if (!context.prefixIdentifiers || !node.content.trim()) { + return node; + } + const { inline, bindingMetadata } = context; + const rewriteIdentifier = (raw, parent, id) => { + const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw]; + if (inline) { + const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id; + const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id; + const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack); + const isNewExpression = parent && isInNewExpression(parentStack); + const wrapWithUnref = (raw2) => { + const wrapped = `${context.helperString(UNREF)}(${raw2})`; + return isNewExpression ? `(${wrapped})` : wrapped; + }; + if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) { + return raw; + } else if (type === "setup-ref") { + return `${raw}.value`; + } else if (type === "setup-maybe-ref") { + return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw); + } else if (type === "setup-let") { + if (isAssignmentLVal) { + const { right: rVal, operator } = parent; + const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1); + const rExpString = stringifyExpression( + processExpression( + createSimpleExpression(rExp, false), + context, + false, + false, + knownIds + ) + ); + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore +` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`; + } else if (isUpdateArg) { + id.start = parent.start; + id.end = parent.end; + const { prefix: isPrefix, operator } = parent; + const prefix = isPrefix ? operator : ``; + const postfix = isPrefix ? `` : operator; + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore +` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`; + } else if (isDestructureAssignment) { + return raw; + } else { + return wrapWithUnref(raw); + } + } else if (type === "props") { + return shared.genPropsAccessExp(raw); + } else if (type === "props-aliased") { + return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]); + } + } else { + if (type && type.startsWith("setup") || type === "literal-const") { + return `$setup.${raw}`; + } else if (type === "props-aliased") { + return `$props['${bindingMetadata.__propsAliases[raw]}']`; + } else if (type) { + return `$${type}.${raw}`; + } + } + return `_ctx.${raw}`; + }; + const rawExp = node.content; + let ast = node.ast; + if (ast === false) { + return node; + } + if (ast === null || !ast && isSimpleIdentifier(rawExp)) { + const isScopeVarReference = context.identifiers[rawExp]; + const isAllowedGlobal = shared.isGloballyAllowed(rawExp); + const isLiteral = isLiteralWhitelisted(rawExp); + if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) { + if (isConst(bindingMetadata[rawExp])) { + node.constType = 1; + } + node.content = rewriteIdentifier(rawExp); + } else if (!isScopeVarReference) { + if (isLiteral) { + node.constType = 3; + } else { + node.constType = 2; + } + } + return node; + } + if (!ast) { + const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`; + try { + ast = parser.parseExpression(source, { + sourceType: "module", + plugins: context.expressionPlugins + }); + } catch (e) { + context.onError( + createCompilerError( + 46, + node.loc, + void 0, + e.message + ) + ); + return node; + } + } + const ids = []; + const parentStack = []; + const knownIds = Object.create(context.identifiers); + walkIdentifiers( + ast, + (node2, parent, _, isReferenced, isLocal) => { + if (isStaticPropertyKey(node2, parent)) { + return; + } + if (node2.name.startsWith("_filter_")) { + return; + } + const needPrefix = isReferenced && canPrefix(node2); + if (needPrefix && !isLocal) { + if (isStaticProperty(parent) && parent.shorthand) { + node2.prefix = `${node2.name}: `; + } + node2.name = rewriteIdentifier(node2.name, parent, node2); + ids.push(node2); + } else { + if (!(needPrefix && isLocal) && (!parent || parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression")) { + node2.isConstant = true; + } + ids.push(node2); + } + }, + true, + // invoke on ALL identifiers + parentStack, + knownIds + ); + const children = []; + ids.sort((a, b) => a.start - b.start); + ids.forEach((id, i) => { + const start = id.start - 1; + const end = id.end - 1; + const last = ids[i - 1]; + const leadingText = rawExp.slice(last ? last.end - 1 : 0, start); + if (leadingText.length || id.prefix) { + children.push(leadingText + (id.prefix || ``)); + } + const source = rawExp.slice(start, end); + children.push( + createSimpleExpression( + id.name, + false, + { + start: advancePositionWithClone(node.loc.start, source, start), + end: advancePositionWithClone(node.loc.start, source, end), + source + }, + id.isConstant ? 3 : 0 + ) + ); + if (i === ids.length - 1 && end < rawExp.length) { + children.push(rawExp.slice(end)); + } + }); + let ret; + if (children.length) { + ret = createCompoundExpression(children, node.loc); + ret.ast = ast; + } else { + ret = node; + ret.constType = 3; + } + ret.identifiers = Object.keys(knownIds); + return ret; +} +function canPrefix(id) { + if (shared.isGloballyAllowed(id.name)) { + return false; + } + if (id.name === "require") { + return false; + } + return true; +} +function stringifyExpression(exp) { + if (shared.isString(exp)) { + return exp; + } else if (exp.type === 4) { + return exp.content; + } else { + return exp.children.map(stringifyExpression).join(""); + } +} +function isConst(type) { + return type === "setup-const" || type === "literal-const"; +} + +const transformIf = createStructuralDirectiveTransform( + /^(?:if|else|else-if)$/, + (node, dir, context) => { + return processIf(node, dir, context, (ifNode, branch, isRoot) => { + const siblings = context.parent.children; + let i = siblings.indexOf(ifNode); + let key = 0; + while (i-- >= 0) { + const sibling = siblings[i]; + if (sibling && sibling.type === 9) { + key += sibling.branches.length; + } + } + return () => { + if (isRoot) { + ifNode.codegenNode = createCodegenNodeForBranch( + branch, + key, + context + ); + } else { + const parentCondition = getParentCondition(ifNode.codegenNode); + parentCondition.alternate = createCodegenNodeForBranch( + branch, + key + ifNode.branches.length - 1, + context + ); + } + }; + }); + } +); +function processIf(node, dir, context, processCodegen) { + if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) { + const loc = dir.exp ? dir.exp.loc : node.loc; + context.onError( + createCompilerError(28, dir.loc) + ); + dir.exp = createSimpleExpression(`true`, false, loc); + } + if (context.prefixIdentifiers && dir.exp) { + dir.exp = processExpression(dir.exp, context); + } + if (dir.name === "if") { + const branch = createIfBranch(node, dir); + const ifNode = { + type: 9, + loc: cloneLoc(node.loc), + branches: [branch] + }; + context.replaceNode(ifNode); + if (processCodegen) { + return processCodegen(ifNode, branch, true); + } + } else { + const siblings = context.parent.children; + const comments = []; + let i = siblings.indexOf(node); + while (i-- >= -1) { + const sibling = siblings[i]; + if (sibling && isCommentOrWhitespace(sibling)) { + context.removeNode(sibling); + if (sibling.type === 3) { + comments.unshift(sibling); + } + continue; + } + if (sibling && sibling.type === 9) { + if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) { + context.onError( + createCompilerError(30, node.loc) + ); + } + context.removeNode(); + const branch = createIfBranch(node, dir); + if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition> + !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) { + branch.children = [...comments, ...branch.children]; + } + { + const key = branch.userKey; + if (key) { + sibling.branches.forEach(({ userKey }) => { + if (isSameKey(userKey, key)) { + context.onError( + createCompilerError( + 29, + branch.userKey.loc + ) + ); + } + }); + } + } + sibling.branches.push(branch); + const onExit = processCodegen && processCodegen(sibling, branch, false); + traverseNode(branch, context); + if (onExit) onExit(); + context.currentNode = null; + } else { + context.onError( + createCompilerError(30, node.loc) + ); + } + break; + } + } +} +function createIfBranch(node, dir) { + const isTemplateIf = node.tagType === 3; + return { + type: 10, + loc: node.loc, + condition: dir.name === "else" ? void 0 : dir.exp, + children: isTemplateIf && !findDir(node, "for") ? node.children : [node], + userKey: findProp(node, `key`), + isTemplateIf + }; +} +function createCodegenNodeForBranch(branch, keyIndex, context) { + if (branch.condition) { + return createConditionalExpression( + branch.condition, + createChildrenCodegenNode(branch, keyIndex, context), + // make sure to pass in asBlock: true so that the comment node call + // closes the current block. + createCallExpression(context.helper(CREATE_COMMENT), [ + '"v-if"' , + "true" + ]) + ); + } else { + return createChildrenCodegenNode(branch, keyIndex, context); + } +} +function createChildrenCodegenNode(branch, keyIndex, context) { + const { helper } = context; + const keyProperty = createObjectProperty( + `key`, + createSimpleExpression( + `${keyIndex}`, + false, + locStub, + 2 + ) + ); + const { children } = branch; + const firstChild = children[0]; + const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1; + if (needFragmentWrapper) { + if (children.length === 1 && firstChild.type === 11) { + const vnodeCall = firstChild.codegenNode; + injectProp(vnodeCall, keyProperty, context); + return vnodeCall; + } else { + let patchFlag = 64; + if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) { + patchFlag |= 2048; + } + return createVNodeCall( + context, + helper(FRAGMENT), + createObjectExpression([keyProperty]), + children, + patchFlag, + void 0, + void 0, + true, + false, + false, + branch.loc + ); + } + } else { + const ret = firstChild.codegenNode; + const vnodeCall = getMemoedVNodeCall(ret); + if (vnodeCall.type === 13) { + convertToBlock(vnodeCall, context); + } + injectProp(vnodeCall, keyProperty, context); + return ret; + } +} +function isSameKey(a, b) { + if (!a || a.type !== b.type) { + return false; + } + if (a.type === 6) { + if (a.value.content !== b.value.content) { + return false; + } + } else { + const exp = a.exp; + const branchExp = b.exp; + if (exp.type !== branchExp.type) { + return false; + } + if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) { + return false; + } + } + return true; +} +function getParentCondition(node) { + while (true) { + if (node.type === 19) { + if (node.alternate.type === 19) { + node = node.alternate; + } else { + return node; + } + } else if (node.type === 20) { + node = node.value; + } + } +} + +const transformFor = createStructuralDirectiveTransform( + "for", + (node, dir, context) => { + const { helper, removeHelper } = context; + return processFor(node, dir, context, (forNode) => { + const renderExp = createCallExpression(helper(RENDER_LIST), [ + forNode.source + ]); + const isTemplate = isTemplateNode(node); + const memo = findDir(node, "memo"); + const keyProp = findProp(node, `key`, false, true); + const isDirKey = keyProp && keyProp.type === 7; + let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp); + if (memo && keyExp && isDirKey) { + { + keyProp.exp = keyExp = processExpression( + keyExp, + context + ); + } + } + const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null; + if (isTemplate) { + if (memo) { + memo.exp = processExpression( + memo.exp, + context + ); + } + if (keyProperty && keyProp.type !== 6) { + keyProperty.value = processExpression( + keyProperty.value, + context + ); + } + } + const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0; + const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256; + forNode.codegenNode = createVNodeCall( + context, + helper(FRAGMENT), + void 0, + renderExp, + fragmentFlag, + void 0, + void 0, + true, + !isStableFragment, + false, + node.loc + ); + return () => { + let childBlock; + const { children } = forNode; + if (isTemplate) { + node.children.some((c) => { + if (c.type === 1) { + const key = findProp(c, "key"); + if (key) { + context.onError( + createCompilerError( + 33, + key.loc + ) + ); + return true; + } + } + }); + } + const needFragmentWrapper = children.length !== 1 || children[0].type !== 1; + const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null; + if (slotOutlet) { + childBlock = slotOutlet.codegenNode; + if (isTemplate && keyProperty) { + injectProp(childBlock, keyProperty, context); + } + } else if (needFragmentWrapper) { + childBlock = createVNodeCall( + context, + helper(FRAGMENT), + keyProperty ? createObjectExpression([keyProperty]) : void 0, + node.children, + 64, + void 0, + void 0, + true, + void 0, + false + ); + } else { + childBlock = children[0].codegenNode; + if (isTemplate && keyProperty) { + injectProp(childBlock, keyProperty, context); + } + if (childBlock.isBlock !== !isStableFragment) { + if (childBlock.isBlock) { + removeHelper(OPEN_BLOCK); + removeHelper( + getVNodeBlockHelper(context.inSSR, childBlock.isComponent) + ); + } else { + removeHelper( + getVNodeHelper(context.inSSR, childBlock.isComponent) + ); + } + } + childBlock.isBlock = !isStableFragment; + if (childBlock.isBlock) { + helper(OPEN_BLOCK); + helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); + } else { + helper(getVNodeHelper(context.inSSR, childBlock.isComponent)); + } + } + if (memo) { + const loop = createFunctionExpression( + createForLoopParams(forNode.parseResult, [ + createSimpleExpression(`_cached`) + ]) + ); + loop.body = createBlockStatement([ + createCompoundExpression([`const _memo = (`, memo.exp, `)`]), + createCompoundExpression([ + `if (_cached`, + ...keyExp ? [` && _cached.key === `, keyExp] : [], + ` && ${context.helperString( + IS_MEMO_SAME + )}(_cached, _memo)) return _cached` + ]), + createCompoundExpression([`const _item = `, childBlock]), + createSimpleExpression(`_item.memo = _memo`), + createSimpleExpression(`return _item`) + ]); + renderExp.arguments.push( + loop, + createSimpleExpression(`_cache`), + createSimpleExpression(String(context.cached.length)) + ); + context.cached.push(null); + } else { + renderExp.arguments.push( + createFunctionExpression( + createForLoopParams(forNode.parseResult), + childBlock, + true + ) + ); + } + }; + }); + } +); +function processFor(node, dir, context, processCodegen) { + if (!dir.exp) { + context.onError( + createCompilerError(31, dir.loc) + ); + return; + } + const parseResult = dir.forParseResult; + if (!parseResult) { + context.onError( + createCompilerError(32, dir.loc) + ); + return; + } + finalizeForParseResult(parseResult, context); + const { addIdentifiers, removeIdentifiers, scopes } = context; + const { source, value, key, index } = parseResult; + const forNode = { + type: 11, + loc: dir.loc, + source, + valueAlias: value, + keyAlias: key, + objectIndexAlias: index, + parseResult, + children: isTemplateNode(node) ? node.children : [node] + }; + context.replaceNode(forNode); + scopes.vFor++; + if (context.prefixIdentifiers) { + value && addIdentifiers(value); + key && addIdentifiers(key); + index && addIdentifiers(index); + } + const onExit = processCodegen && processCodegen(forNode); + return () => { + scopes.vFor--; + if (context.prefixIdentifiers) { + value && removeIdentifiers(value); + key && removeIdentifiers(key); + index && removeIdentifiers(index); + } + if (onExit) onExit(); + }; +} +function finalizeForParseResult(result, context) { + if (result.finalized) return; + if (context.prefixIdentifiers) { + result.source = processExpression( + result.source, + context + ); + if (result.key) { + result.key = processExpression( + result.key, + context, + true + ); + } + if (result.index) { + result.index = processExpression( + result.index, + context, + true + ); + } + if (result.value) { + result.value = processExpression( + result.value, + context, + true + ); + } + } + result.finalized = true; +} +function createForLoopParams({ value, key, index }, memoArgs = []) { + return createParamsList([value, key, index, ...memoArgs]); +} +function createParamsList(args) { + let i = args.length; + while (i--) { + if (args[i]) break; + } + return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false)); +} + +const defaultFallback = createSimpleExpression(`undefined`, false); +const trackSlotScopes = (node, context) => { + if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) { + const vSlot = findDir(node, "slot"); + if (vSlot) { + const slotProps = vSlot.exp; + if (context.prefixIdentifiers) { + slotProps && context.addIdentifiers(slotProps); + } + context.scopes.vSlot++; + return () => { + if (context.prefixIdentifiers) { + slotProps && context.removeIdentifiers(slotProps); + } + context.scopes.vSlot--; + }; + } + } +}; +const trackVForSlotScopes = (node, context) => { + let vFor; + if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) { + const result = vFor.forParseResult; + if (result) { + finalizeForParseResult(result, context); + const { value, key, index } = result; + const { addIdentifiers, removeIdentifiers } = context; + value && addIdentifiers(value); + key && addIdentifiers(key); + index && addIdentifiers(index); + return () => { + value && removeIdentifiers(value); + key && removeIdentifiers(key); + index && removeIdentifiers(index); + }; + } + } +}; +const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression( + props, + children, + false, + true, + children.length ? children[0].loc : loc +); +function buildSlots(node, context, buildSlotFn = buildClientSlotFn) { + context.helper(WITH_CTX); + const { children, loc } = node; + const slotsProperties = []; + const dynamicSlots = []; + let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0; + if (!context.ssr && context.prefixIdentifiers) { + hasDynamicSlots = node.props.some( + (prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers)) + ) || children.some((child) => hasScopeRef(child, context.identifiers)); + } + const onComponentSlot = findDir(node, "slot", true); + if (onComponentSlot) { + const { arg, exp } = onComponentSlot; + if (arg && !isStaticExp(arg)) { + hasDynamicSlots = true; + } + slotsProperties.push( + createObjectProperty( + arg || createSimpleExpression("default", true), + buildSlotFn(exp, void 0, children, loc) + ) + ); + } + let hasTemplateSlots = false; + let hasNamedDefaultSlot = false; + const implicitDefaultChildren = []; + const seenSlotNames = /* @__PURE__ */ new Set(); + let conditionalBranchIndex = 0; + for (let i = 0; i < children.length; i++) { + const slotElement = children[i]; + let slotDir; + if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) { + if (slotElement.type !== 3) { + implicitDefaultChildren.push(slotElement); + } + continue; + } + if (onComponentSlot) { + context.onError( + createCompilerError(37, slotDir.loc) + ); + break; + } + hasTemplateSlots = true; + const { children: slotChildren, loc: slotLoc } = slotElement; + const { + arg: slotName = createSimpleExpression(`default`, true), + exp: slotProps, + loc: dirLoc + } = slotDir; + let staticSlotName; + if (isStaticExp(slotName)) { + staticSlotName = slotName ? slotName.content : `default`; + } else { + hasDynamicSlots = true; + } + const vFor = findDir(slotElement, "for"); + const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc); + let vIf; + let vElse; + if (vIf = findDir(slotElement, "if")) { + hasDynamicSlots = true; + dynamicSlots.push( + createConditionalExpression( + vIf.exp, + buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), + defaultFallback + ) + ); + } else if (vElse = findDir( + slotElement, + /^else(?:-if)?$/, + true + /* allowEmpty */ + )) { + let j = i; + let prev; + while (j--) { + prev = children[j]; + if (!isCommentOrWhitespace(prev)) { + break; + } + } + if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) { + let conditional = dynamicSlots[dynamicSlots.length - 1]; + while (conditional.alternate.type === 19) { + conditional = conditional.alternate; + } + conditional.alternate = vElse.exp ? createConditionalExpression( + vElse.exp, + buildDynamicSlot( + slotName, + slotFunction, + conditionalBranchIndex++ + ), + defaultFallback + ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++); + } else { + context.onError( + createCompilerError(30, vElse.loc) + ); + } + } else if (vFor) { + hasDynamicSlots = true; + const parseResult = vFor.forParseResult; + if (parseResult) { + finalizeForParseResult(parseResult, context); + dynamicSlots.push( + createCallExpression(context.helper(RENDER_LIST), [ + parseResult.source, + createFunctionExpression( + createForLoopParams(parseResult), + buildDynamicSlot(slotName, slotFunction), + true + ) + ]) + ); + } else { + context.onError( + createCompilerError( + 32, + vFor.loc + ) + ); + } + } else { + if (staticSlotName) { + if (seenSlotNames.has(staticSlotName)) { + context.onError( + createCompilerError( + 38, + dirLoc + ) + ); + continue; + } + seenSlotNames.add(staticSlotName); + if (staticSlotName === "default") { + hasNamedDefaultSlot = true; + } + } + slotsProperties.push(createObjectProperty(slotName, slotFunction)); + } + } + if (!onComponentSlot) { + const buildDefaultSlotProperty = (props, children2) => { + const fn = buildSlotFn(props, void 0, children2, loc); + if (context.compatConfig) { + fn.isNonScopedSlot = true; + } + return createObjectProperty(`default`, fn); + }; + if (!hasTemplateSlots) { + slotsProperties.push(buildDefaultSlotProperty(void 0, children)); + } else if (implicitDefaultChildren.length && // #3766 + // with whitespace: 'preserve', whitespaces between slots will end up in + // implicitDefaultChildren. Ignore if all implicit children are whitespaces. + !implicitDefaultChildren.every(isWhitespaceText)) { + if (hasNamedDefaultSlot) { + context.onError( + createCompilerError( + 39, + implicitDefaultChildren[0].loc + ) + ); + } else { + slotsProperties.push( + buildDefaultSlotProperty(void 0, implicitDefaultChildren) + ); + } + } + } + const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1; + let slots = createObjectExpression( + slotsProperties.concat( + createObjectProperty( + `_`, + // 2 = compiled but dynamic = can skip normalization, but must run diff + // 1 = compiled and static = can skip normalization AND diff as optimized + createSimpleExpression( + slotFlag + (` /* ${shared.slotFlagsText[slotFlag]} */` ), + false + ) + ) + ), + loc + ); + if (dynamicSlots.length) { + slots = createCallExpression(context.helper(CREATE_SLOTS), [ + slots, + createArrayExpression(dynamicSlots) + ]); + } + return { + slots, + hasDynamicSlots + }; +} +function buildDynamicSlot(name, fn, index) { + const props = [ + createObjectProperty(`name`, name), + createObjectProperty(`fn`, fn) + ]; + if (index != null) { + props.push( + createObjectProperty(`key`, createSimpleExpression(String(index), true)) + ); + } + return createObjectExpression(props); +} +function hasForwardedSlots(children) { + for (let i = 0; i < children.length; i++) { + const child = children[i]; + switch (child.type) { + case 1: + if (child.tagType === 2 || hasForwardedSlots(child.children)) { + return true; + } + break; + case 9: + if (hasForwardedSlots(child.branches)) return true; + break; + case 10: + case 11: + if (hasForwardedSlots(child.children)) return true; + break; + } + } + return false; +} + +const directiveImportMap = /* @__PURE__ */ new WeakMap(); +const transformElement = (node, context) => { + return function postTransformElement() { + node = context.currentNode; + if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) { + return; + } + const { tag, props } = node; + const isComponent = node.tagType === 1; + let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`; + const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT; + let vnodeProps; + let vnodeChildren; + let patchFlag = 0; + let vnodeDynamicProps; + let dynamicPropNames; + let vnodeDirectives; + let shouldUseBlock = ( + // dynamic component may resolve to plain elements + isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block + // updates inside get proper isSVG flag at runtime. (#639, #643) + // This is technically web-specific, but splitting the logic out of core + // leads to too much unnecessary complexity. + (tag === "svg" || tag === "foreignObject" || tag === "math") + ); + if (props.length > 0) { + const propsBuildResult = buildProps( + node, + context, + void 0, + isComponent, + isDynamicComponent + ); + vnodeProps = propsBuildResult.props; + patchFlag = propsBuildResult.patchFlag; + dynamicPropNames = propsBuildResult.dynamicPropNames; + const directives = propsBuildResult.directives; + vnodeDirectives = directives && directives.length ? createArrayExpression( + directives.map((dir) => buildDirectiveArgs(dir, context)) + ) : void 0; + if (propsBuildResult.shouldUseBlock) { + shouldUseBlock = true; + } + } + if (node.children.length > 0) { + if (vnodeTag === KEEP_ALIVE) { + shouldUseBlock = true; + patchFlag |= 1024; + if (node.children.length > 1) { + context.onError( + createCompilerError(47, { + start: node.children[0].loc.start, + end: node.children[node.children.length - 1].loc.end, + source: "" + }) + ); + } + } + const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling + vnodeTag !== TELEPORT && // explained above. + vnodeTag !== KEEP_ALIVE; + if (shouldBuildAsSlots) { + const { slots, hasDynamicSlots } = buildSlots(node, context); + vnodeChildren = slots; + if (hasDynamicSlots) { + patchFlag |= 1024; + } + } else if (node.children.length === 1 && vnodeTag !== TELEPORT) { + const child = node.children[0]; + const type = child.type; + const hasDynamicTextChild = type === 5 || type === 8; + if (hasDynamicTextChild && getConstantType(child, context) === 0) { + patchFlag |= 1; + } + if (hasDynamicTextChild || type === 2) { + vnodeChildren = child; + } else { + vnodeChildren = node.children; + } + } else { + vnodeChildren = node.children; + } + } + if (dynamicPropNames && dynamicPropNames.length) { + vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames); + } + node.codegenNode = createVNodeCall( + context, + vnodeTag, + vnodeProps, + vnodeChildren, + patchFlag === 0 ? void 0 : patchFlag, + vnodeDynamicProps, + vnodeDirectives, + !!shouldUseBlock, + false, + isComponent, + node.loc + ); + }; +}; +function resolveComponentType(node, context, ssr = false) { + let { tag } = node; + const isExplicitDynamic = isComponentTag(tag); + const isProp = findProp( + node, + "is", + false, + true + /* allow empty */ + ); + if (isProp) { + if (isExplicitDynamic || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + )) { + let exp; + if (isProp.type === 6) { + exp = isProp.value && createSimpleExpression(isProp.value.content, true); + } else { + exp = isProp.exp; + if (!exp) { + exp = createSimpleExpression(`is`, false, isProp.arg.loc); + { + exp = isProp.exp = processExpression(exp, context); + } + } + } + if (exp) { + return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [ + exp + ]); + } + } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) { + tag = isProp.value.content.slice(4); + } + } + const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag); + if (builtIn) { + if (!ssr) context.helper(builtIn); + return builtIn; + } + { + const fromSetup = resolveSetupReference(tag, context); + if (fromSetup) { + return fromSetup; + } + const dotIndex = tag.indexOf("."); + if (dotIndex > 0) { + const ns = resolveSetupReference(tag.slice(0, dotIndex), context); + if (ns) { + return ns + tag.slice(dotIndex); + } + } + } + if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) { + context.helper(RESOLVE_COMPONENT); + context.components.add(tag + `__self`); + return toValidAssetId(tag, `component`); + } + context.helper(RESOLVE_COMPONENT); + context.components.add(tag); + return toValidAssetId(tag, `component`); +} +function resolveSetupReference(name, context) { + const bindings = context.bindingMetadata; + if (!bindings || bindings.__isScriptSetup === false) { + return; + } + const camelName = shared.camelize(name); + const PascalName = shared.capitalize(camelName); + const checkType = (type) => { + if (bindings[name] === type) { + return name; + } + if (bindings[camelName] === type) { + return camelName; + } + if (bindings[PascalName] === type) { + return PascalName; + } + }; + const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const"); + if (fromConst) { + return context.inline ? ( + // in inline mode, const setup bindings (e.g. imports) can be used as-is + fromConst + ) : `$setup[${JSON.stringify(fromConst)}]`; + } + const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref"); + if (fromMaybeRef) { + return context.inline ? ( + // setup scope bindings that may be refs need to be unrefed + `${context.helperString(UNREF)}(${fromMaybeRef})` + ) : `$setup[${JSON.stringify(fromMaybeRef)}]`; + } + const fromProps = checkType("props"); + if (fromProps) { + return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`; + } +} +function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) { + const { tag, loc: elementLoc, children } = node; + let properties = []; + const mergeArgs = []; + const runtimeDirectives = []; + const hasChildren = children.length > 0; + let shouldUseBlock = false; + let patchFlag = 0; + let hasRef = false; + let hasClassBinding = false; + let hasStyleBinding = false; + let hasHydrationEventBinding = false; + let hasDynamicKeys = false; + let hasVnodeHook = false; + const dynamicPropNames = []; + const pushMergeArg = (arg) => { + if (properties.length) { + mergeArgs.push( + createObjectExpression(dedupeProperties(properties), elementLoc) + ); + properties = []; + } + if (arg) mergeArgs.push(arg); + }; + const pushRefVForMarker = () => { + if (context.scopes.vFor > 0) { + properties.push( + createObjectProperty( + createSimpleExpression("ref_for", true), + createSimpleExpression("true") + ) + ); + } + }; + const analyzePatchFlag = ({ key, value }) => { + if (isStaticExp(key)) { + const name = key.content; + const isEventHandler = shared.isOn(name); + if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click + // dedicated fast path. + name.toLowerCase() !== "onclick" && // omit v-model handlers + name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks + !shared.isReservedProp(name)) { + hasHydrationEventBinding = true; + } + if (isEventHandler && shared.isReservedProp(name)) { + hasVnodeHook = true; + } + if (isEventHandler && value.type === 14) { + value = value.arguments[0]; + } + if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) { + return; + } + if (name === "ref") { + hasRef = true; + } else if (name === "class") { + hasClassBinding = true; + } else if (name === "style") { + hasStyleBinding = true; + } else if (name !== "key" && !dynamicPropNames.includes(name)) { + dynamicPropNames.push(name); + } + if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) { + dynamicPropNames.push(name); + } + } else { + hasDynamicKeys = true; + } + }; + for (let i = 0; i < props.length; i++) { + const prop = props[i]; + if (prop.type === 6) { + const { loc, name, nameLoc, value } = prop; + let isStatic = true; + if (name === "ref") { + hasRef = true; + pushRefVForMarker(); + if (value && context.inline) { + const binding = context.bindingMetadata[value.content]; + if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") { + isStatic = false; + properties.push( + createObjectProperty( + createSimpleExpression("ref_key", true), + createSimpleExpression(value.content, true, value.loc) + ) + ); + } + } + } + if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + ))) { + continue; + } + properties.push( + createObjectProperty( + createSimpleExpression(name, true, nameLoc), + createSimpleExpression( + value ? value.content : "", + isStatic, + value ? value.loc : loc + ) + ) + ); + } else { + const { name, arg, exp, loc, modifiers } = prop; + const isVBind = name === "bind"; + const isVOn = name === "on"; + if (name === "slot") { + if (!isComponent) { + context.onError( + createCompilerError(40, loc) + ); + } + continue; + } + if (name === "once" || name === "memo") { + continue; + } + if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled( + "COMPILER_IS_ON_ELEMENT", + context + ))) { + continue; + } + if (isVOn && ssr) { + continue; + } + if ( + // #938: elements with dynamic keys should be forced into blocks + isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked + // before children + isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update") + ) { + shouldUseBlock = true; + } + if (isVBind && isStaticArgOf(arg, "ref")) { + pushRefVForMarker(); + } + if (!arg && (isVBind || isVOn)) { + hasDynamicKeys = true; + if (exp) { + if (isVBind) { + { + pushMergeArg(); + { + const hasOverridableKeys = mergeArgs.some((arg2) => { + if (arg2.type === 15) { + return arg2.properties.some(({ key }) => { + if (key.type !== 4 || !key.isStatic) { + return true; + } + return key.content !== "class" && key.content !== "style" && !shared.isOn(key.content); + }); + } else { + return true; + } + }); + if (hasOverridableKeys) { + checkCompatEnabled( + "COMPILER_V_BIND_OBJECT_ORDER", + context, + loc + ); + } + } + if (isCompatEnabled( + "COMPILER_V_BIND_OBJECT_ORDER", + context + )) { + mergeArgs.unshift(exp); + continue; + } + } + pushRefVForMarker(); + pushMergeArg(); + mergeArgs.push(exp); + } else { + pushMergeArg({ + type: 14, + loc, + callee: context.helper(TO_HANDLERS), + arguments: isComponent ? [exp] : [exp, `true`] + }); + } + } else { + context.onError( + createCompilerError( + isVBind ? 34 : 35, + loc + ) + ); + } + continue; + } + if (isVBind && modifiers.some((mod) => mod.content === "prop")) { + patchFlag |= 32; + } + const directiveTransform = context.directiveTransforms[name]; + if (directiveTransform) { + const { props: props2, needRuntime } = directiveTransform(prop, node, context); + !ssr && props2.forEach(analyzePatchFlag); + if (isVOn && arg && !isStaticExp(arg)) { + pushMergeArg(createObjectExpression(props2, elementLoc)); + } else { + properties.push(...props2); + } + if (needRuntime) { + runtimeDirectives.push(prop); + if (shared.isSymbol(needRuntime)) { + directiveImportMap.set(prop, needRuntime); + } + } + } else if (!shared.isBuiltInDirective(name)) { + runtimeDirectives.push(prop); + if (hasChildren) { + shouldUseBlock = true; + } + } + } + } + let propsExpression = void 0; + if (mergeArgs.length) { + pushMergeArg(); + if (mergeArgs.length > 1) { + propsExpression = createCallExpression( + context.helper(MERGE_PROPS), + mergeArgs, + elementLoc + ); + } else { + propsExpression = mergeArgs[0]; + } + } else if (properties.length) { + propsExpression = createObjectExpression( + dedupeProperties(properties), + elementLoc + ); + } + if (hasDynamicKeys) { + patchFlag |= 16; + } else { + if (hasClassBinding && !isComponent) { + patchFlag |= 2; + } + if (hasStyleBinding && !isComponent) { + patchFlag |= 4; + } + if (dynamicPropNames.length) { + patchFlag |= 8; + } + if (hasHydrationEventBinding) { + patchFlag |= 32; + } + } + if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) { + patchFlag |= 512; + } + if (!context.inSSR && propsExpression) { + switch (propsExpression.type) { + case 15: + let classKeyIndex = -1; + let styleKeyIndex = -1; + let hasDynamicKey = false; + for (let i = 0; i < propsExpression.properties.length; i++) { + const key = propsExpression.properties[i].key; + if (isStaticExp(key)) { + if (key.content === "class") { + classKeyIndex = i; + } else if (key.content === "style") { + styleKeyIndex = i; + } + } else if (!key.isHandlerKey) { + hasDynamicKey = true; + } + } + const classProp = propsExpression.properties[classKeyIndex]; + const styleProp = propsExpression.properties[styleKeyIndex]; + if (!hasDynamicKey) { + if (classProp && !isStaticExp(classProp.value)) { + classProp.value = createCallExpression( + context.helper(NORMALIZE_CLASS), + [classProp.value] + ); + } + if (styleProp && // the static style is compiled into an object, + // so use `hasStyleBinding` to ensure that it is a dynamic style binding + (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist, + // v-bind:style with static literal object + styleProp.value.type === 17)) { + styleProp.value = createCallExpression( + context.helper(NORMALIZE_STYLE), + [styleProp.value] + ); + } + } else { + propsExpression = createCallExpression( + context.helper(NORMALIZE_PROPS), + [propsExpression] + ); + } + break; + case 14: + break; + default: + propsExpression = createCallExpression( + context.helper(NORMALIZE_PROPS), + [ + createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [ + propsExpression + ]) + ] + ); + break; + } + } + return { + props: propsExpression, + directives: runtimeDirectives, + patchFlag, + dynamicPropNames, + shouldUseBlock + }; +} +function dedupeProperties(properties) { + const knownProps = /* @__PURE__ */ new Map(); + const deduped = []; + for (let i = 0; i < properties.length; i++) { + const prop = properties[i]; + if (prop.key.type === 8 || !prop.key.isStatic) { + deduped.push(prop); + continue; + } + const name = prop.key.content; + const existing = knownProps.get(name); + if (existing) { + if (name === "style" || name === "class" || shared.isOn(name)) { + mergeAsArray(existing, prop); + } + } else { + knownProps.set(name, prop); + deduped.push(prop); + } + } + return deduped; +} +function mergeAsArray(existing, incoming) { + if (existing.value.type === 17) { + existing.value.elements.push(incoming.value); + } else { + existing.value = createArrayExpression( + [existing.value, incoming.value], + existing.loc + ); + } +} +function buildDirectiveArgs(dir, context) { + const dirArgs = []; + const runtime = directiveImportMap.get(dir); + if (runtime) { + dirArgs.push(context.helperString(runtime)); + } else { + const fromSetup = resolveSetupReference("v-" + dir.name, context); + if (fromSetup) { + dirArgs.push(fromSetup); + } else { + context.helper(RESOLVE_DIRECTIVE); + context.directives.add(dir.name); + dirArgs.push(toValidAssetId(dir.name, `directive`)); + } + } + const { loc } = dir; + if (dir.exp) dirArgs.push(dir.exp); + if (dir.arg) { + if (!dir.exp) { + dirArgs.push(`void 0`); + } + dirArgs.push(dir.arg); + } + if (Object.keys(dir.modifiers).length) { + if (!dir.arg) { + if (!dir.exp) { + dirArgs.push(`void 0`); + } + dirArgs.push(`void 0`); + } + const trueExpression = createSimpleExpression(`true`, false, loc); + dirArgs.push( + createObjectExpression( + dir.modifiers.map( + (modifier) => createObjectProperty(modifier, trueExpression) + ), + loc + ) + ); + } + return createArrayExpression(dirArgs, dir.loc); +} +function stringifyDynamicPropNames(props) { + let propsNamesString = `[`; + for (let i = 0, l = props.length; i < l; i++) { + propsNamesString += JSON.stringify(props[i]); + if (i < l - 1) propsNamesString += ", "; + } + return propsNamesString + `]`; +} +function isComponentTag(tag) { + return tag === "component" || tag === "Component"; +} + +const transformSlotOutlet = (node, context) => { + if (isSlotOutlet(node)) { + const { children, loc } = node; + const { slotName, slotProps } = processSlotOutlet(node, context); + const slotArgs = [ + context.prefixIdentifiers ? `_ctx.$slots` : `$slots`, + slotName, + "{}", + "undefined", + "true" + ]; + let expectedLen = 2; + if (slotProps) { + slotArgs[2] = slotProps; + expectedLen = 3; + } + if (children.length) { + slotArgs[3] = createFunctionExpression([], children, false, false, loc); + expectedLen = 4; + } + if (context.scopeId && !context.slotted) { + expectedLen = 5; + } + slotArgs.splice(expectedLen); + node.codegenNode = createCallExpression( + context.helper(RENDER_SLOT), + slotArgs, + loc + ); + } +}; +function processSlotOutlet(node, context) { + let slotName = `"default"`; + let slotProps = void 0; + const nonNameProps = []; + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + if (p.value) { + if (p.name === "name") { + slotName = JSON.stringify(p.value.content); + } else { + p.name = shared.camelize(p.name); + nonNameProps.push(p); + } + } + } else { + if (p.name === "bind" && isStaticArgOf(p.arg, "name")) { + if (p.exp) { + slotName = p.exp; + } else if (p.arg && p.arg.type === 4) { + const name = shared.camelize(p.arg.content); + slotName = p.exp = createSimpleExpression(name, false, p.arg.loc); + { + slotName = p.exp = processExpression(p.exp, context); + } + } + } else { + if (p.name === "bind" && p.arg && isStaticExp(p.arg)) { + p.arg.content = shared.camelize(p.arg.content); + } + nonNameProps.push(p); + } + } + } + if (nonNameProps.length > 0) { + const { props, directives } = buildProps( + node, + context, + nonNameProps, + false, + false + ); + slotProps = props; + if (directives.length) { + context.onError( + createCompilerError( + 36, + directives[0].loc + ) + ); + } + } + return { + slotName, + slotProps + }; +} + +const transformOn = (dir, node, context, augmentor) => { + const { loc, modifiers, arg } = dir; + if (!dir.exp && !modifiers.length) { + context.onError(createCompilerError(35, loc)); + } + let eventName; + if (arg.type === 4) { + if (arg.isStatic) { + let rawName = arg.content; + if (rawName.startsWith("vnode")) { + context.onError(createCompilerError(52, arg.loc)); + } + if (rawName.startsWith("vue:")) { + rawName = `vnode-${rawName.slice(4)}`; + } + const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? ( + // for non-element and vnode lifecycle event listeners, auto convert + // it to camelCase. See issue #2249 + shared.toHandlerKey(shared.camelize(rawName)) + ) : ( + // preserve case for plain element listeners that have uppercase + // letters, as these may be custom elements' custom events + `on:${rawName}` + ); + eventName = createSimpleExpression(eventString, true, arg.loc); + } else { + eventName = createCompoundExpression([ + `${context.helperString(TO_HANDLER_KEY)}(`, + arg, + `)` + ]); + } + } else { + eventName = arg; + eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`); + eventName.children.push(`)`); + } + let exp = dir.exp; + if (exp && !exp.content.trim()) { + exp = void 0; + } + let shouldCache = context.cacheHandlers && !exp && !context.inVOnce; + if (exp) { + const isMemberExp = isMemberExpression(exp, context); + const isInlineStatement = !(isMemberExp || isFnExpression(exp, context)); + const hasMultipleStatements = exp.content.includes(`;`); + if (context.prefixIdentifiers) { + isInlineStatement && context.addIdentifiers(`$event`); + exp = dir.exp = processExpression( + exp, + context, + false, + hasMultipleStatements + ); + isInlineStatement && context.removeIdentifiers(`$event`); + shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once + !context.inVOnce && // runtime constants don't need to be cached + // (this is analyzed by compileScript in SFC <script setup>) + !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component - + // we need to use the original function to preserve arity, + // e.g. <transition> relies on checking cb.length to determine + // transition end handling. Inline function is ok since its arity + // is preserved even when cached. + !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot) + // it must be passed fresh to avoid stale values. + !hasScopeRef(exp, context.identifiers); + if (shouldCache && isMemberExp) { + if (exp.type === 4) { + exp.content = `${exp.content} && ${exp.content}(...args)`; + } else { + exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`]; + } + } + } + if (isInlineStatement || shouldCache && isMemberExp) { + exp = createCompoundExpression([ + `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? ` +//@ts-ignore +` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`, + exp, + hasMultipleStatements ? `}` : `)` + ]); + } + } + let ret = { + props: [ + createObjectProperty( + eventName, + exp || createSimpleExpression(`() => {}`, false, loc) + ) + ] + }; + if (augmentor) { + ret = augmentor(ret); + } + if (shouldCache) { + ret.props[0].value = context.cache(ret.props[0].value); + } + ret.props.forEach((p) => p.key.isHandlerKey = true); + return ret; +}; + +const transformBind = (dir, _node, context) => { + const { modifiers, loc } = dir; + const arg = dir.arg; + let { exp } = dir; + if (exp && exp.type === 4 && !exp.content.trim()) { + { + context.onError( + createCompilerError(34, loc) + ); + return { + props: [ + createObjectProperty(arg, createSimpleExpression("", true, loc)) + ] + }; + } + } + if (arg.type !== 4) { + arg.children.unshift(`(`); + arg.children.push(`) || ""`); + } else if (!arg.isStatic) { + arg.content = arg.content ? `${arg.content} || ""` : `""`; + } + if (modifiers.some((mod) => mod.content === "camel")) { + if (arg.type === 4) { + if (arg.isStatic) { + arg.content = shared.camelize(arg.content); + } else { + arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`; + } + } else { + arg.children.unshift(`${context.helperString(CAMELIZE)}(`); + arg.children.push(`)`); + } + } + if (!context.inSSR) { + if (modifiers.some((mod) => mod.content === "prop")) { + injectPrefix(arg, "."); + } + if (modifiers.some((mod) => mod.content === "attr")) { + injectPrefix(arg, "^"); + } + } + return { + props: [createObjectProperty(arg, exp)] + }; +}; +const injectPrefix = (arg, prefix) => { + if (arg.type === 4) { + if (arg.isStatic) { + arg.content = prefix + arg.content; + } else { + arg.content = `\`${prefix}\${${arg.content}}\``; + } + } else { + arg.children.unshift(`'${prefix}' + (`); + arg.children.push(`)`); + } +}; + +const transformText = (node, context) => { + if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) { + return () => { + const children = node.children; + let currentContainer = void 0; + let hasText = false; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isText$1(child)) { + hasText = true; + for (let j = i + 1; j < children.length; j++) { + const next = children[j]; + if (isText$1(next)) { + if (!currentContainer) { + currentContainer = children[i] = createCompoundExpression( + [child], + child.loc + ); + } + currentContainer.children.push(` + `, next); + children.splice(j, 1); + j--; + } else { + currentContainer = void 0; + break; + } + } + } + } + if (!hasText || // if this is a plain element with a single text child, leave it + // as-is since the runtime has dedicated fast path for this by directly + // setting textContent of the element. + // for component root it's always normalized anyway. + children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756 + // custom directives can potentially add DOM elements arbitrarily, + // we need to avoid setting textContent of the element at runtime + // to avoid accidentally overwriting the DOM elements added + // by the user through custom directives. + !node.props.find( + (p) => p.type === 7 && !context.directiveTransforms[p.name] + ) && // in compat mode, <template> tags with no special directives + // will be rendered as a fragment so its children must be + // converted into vnodes. + !(node.tag === "template"))) { + return; + } + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isText$1(child) || child.type === 8) { + const callArgs = []; + if (child.type !== 2 || child.content !== " ") { + callArgs.push(child); + } + if (!context.ssr && getConstantType(child, context) === 0) { + callArgs.push( + 1 + (` /* ${shared.PatchFlagNames[1]} */` ) + ); + } + children[i] = { + type: 12, + content: child, + loc: child.loc, + codegenNode: createCallExpression( + context.helper(CREATE_TEXT), + callArgs + ) + }; + } + } + }; + } +}; + +const seen$1 = /* @__PURE__ */ new WeakSet(); +const transformOnce = (node, context) => { + if (node.type === 1 && findDir(node, "once", true)) { + if (seen$1.has(node) || context.inVOnce || context.inSSR) { + return; + } + seen$1.add(node); + context.inVOnce = true; + context.helper(SET_BLOCK_TRACKING); + return () => { + context.inVOnce = false; + const cur = context.currentNode; + if (cur.codegenNode) { + cur.codegenNode = context.cache( + cur.codegenNode, + true, + true + ); + } + }; + } +}; + +const transformModel = (dir, node, context) => { + const { exp, arg } = dir; + if (!exp) { + context.onError( + createCompilerError(41, dir.loc) + ); + return createTransformProps(); + } + const rawExp = exp.loc.source.trim(); + const expString = exp.type === 4 ? exp.content : rawExp; + const bindingType = context.bindingMetadata[rawExp]; + if (bindingType === "props" || bindingType === "props-aliased") { + context.onError(createCompilerError(44, exp.loc)); + return createTransformProps(); + } + if (bindingType === "literal-const" || bindingType === "setup-const") { + context.onError(createCompilerError(45, exp.loc)); + return createTransformProps(); + } + const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref"); + if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) { + context.onError( + createCompilerError(42, exp.loc) + ); + return createTransformProps(); + } + if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) { + context.onError( + createCompilerError(43, exp.loc) + ); + return createTransformProps(); + } + const propName = arg ? arg : createSimpleExpression("modelValue", true); + const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`; + let assignmentExp; + const eventArg = context.isTS ? `($event: any)` : `$event`; + if (maybeRef) { + if (bindingType === "setup-ref") { + assignmentExp = createCompoundExpression([ + `${eventArg} => ((`, + createSimpleExpression(rawExp, false, exp.loc), + `).value = $event)` + ]); + } else { + const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`; + assignmentExp = createCompoundExpression([ + `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`, + createSimpleExpression(rawExp, false, exp.loc), + `).value = $event : ${altAssignment})` + ]); + } + } else { + assignmentExp = createCompoundExpression([ + `${eventArg} => ((`, + exp, + `) = $event)` + ]); + } + const props = [ + // modelValue: foo + createObjectProperty(propName, dir.exp), + // "onUpdate:modelValue": $event => (foo = $event) + createObjectProperty(eventName, assignmentExp) + ]; + if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) { + props[1].value = context.cache(props[1].value); + } + if (dir.modifiers.length && node.tagType === 1) { + const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `); + const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`; + props.push( + createObjectProperty( + modifiersKey, + createSimpleExpression( + `{ ${modifiers} }`, + false, + dir.loc, + 2 + ) + ) + ); + } + return createTransformProps(props); +}; +function createTransformProps(props = []) { + return { props }; +} + +const validDivisionCharRE = /[\w).+\-_$\]]/; +const transformFilter = (node, context) => { + if (!isCompatEnabled("COMPILER_FILTERS", context)) { + return; + } + if (node.type === 5) { + rewriteFilter(node.content, context); + } else if (node.type === 1) { + node.props.forEach((prop) => { + if (prop.type === 7 && prop.name !== "for" && prop.exp) { + rewriteFilter(prop.exp, context); + } + }); + } +}; +function rewriteFilter(node, context) { + if (node.type === 4) { + parseFilter(node, context); + } else { + for (let i = 0; i < node.children.length; i++) { + const child = node.children[i]; + if (typeof child !== "object") continue; + if (child.type === 4) { + parseFilter(child, context); + } else if (child.type === 8) { + rewriteFilter(node, context); + } else if (child.type === 5) { + rewriteFilter(child.content, context); + } + } + } +} +function parseFilter(node, context) { + const exp = node.content; + let inSingle = false; + let inDouble = false; + let inTemplateString = false; + let inRegex = false; + let curly = 0; + let square = 0; + let paren = 0; + let lastFilterIndex = 0; + let c, prev, i, expression, filters = []; + for (i = 0; i < exp.length; i++) { + prev = c; + c = exp.charCodeAt(i); + if (inSingle) { + if (c === 39 && prev !== 92) inSingle = false; + } else if (inDouble) { + if (c === 34 && prev !== 92) inDouble = false; + } else if (inTemplateString) { + if (c === 96 && prev !== 92) inTemplateString = false; + } else if (inRegex) { + if (c === 47 && prev !== 92) inRegex = false; + } else if (c === 124 && // pipe + exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) { + if (expression === void 0) { + lastFilterIndex = i + 1; + expression = exp.slice(0, i).trim(); + } else { + pushFilter(); + } + } else { + switch (c) { + case 34: + inDouble = true; + break; + // " + case 39: + inSingle = true; + break; + // ' + case 96: + inTemplateString = true; + break; + // ` + case 40: + paren++; + break; + // ( + case 41: + paren--; + break; + // ) + case 91: + square++; + break; + // [ + case 93: + square--; + break; + // ] + case 123: + curly++; + break; + // { + case 125: + curly--; + break; + } + if (c === 47) { + let j = i - 1; + let p; + for (; j >= 0; j--) { + p = exp.charAt(j); + if (p !== " ") break; + } + if (!p || !validDivisionCharRE.test(p)) { + inRegex = true; + } + } + } + } + if (expression === void 0) { + expression = exp.slice(0, i).trim(); + } else if (lastFilterIndex !== 0) { + pushFilter(); + } + function pushFilter() { + filters.push(exp.slice(lastFilterIndex, i).trim()); + lastFilterIndex = i + 1; + } + if (filters.length) { + warnDeprecation( + "COMPILER_FILTERS", + context, + node.loc + ); + for (i = 0; i < filters.length; i++) { + expression = wrapFilter(expression, filters[i], context); + } + node.content = expression; + node.ast = void 0; + } +} +function wrapFilter(exp, filter, context) { + context.helper(RESOLVE_FILTER); + const i = filter.indexOf("("); + if (i < 0) { + context.filters.add(filter); + return `${toValidAssetId(filter, "filter")}(${exp})`; + } else { + const name = filter.slice(0, i); + const args = filter.slice(i + 1); + context.filters.add(name); + return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`; + } +} + +const seen = /* @__PURE__ */ new WeakSet(); +const transformMemo = (node, context) => { + if (node.type === 1) { + const dir = findDir(node, "memo"); + if (!dir || seen.has(node) || context.inSSR) { + return; + } + seen.add(node); + return () => { + const codegenNode = node.codegenNode || context.currentNode.codegenNode; + if (codegenNode && codegenNode.type === 13) { + if (node.tagType !== 1) { + convertToBlock(codegenNode, context); + } + node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [ + dir.exp, + createFunctionExpression(void 0, codegenNode), + `_cache`, + String(context.cached.length) + ]); + context.cached.push(null); + } + }; + } +}; + +const transformVBindShorthand = (node, context) => { + if (node.type === 1) { + for (const prop of node.props) { + if (prop.type === 7 && prop.name === "bind" && (!prop.exp || // #13930 :foo in in-DOM templates will be parsed into :foo="" by browser + false) && prop.arg) { + const arg = prop.arg; + if (arg.type !== 4 || !arg.isStatic) { + context.onError( + createCompilerError( + 53, + arg.loc + ) + ); + prop.exp = createSimpleExpression("", true, arg.loc); + } else { + const propName = shared.camelize(arg.content); + if (validFirstIdentCharRE.test(propName[0]) || // allow hyphen first char for https://github.com/vuejs/language-tools/pull/3424 + propName[0] === "-") { + prop.exp = createSimpleExpression(propName, false, arg.loc); + } + } + } + } + } +}; + +function getBaseTransformPreset(prefixIdentifiers) { + return [ + [ + transformVBindShorthand, + transformOnce, + transformIf, + transformMemo, + transformFor, + ...[transformFilter] , + ...prefixIdentifiers ? [ + // order is important + trackVForSlotScopes, + transformExpression + ] : [], + transformSlotOutlet, + transformElement, + trackSlotScopes, + transformText + ], + { + on: transformOn, + bind: transformBind, + model: transformModel + } + ]; +} +function baseCompile(source, options = {}) { + const onError = options.onError || defaultOnError; + const isModuleMode = options.mode === "module"; + const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode; + if (!prefixIdentifiers && options.cacheHandlers) { + onError(createCompilerError(50)); + } + if (options.scopeId && !isModuleMode) { + onError(createCompilerError(51)); + } + const resolvedOptions = shared.extend({}, options, { + prefixIdentifiers + }); + const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source; + const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers); + if (options.isTS) { + const { expressionPlugins } = options; + if (!expressionPlugins || !expressionPlugins.includes("typescript")) { + options.expressionPlugins = [...expressionPlugins || [], "typescript"]; + } + } + transform( + ast, + shared.extend({}, resolvedOptions, { + nodeTransforms: [ + ...nodeTransforms, + ...options.nodeTransforms || [] + // user transforms + ], + directiveTransforms: shared.extend( + {}, + directiveTransforms, + options.directiveTransforms || {} + // user transforms + ) + }) + ); + return generate(ast, resolvedOptions); +} + +const BindingTypes = { + "DATA": "data", + "PROPS": "props", + "PROPS_ALIASED": "props-aliased", + "SETUP_LET": "setup-let", + "SETUP_CONST": "setup-const", + "SETUP_REACTIVE_CONST": "setup-reactive-const", + "SETUP_MAYBE_REF": "setup-maybe-ref", + "SETUP_REF": "setup-ref", + "OPTIONS": "options", + "LITERAL_CONST": "literal-const" +}; + +const noopDirectiveTransform = () => ({ props: [] }); + +exports.generateCodeFrame = shared.generateCodeFrame; +exports.BASE_TRANSITION = BASE_TRANSITION; +exports.BindingTypes = BindingTypes; +exports.CAMELIZE = CAMELIZE; +exports.CAPITALIZE = CAPITALIZE; +exports.CREATE_BLOCK = CREATE_BLOCK; +exports.CREATE_COMMENT = CREATE_COMMENT; +exports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK; +exports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE; +exports.CREATE_SLOTS = CREATE_SLOTS; +exports.CREATE_STATIC = CREATE_STATIC; +exports.CREATE_TEXT = CREATE_TEXT; +exports.CREATE_VNODE = CREATE_VNODE; +exports.CompilerDeprecationTypes = CompilerDeprecationTypes; +exports.ConstantTypes = ConstantTypes; +exports.ElementTypes = ElementTypes; +exports.ErrorCodes = ErrorCodes; +exports.FRAGMENT = FRAGMENT; +exports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS; +exports.IS_MEMO_SAME = IS_MEMO_SAME; +exports.IS_REF = IS_REF; +exports.KEEP_ALIVE = KEEP_ALIVE; +exports.MERGE_PROPS = MERGE_PROPS; +exports.NORMALIZE_CLASS = NORMALIZE_CLASS; +exports.NORMALIZE_PROPS = NORMALIZE_PROPS; +exports.NORMALIZE_STYLE = NORMALIZE_STYLE; +exports.Namespaces = Namespaces; +exports.NodeTypes = NodeTypes; +exports.OPEN_BLOCK = OPEN_BLOCK; +exports.POP_SCOPE_ID = POP_SCOPE_ID; +exports.PUSH_SCOPE_ID = PUSH_SCOPE_ID; +exports.RENDER_LIST = RENDER_LIST; +exports.RENDER_SLOT = RENDER_SLOT; +exports.RESOLVE_COMPONENT = RESOLVE_COMPONENT; +exports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE; +exports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT; +exports.RESOLVE_FILTER = RESOLVE_FILTER; +exports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING; +exports.SUSPENSE = SUSPENSE; +exports.TELEPORT = TELEPORT; +exports.TO_DISPLAY_STRING = TO_DISPLAY_STRING; +exports.TO_HANDLERS = TO_HANDLERS; +exports.TO_HANDLER_KEY = TO_HANDLER_KEY; +exports.TS_NODE_TYPES = TS_NODE_TYPES; +exports.UNREF = UNREF; +exports.WITH_CTX = WITH_CTX; +exports.WITH_DIRECTIVES = WITH_DIRECTIVES; +exports.WITH_MEMO = WITH_MEMO; +exports.advancePositionWithClone = advancePositionWithClone; +exports.advancePositionWithMutation = advancePositionWithMutation; +exports.assert = assert; +exports.baseCompile = baseCompile; +exports.baseParse = baseParse; +exports.buildDirectiveArgs = buildDirectiveArgs; +exports.buildProps = buildProps; +exports.buildSlots = buildSlots; +exports.checkCompatEnabled = checkCompatEnabled; +exports.convertToBlock = convertToBlock; +exports.createArrayExpression = createArrayExpression; +exports.createAssignmentExpression = createAssignmentExpression; +exports.createBlockStatement = createBlockStatement; +exports.createCacheExpression = createCacheExpression; +exports.createCallExpression = createCallExpression; +exports.createCompilerError = createCompilerError; +exports.createCompoundExpression = createCompoundExpression; +exports.createConditionalExpression = createConditionalExpression; +exports.createForLoopParams = createForLoopParams; +exports.createFunctionExpression = createFunctionExpression; +exports.createIfStatement = createIfStatement; +exports.createInterpolation = createInterpolation; +exports.createObjectExpression = createObjectExpression; +exports.createObjectProperty = createObjectProperty; +exports.createReturnStatement = createReturnStatement; +exports.createRoot = createRoot; +exports.createSequenceExpression = createSequenceExpression; +exports.createSimpleExpression = createSimpleExpression; +exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform; +exports.createTemplateLiteral = createTemplateLiteral; +exports.createTransformContext = createTransformContext; +exports.createVNodeCall = createVNodeCall; +exports.errorMessages = errorMessages; +exports.extractIdentifiers = extractIdentifiers; +exports.findDir = findDir; +exports.findProp = findProp; +exports.forAliasRE = forAliasRE; +exports.generate = generate; +exports.getBaseTransformPreset = getBaseTransformPreset; +exports.getConstantType = getConstantType; +exports.getMemoedVNodeCall = getMemoedVNodeCall; +exports.getVNodeBlockHelper = getVNodeBlockHelper; +exports.getVNodeHelper = getVNodeHelper; +exports.hasDynamicKeyVBind = hasDynamicKeyVBind; +exports.hasScopeRef = hasScopeRef; +exports.helperNameMap = helperNameMap; +exports.injectProp = injectProp; +exports.isAllWhitespace = isAllWhitespace; +exports.isCommentOrWhitespace = isCommentOrWhitespace; +exports.isCoreComponent = isCoreComponent; +exports.isFnExpression = isFnExpression; +exports.isFnExpressionBrowser = isFnExpressionBrowser; +exports.isFnExpressionNode = isFnExpressionNode; +exports.isFunctionType = isFunctionType; +exports.isInDestructureAssignment = isInDestructureAssignment; +exports.isInNewExpression = isInNewExpression; +exports.isMemberExpression = isMemberExpression; +exports.isMemberExpressionBrowser = isMemberExpressionBrowser; +exports.isMemberExpressionNode = isMemberExpressionNode; +exports.isReferencedIdentifier = isReferencedIdentifier; +exports.isSimpleIdentifier = isSimpleIdentifier; +exports.isSlotOutlet = isSlotOutlet; +exports.isStaticArgOf = isStaticArgOf; +exports.isStaticExp = isStaticExp; +exports.isStaticProperty = isStaticProperty; +exports.isStaticPropertyKey = isStaticPropertyKey; +exports.isTemplateNode = isTemplateNode; +exports.isText = isText$1; +exports.isVPre = isVPre; +exports.isVSlot = isVSlot; +exports.isWhitespaceText = isWhitespaceText; +exports.locStub = locStub; +exports.noopDirectiveTransform = noopDirectiveTransform; +exports.processExpression = processExpression; +exports.processFor = processFor; +exports.processIf = processIf; +exports.processSlotOutlet = processSlotOutlet; +exports.registerRuntimeHelpers = registerRuntimeHelpers; +exports.resolveComponentType = resolveComponentType; +exports.stringifyExpression = stringifyExpression; +exports.toValidAssetId = toValidAssetId; +exports.trackSlotScopes = trackSlotScopes; +exports.trackVForSlotScopes = trackVForSlotScopes; +exports.transform = transform; +exports.transformBind = transformBind; +exports.transformElement = transformElement; +exports.transformExpression = transformExpression; +exports.transformModel = transformModel; +exports.transformOn = transformOn; +exports.transformVBindShorthand = transformVBindShorthand; +exports.traverseNode = traverseNode; +exports.unwrapTSNode = unwrapTSNode; +exports.validFirstIdentCharRE = validFirstIdentCharRE; +exports.walkBlockDeclarations = walkBlockDeclarations; +exports.walkFunctionParams = walkFunctionParams; +exports.walkIdentifiers = walkIdentifiers; +exports.warnDeprecation = warnDeprecation; + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509105); +})() +//miniprogram-npm-outsideDeps=["@vue/shared","entities/decode","@babel/parser","estree-walker","source-map-js"] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-core/index.js.map b/miniapp/miniprogram_npm/@vue/compiler-core/index.js.map new file mode 100644 index 0000000..e3f5070 --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-core/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js","dist/compiler-core.cjs.prod.js","dist/compiler-core.cjs.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;AELA,ADGA,ADGA;AELA,ADGA,ADGA;AELA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./dist/compiler-core.cjs.prod.js')\n} else {\n module.exports = require('./dist/compiler-core.cjs.js')\n}\n","/**\n* @vue/compiler-core v3.5.28\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\n* @license MIT\n**/\n\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar shared = require('@vue/shared');\nvar decode = require('entities/decode');\nvar parser = require('@babel/parser');\nvar estreeWalker = require('estree-walker');\nvar sourceMapJs = require('source-map-js');\n\nconst FRAGMENT = /* @__PURE__ */ Symbol(``);\nconst TELEPORT = /* @__PURE__ */ Symbol(``);\nconst SUSPENSE = /* @__PURE__ */ Symbol(``);\nconst KEEP_ALIVE = /* @__PURE__ */ Symbol(``);\nconst BASE_TRANSITION = /* @__PURE__ */ Symbol(\n ``\n);\nconst OPEN_BLOCK = /* @__PURE__ */ Symbol(``);\nconst CREATE_BLOCK = /* @__PURE__ */ Symbol(``);\nconst CREATE_ELEMENT_BLOCK = /* @__PURE__ */ Symbol(\n ``\n);\nconst CREATE_VNODE = /* @__PURE__ */ Symbol(``);\nconst CREATE_ELEMENT_VNODE = /* @__PURE__ */ Symbol(\n ``\n);\nconst CREATE_COMMENT = /* @__PURE__ */ Symbol(\n ``\n);\nconst CREATE_TEXT = /* @__PURE__ */ Symbol(\n ``\n);\nconst CREATE_STATIC = /* @__PURE__ */ Symbol(\n ``\n);\nconst RESOLVE_COMPONENT = /* @__PURE__ */ Symbol(\n ``\n);\nconst RESOLVE_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol(\n ``\n);\nconst RESOLVE_DIRECTIVE = /* @__PURE__ */ Symbol(\n ``\n);\nconst RESOLVE_FILTER = /* @__PURE__ */ Symbol(\n ``\n);\nconst WITH_DIRECTIVES = /* @__PURE__ */ Symbol(\n ``\n);\nconst RENDER_LIST = /* @__PURE__ */ Symbol(``);\nconst RENDER_SLOT = /* @__PURE__ */ Symbol(``);\nconst CREATE_SLOTS = /* @__PURE__ */ Symbol(``);\nconst TO_DISPLAY_STRING = /* @__PURE__ */ Symbol(\n ``\n);\nconst MERGE_PROPS = /* @__PURE__ */ Symbol(``);\nconst NORMALIZE_CLASS = /* @__PURE__ */ Symbol(\n ``\n);\nconst NORMALIZE_STYLE = /* @__PURE__ */ Symbol(\n ``\n);\nconst NORMALIZE_PROPS = /* @__PURE__ */ Symbol(\n ``\n);\nconst GUARD_REACTIVE_PROPS = /* @__PURE__ */ Symbol(\n ``\n);\nconst TO_HANDLERS = /* @__PURE__ */ Symbol(``);\nconst CAMELIZE = /* @__PURE__ */ Symbol(``);\nconst CAPITALIZE = /* @__PURE__ */ Symbol(``);\nconst TO_HANDLER_KEY = /* @__PURE__ */ Symbol(\n ``\n);\nconst SET_BLOCK_TRACKING = /* @__PURE__ */ Symbol(\n ``\n);\nconst PUSH_SCOPE_ID = /* @__PURE__ */ Symbol(``);\nconst POP_SCOPE_ID = /* @__PURE__ */ Symbol(``);\nconst WITH_CTX = /* @__PURE__ */ Symbol(``);\nconst UNREF = /* @__PURE__ */ Symbol(``);\nconst IS_REF = /* @__PURE__ */ Symbol(``);\nconst WITH_MEMO = /* @__PURE__ */ Symbol(``);\nconst IS_MEMO_SAME = /* @__PURE__ */ Symbol(``);\nconst helperNameMap = {\n [FRAGMENT]: `Fragment`,\n [TELEPORT]: `Teleport`,\n [SUSPENSE]: `Suspense`,\n [KEEP_ALIVE]: `KeepAlive`,\n [BASE_TRANSITION]: `BaseTransition`,\n [OPEN_BLOCK]: `openBlock`,\n [CREATE_BLOCK]: `createBlock`,\n [CREATE_ELEMENT_BLOCK]: `createElementBlock`,\n [CREATE_VNODE]: `createVNode`,\n [CREATE_ELEMENT_VNODE]: `createElementVNode`,\n [CREATE_COMMENT]: `createCommentVNode`,\n [CREATE_TEXT]: `createTextVNode`,\n [CREATE_STATIC]: `createStaticVNode`,\n [RESOLVE_COMPONENT]: `resolveComponent`,\n [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,\n [RESOLVE_DIRECTIVE]: `resolveDirective`,\n [RESOLVE_FILTER]: `resolveFilter`,\n [WITH_DIRECTIVES]: `withDirectives`,\n [RENDER_LIST]: `renderList`,\n [RENDER_SLOT]: `renderSlot`,\n [CREATE_SLOTS]: `createSlots`,\n [TO_DISPLAY_STRING]: `toDisplayString`,\n [MERGE_PROPS]: `mergeProps`,\n [NORMALIZE_CLASS]: `normalizeClass`,\n [NORMALIZE_STYLE]: `normalizeStyle`,\n [NORMALIZE_PROPS]: `normalizeProps`,\n [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,\n [TO_HANDLERS]: `toHandlers`,\n [CAMELIZE]: `camelize`,\n [CAPITALIZE]: `capitalize`,\n [TO_HANDLER_KEY]: `toHandlerKey`,\n [SET_BLOCK_TRACKING]: `setBlockTracking`,\n [PUSH_SCOPE_ID]: `pushScopeId`,\n [POP_SCOPE_ID]: `popScopeId`,\n [WITH_CTX]: `withCtx`,\n [UNREF]: `unref`,\n [IS_REF]: `isRef`,\n [WITH_MEMO]: `withMemo`,\n [IS_MEMO_SAME]: `isMemoSame`\n};\nfunction registerRuntimeHelpers(helpers) {\n Object.getOwnPropertySymbols(helpers).forEach((s) => {\n helperNameMap[s] = helpers[s];\n });\n}\n\nconst Namespaces = {\n \"HTML\": 0,\n \"0\": \"HTML\",\n \"SVG\": 1,\n \"1\": \"SVG\",\n \"MATH_ML\": 2,\n \"2\": \"MATH_ML\"\n};\nconst NodeTypes = {\n \"ROOT\": 0,\n \"0\": \"ROOT\",\n \"ELEMENT\": 1,\n \"1\": \"ELEMENT\",\n \"TEXT\": 2,\n \"2\": \"TEXT\",\n \"COMMENT\": 3,\n \"3\": \"COMMENT\",\n \"SIMPLE_EXPRESSION\": 4,\n \"4\": \"SIMPLE_EXPRESSION\",\n \"INTERPOLATION\": 5,\n \"5\": \"INTERPOLATION\",\n \"ATTRIBUTE\": 6,\n \"6\": \"ATTRIBUTE\",\n \"DIRECTIVE\": 7,\n \"7\": \"DIRECTIVE\",\n \"COMPOUND_EXPRESSION\": 8,\n \"8\": \"COMPOUND_EXPRESSION\",\n \"IF\": 9,\n \"9\": \"IF\",\n \"IF_BRANCH\": 10,\n \"10\": \"IF_BRANCH\",\n \"FOR\": 11,\n \"11\": \"FOR\",\n \"TEXT_CALL\": 12,\n \"12\": \"TEXT_CALL\",\n \"VNODE_CALL\": 13,\n \"13\": \"VNODE_CALL\",\n \"JS_CALL_EXPRESSION\": 14,\n \"14\": \"JS_CALL_EXPRESSION\",\n \"JS_OBJECT_EXPRESSION\": 15,\n \"15\": \"JS_OBJECT_EXPRESSION\",\n \"JS_PROPERTY\": 16,\n \"16\": \"JS_PROPERTY\",\n \"JS_ARRAY_EXPRESSION\": 17,\n \"17\": \"JS_ARRAY_EXPRESSION\",\n \"JS_FUNCTION_EXPRESSION\": 18,\n \"18\": \"JS_FUNCTION_EXPRESSION\",\n \"JS_CONDITIONAL_EXPRESSION\": 19,\n \"19\": \"JS_CONDITIONAL_EXPRESSION\",\n \"JS_CACHE_EXPRESSION\": 20,\n \"20\": \"JS_CACHE_EXPRESSION\",\n \"JS_BLOCK_STATEMENT\": 21,\n \"21\": \"JS_BLOCK_STATEMENT\",\n \"JS_TEMPLATE_LITERAL\": 22,\n \"22\": \"JS_TEMPLATE_LITERAL\",\n \"JS_IF_STATEMENT\": 23,\n \"23\": \"JS_IF_STATEMENT\",\n \"JS_ASSIGNMENT_EXPRESSION\": 24,\n \"24\": \"JS_ASSIGNMENT_EXPRESSION\",\n \"JS_SEQUENCE_EXPRESSION\": 25,\n \"25\": \"JS_SEQUENCE_EXPRESSION\",\n \"JS_RETURN_STATEMENT\": 26,\n \"26\": \"JS_RETURN_STATEMENT\"\n};\nconst ElementTypes = {\n \"ELEMENT\": 0,\n \"0\": \"ELEMENT\",\n \"COMPONENT\": 1,\n \"1\": \"COMPONENT\",\n \"SLOT\": 2,\n \"2\": \"SLOT\",\n \"TEMPLATE\": 3,\n \"3\": \"TEMPLATE\"\n};\nconst ConstantTypes = {\n \"NOT_CONSTANT\": 0,\n \"0\": \"NOT_CONSTANT\",\n \"CAN_SKIP_PATCH\": 1,\n \"1\": \"CAN_SKIP_PATCH\",\n \"CAN_CACHE\": 2,\n \"2\": \"CAN_CACHE\",\n \"CAN_STRINGIFY\": 3,\n \"3\": \"CAN_STRINGIFY\"\n};\nconst locStub = {\n start: { line: 1, column: 1, offset: 0 },\n end: { line: 1, column: 1, offset: 0 },\n source: \"\"\n};\nfunction createRoot(children, source = \"\") {\n return {\n type: 0,\n source,\n children,\n helpers: /* @__PURE__ */ new Set(),\n components: [],\n directives: [],\n hoists: [],\n imports: [],\n cached: [],\n temps: 0,\n codegenNode: void 0,\n loc: locStub\n };\n}\nfunction createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {\n if (context) {\n if (isBlock) {\n context.helper(OPEN_BLOCK);\n context.helper(getVNodeBlockHelper(context.inSSR, isComponent));\n } else {\n context.helper(getVNodeHelper(context.inSSR, isComponent));\n }\n if (directives) {\n context.helper(WITH_DIRECTIVES);\n }\n }\n return {\n type: 13,\n tag,\n props,\n children,\n patchFlag,\n dynamicProps,\n directives,\n isBlock,\n disableTracking,\n isComponent,\n loc\n };\n}\nfunction createArrayExpression(elements, loc = locStub) {\n return {\n type: 17,\n loc,\n elements\n };\n}\nfunction createObjectExpression(properties, loc = locStub) {\n return {\n type: 15,\n loc,\n properties\n };\n}\nfunction createObjectProperty(key, value) {\n return {\n type: 16,\n loc: locStub,\n key: shared.isString(key) ? createSimpleExpression(key, true) : key,\n value\n };\n}\nfunction createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {\n return {\n type: 4,\n loc,\n content,\n isStatic,\n constType: isStatic ? 3 : constType\n };\n}\nfunction createInterpolation(content, loc) {\n return {\n type: 5,\n loc,\n content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content\n };\n}\nfunction createCompoundExpression(children, loc = locStub) {\n return {\n type: 8,\n loc,\n children\n };\n}\nfunction createCallExpression(callee, args = [], loc = locStub) {\n return {\n type: 14,\n loc,\n callee,\n arguments: args\n };\n}\nfunction createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {\n return {\n type: 18,\n params,\n returns,\n newline,\n isSlot,\n loc\n };\n}\nfunction createConditionalExpression(test, consequent, alternate, newline = true) {\n return {\n type: 19,\n test,\n consequent,\n alternate,\n newline,\n loc: locStub\n };\n}\nfunction createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {\n return {\n type: 20,\n index,\n value,\n needPauseTracking,\n inVOnce,\n needArraySpread: false,\n loc: locStub\n };\n}\nfunction createBlockStatement(body) {\n return {\n type: 21,\n body,\n loc: locStub\n };\n}\nfunction createTemplateLiteral(elements) {\n return {\n type: 22,\n elements,\n loc: locStub\n };\n}\nfunction createIfStatement(test, consequent, alternate) {\n return {\n type: 23,\n test,\n consequent,\n alternate,\n loc: locStub\n };\n}\nfunction createAssignmentExpression(left, right) {\n return {\n type: 24,\n left,\n right,\n loc: locStub\n };\n}\nfunction createSequenceExpression(expressions) {\n return {\n type: 25,\n expressions,\n loc: locStub\n };\n}\nfunction createReturnStatement(returns) {\n return {\n type: 26,\n returns,\n loc: locStub\n };\n}\nfunction getVNodeHelper(ssr, isComponent) {\n return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;\n}\nfunction getVNodeBlockHelper(ssr, isComponent) {\n return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;\n}\nfunction convertToBlock(node, { helper, removeHelper, inSSR }) {\n if (!node.isBlock) {\n node.isBlock = true;\n removeHelper(getVNodeHelper(inSSR, node.isComponent));\n helper(OPEN_BLOCK);\n helper(getVNodeBlockHelper(inSSR, node.isComponent));\n }\n}\n\nconst defaultDelimitersOpen = new Uint8Array([123, 123]);\nconst defaultDelimitersClose = new Uint8Array([125, 125]);\nfunction isTagStartChar(c) {\n return c >= 97 && c <= 122 || c >= 65 && c <= 90;\n}\nfunction isWhitespace(c) {\n return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;\n}\nfunction isEndOfTagSection(c) {\n return c === 47 || c === 62 || isWhitespace(c);\n}\nfunction toCharCodes(str) {\n const ret = new Uint8Array(str.length);\n for (let i = 0; i < str.length; i++) {\n ret[i] = str.charCodeAt(i);\n }\n return ret;\n}\nconst Sequences = {\n Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),\n // CDATA[\n CdataEnd: new Uint8Array([93, 93, 62]),\n // ]]>\n CommentEnd: new Uint8Array([45, 45, 62]),\n // `-->`\n ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),\n // `<\\/script`\n StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),\n // `</style`\n TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),\n // `</title`\n TextareaEnd: new Uint8Array([\n 60,\n 47,\n 116,\n 101,\n 120,\n 116,\n 97,\n 114,\n 101,\n 97\n ])\n // `</textarea\n};\nclass Tokenizer {\n constructor(stack, cbs) {\n this.stack = stack;\n this.cbs = cbs;\n /** The current state the tokenizer is in. */\n this.state = 1;\n /** The read buffer. */\n this.buffer = \"\";\n /** The beginning of the section that is currently being read. */\n this.sectionStart = 0;\n /** The index within the buffer that we are currently looking at. */\n this.index = 0;\n /** The start of the last entity. */\n this.entityStart = 0;\n /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */\n this.baseState = 1;\n /** For special parsing behavior inside of script and style tags. */\n this.inRCDATA = false;\n /** For disabling RCDATA tags handling */\n this.inXML = false;\n /** For disabling interpolation parsing in v-pre */\n this.inVPre = false;\n /** Record newline positions for fast line / column calculation */\n this.newlines = [];\n this.mode = 0;\n this.delimiterOpen = defaultDelimitersOpen;\n this.delimiterClose = defaultDelimitersClose;\n this.delimiterIndex = -1;\n this.currentSequence = void 0;\n this.sequenceIndex = 0;\n {\n this.entityDecoder = new decode.EntityDecoder(\n decode.htmlDecodeTree,\n (cp, consumed) => this.emitCodePoint(cp, consumed)\n );\n }\n }\n get inSFCRoot() {\n return this.mode === 2 && this.stack.length === 0;\n }\n reset() {\n this.state = 1;\n this.mode = 0;\n this.buffer = \"\";\n this.sectionStart = 0;\n this.index = 0;\n this.baseState = 1;\n this.inRCDATA = false;\n this.currentSequence = void 0;\n this.newlines.length = 0;\n this.delimiterOpen = defaultDelimitersOpen;\n this.delimiterClose = defaultDelimitersClose;\n }\n /**\n * Generate Position object with line / column information using recorded\n * newline positions. We know the index is always going to be an already\n * processed index, so all the newlines up to this index should have been\n * recorded.\n */\n getPos(index) {\n let line = 1;\n let column = index + 1;\n const length = this.newlines.length;\n let j = -1;\n if (length > 100) {\n let l = -1;\n let r = length;\n while (l + 1 < r) {\n const m = l + r >>> 1;\n this.newlines[m] < index ? l = m : r = m;\n }\n j = l;\n } else {\n for (let i = length - 1; i >= 0; i--) {\n if (index > this.newlines[i]) {\n j = i;\n break;\n }\n }\n }\n if (j >= 0) {\n line = j + 2;\n column = index - this.newlines[j];\n }\n return {\n column,\n line,\n offset: index\n };\n }\n peek() {\n return this.buffer.charCodeAt(this.index + 1);\n }\n stateText(c) {\n if (c === 60) {\n if (this.index > this.sectionStart) {\n this.cbs.ontext(this.sectionStart, this.index);\n }\n this.state = 5;\n this.sectionStart = this.index;\n } else if (c === 38) {\n this.startEntity();\n } else if (!this.inVPre && c === this.delimiterOpen[0]) {\n this.state = 2;\n this.delimiterIndex = 0;\n this.stateInterpolationOpen(c);\n }\n }\n stateInterpolationOpen(c) {\n if (c === this.delimiterOpen[this.delimiterIndex]) {\n if (this.delimiterIndex === this.delimiterOpen.length - 1) {\n const start = this.index + 1 - this.delimiterOpen.length;\n if (start > this.sectionStart) {\n this.cbs.ontext(this.sectionStart, start);\n }\n this.state = 3;\n this.sectionStart = start;\n } else {\n this.delimiterIndex++;\n }\n } else if (this.inRCDATA) {\n this.state = 32;\n this.stateInRCDATA(c);\n } else {\n this.state = 1;\n this.stateText(c);\n }\n }\n stateInterpolation(c) {\n if (c === this.delimiterClose[0]) {\n this.state = 4;\n this.delimiterIndex = 0;\n this.stateInterpolationClose(c);\n }\n }\n stateInterpolationClose(c) {\n if (c === this.delimiterClose[this.delimiterIndex]) {\n if (this.delimiterIndex === this.delimiterClose.length - 1) {\n this.cbs.oninterpolation(this.sectionStart, this.index + 1);\n if (this.inRCDATA) {\n this.state = 32;\n } else {\n this.state = 1;\n }\n this.sectionStart = this.index + 1;\n } else {\n this.delimiterIndex++;\n }\n } else {\n this.state = 3;\n this.stateInterpolation(c);\n }\n }\n stateSpecialStartSequence(c) {\n const isEnd = this.sequenceIndex === this.currentSequence.length;\n const isMatch = isEnd ? (\n // If we are at the end of the sequence, make sure the tag name has ended\n isEndOfTagSection(c)\n ) : (\n // Otherwise, do a case-insensitive comparison\n (c | 32) === this.currentSequence[this.sequenceIndex]\n );\n if (!isMatch) {\n this.inRCDATA = false;\n } else if (!isEnd) {\n this.sequenceIndex++;\n return;\n }\n this.sequenceIndex = 0;\n this.state = 6;\n this.stateInTagName(c);\n }\n /** Look for an end tag. For <title> and <textarea>, also decode entities. */\n stateInRCDATA(c) {\n if (this.sequenceIndex === this.currentSequence.length) {\n if (c === 62 || isWhitespace(c)) {\n const endOfText = this.index - this.currentSequence.length;\n if (this.sectionStart < endOfText) {\n const actualIndex = this.index;\n this.index = endOfText;\n this.cbs.ontext(this.sectionStart, endOfText);\n this.index = actualIndex;\n }\n this.sectionStart = endOfText + 2;\n this.stateInClosingTagName(c);\n this.inRCDATA = false;\n return;\n }\n this.sequenceIndex = 0;\n }\n if ((c | 32) === this.currentSequence[this.sequenceIndex]) {\n this.sequenceIndex += 1;\n } else if (this.sequenceIndex === 0) {\n if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {\n if (c === 38) {\n this.startEntity();\n } else if (!this.inVPre && c === this.delimiterOpen[0]) {\n this.state = 2;\n this.delimiterIndex = 0;\n this.stateInterpolationOpen(c);\n }\n } else if (this.fastForwardTo(60)) {\n this.sequenceIndex = 1;\n }\n } else {\n this.sequenceIndex = Number(c === 60);\n }\n }\n stateCDATASequence(c) {\n if (c === Sequences.Cdata[this.sequenceIndex]) {\n if (++this.sequenceIndex === Sequences.Cdata.length) {\n this.state = 28;\n this.currentSequence = Sequences.CdataEnd;\n this.sequenceIndex = 0;\n this.sectionStart = this.index + 1;\n }\n } else {\n this.sequenceIndex = 0;\n this.state = 23;\n this.stateInDeclaration(c);\n }\n }\n /**\n * When we wait for one specific character, we can speed things up\n * by skipping through the buffer until we find it.\n *\n * @returns Whether the character was found.\n */\n fastForwardTo(c) {\n while (++this.index < this.buffer.length) {\n const cc = this.buffer.charCodeAt(this.index);\n if (cc === 10) {\n this.newlines.push(this.index);\n }\n if (cc === c) {\n return true;\n }\n }\n this.index = this.buffer.length - 1;\n return false;\n }\n /**\n * Comments and CDATA end with `-->` and `]]>`.\n *\n * Their common qualities are:\n * - Their end sequences have a distinct character they start with.\n * - That character is then repeated, so we have to check multiple repeats.\n * - All characters but the start character of the sequence can be skipped.\n */\n stateInCommentLike(c) {\n if (c === this.currentSequence[this.sequenceIndex]) {\n if (++this.sequenceIndex === this.currentSequence.length) {\n if (this.currentSequence === Sequences.CdataEnd) {\n this.cbs.oncdata(this.sectionStart, this.index - 2);\n } else {\n this.cbs.oncomment(this.sectionStart, this.index - 2);\n }\n this.sequenceIndex = 0;\n this.sectionStart = this.index + 1;\n this.state = 1;\n }\n } else if (this.sequenceIndex === 0) {\n if (this.fastForwardTo(this.currentSequence[0])) {\n this.sequenceIndex = 1;\n }\n } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {\n this.sequenceIndex = 0;\n }\n }\n startSpecial(sequence, offset) {\n this.enterRCDATA(sequence, offset);\n this.state = 31;\n }\n enterRCDATA(sequence, offset) {\n this.inRCDATA = true;\n this.currentSequence = sequence;\n this.sequenceIndex = offset;\n }\n stateBeforeTagName(c) {\n if (c === 33) {\n this.state = 22;\n this.sectionStart = this.index + 1;\n } else if (c === 63) {\n this.state = 24;\n this.sectionStart = this.index + 1;\n } else if (isTagStartChar(c)) {\n this.sectionStart = this.index;\n if (this.mode === 0) {\n this.state = 6;\n } else if (this.inSFCRoot) {\n this.state = 34;\n } else if (!this.inXML) {\n if (c === 116) {\n this.state = 30;\n } else {\n this.state = c === 115 ? 29 : 6;\n }\n } else {\n this.state = 6;\n }\n } else if (c === 47) {\n this.state = 8;\n } else {\n this.state = 1;\n this.stateText(c);\n }\n }\n stateInTagName(c) {\n if (isEndOfTagSection(c)) {\n this.handleTagName(c);\n }\n }\n stateInSFCRootTagName(c) {\n if (isEndOfTagSection(c)) {\n const tag = this.buffer.slice(this.sectionStart, this.index);\n if (tag !== \"template\") {\n this.enterRCDATA(toCharCodes(`</` + tag), 0);\n }\n this.handleTagName(c);\n }\n }\n handleTagName(c) {\n this.cbs.onopentagname(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.state = 11;\n this.stateBeforeAttrName(c);\n }\n stateBeforeClosingTagName(c) {\n if (isWhitespace(c)) ; else if (c === 62) {\n {\n this.cbs.onerr(14, this.index);\n }\n this.state = 1;\n this.sectionStart = this.index + 1;\n } else {\n this.state = isTagStartChar(c) ? 9 : 27;\n this.sectionStart = this.index;\n }\n }\n stateInClosingTagName(c) {\n if (c === 62 || isWhitespace(c)) {\n this.cbs.onclosetag(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.state = 10;\n this.stateAfterClosingTagName(c);\n }\n }\n stateAfterClosingTagName(c) {\n if (c === 62) {\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeAttrName(c) {\n if (c === 62) {\n this.cbs.onopentagend(this.index);\n if (this.inRCDATA) {\n this.state = 32;\n } else {\n this.state = 1;\n }\n this.sectionStart = this.index + 1;\n } else if (c === 47) {\n this.state = 7;\n if (this.peek() !== 62) {\n this.cbs.onerr(22, this.index);\n }\n } else if (c === 60 && this.peek() === 47) {\n this.cbs.onopentagend(this.index);\n this.state = 5;\n this.sectionStart = this.index;\n } else if (!isWhitespace(c)) {\n if (c === 61) {\n this.cbs.onerr(\n 19,\n this.index\n );\n }\n this.handleAttrStart(c);\n }\n }\n handleAttrStart(c) {\n if (c === 118 && this.peek() === 45) {\n this.state = 13;\n this.sectionStart = this.index;\n } else if (c === 46 || c === 58 || c === 64 || c === 35) {\n this.cbs.ondirname(this.index, this.index + 1);\n this.state = 14;\n this.sectionStart = this.index + 1;\n } else {\n this.state = 12;\n this.sectionStart = this.index;\n }\n }\n stateInSelfClosingTag(c) {\n if (c === 62) {\n this.cbs.onselfclosingtag(this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n this.inRCDATA = false;\n } else if (!isWhitespace(c)) {\n this.state = 11;\n this.stateBeforeAttrName(c);\n }\n }\n stateInAttrName(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.onattribname(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 34 || c === 39 || c === 60) {\n this.cbs.onerr(\n 17,\n this.index\n );\n }\n }\n stateInDirName(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 58) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.state = 14;\n this.sectionStart = this.index + 1;\n } else if (c === 46) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.state = 16;\n this.sectionStart = this.index + 1;\n }\n }\n stateInDirArg(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirarg(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 91) {\n this.state = 15;\n } else if (c === 46) {\n this.cbs.ondirarg(this.sectionStart, this.index);\n this.state = 16;\n this.sectionStart = this.index + 1;\n }\n }\n stateInDynamicDirArg(c) {\n if (c === 93) {\n this.state = 14;\n } else if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirarg(this.sectionStart, this.index + 1);\n this.handleAttrNameEnd(c);\n {\n this.cbs.onerr(\n 27,\n this.index\n );\n }\n }\n }\n stateInDirModifier(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirmodifier(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 46) {\n this.cbs.ondirmodifier(this.sectionStart, this.index);\n this.sectionStart = this.index + 1;\n }\n }\n handleAttrNameEnd(c) {\n this.sectionStart = this.index;\n this.state = 17;\n this.cbs.onattribnameend(this.index);\n this.stateAfterAttrName(c);\n }\n stateAfterAttrName(c) {\n if (c === 61) {\n this.state = 18;\n } else if (c === 47 || c === 62) {\n this.cbs.onattribend(0, this.sectionStart);\n this.sectionStart = -1;\n this.state = 11;\n this.stateBeforeAttrName(c);\n } else if (!isWhitespace(c)) {\n this.cbs.onattribend(0, this.sectionStart);\n this.handleAttrStart(c);\n }\n }\n stateBeforeAttrValue(c) {\n if (c === 34) {\n this.state = 19;\n this.sectionStart = this.index + 1;\n } else if (c === 39) {\n this.state = 20;\n this.sectionStart = this.index + 1;\n } else if (!isWhitespace(c)) {\n this.sectionStart = this.index;\n this.state = 21;\n this.stateInAttrValueNoQuotes(c);\n }\n }\n handleInAttrValue(c, quote) {\n if (c === quote || false) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.cbs.onattribend(\n quote === 34 ? 3 : 2,\n this.index + 1\n );\n this.state = 11;\n } else if (c === 38) {\n this.startEntity();\n }\n }\n stateInAttrValueDoubleQuotes(c) {\n this.handleInAttrValue(c, 34);\n }\n stateInAttrValueSingleQuotes(c) {\n this.handleInAttrValue(c, 39);\n }\n stateInAttrValueNoQuotes(c) {\n if (isWhitespace(c) || c === 62) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.cbs.onattribend(1, this.index);\n this.state = 11;\n this.stateBeforeAttrName(c);\n } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {\n this.cbs.onerr(\n 18,\n this.index\n );\n } else if (c === 38) {\n this.startEntity();\n }\n }\n stateBeforeDeclaration(c) {\n if (c === 91) {\n this.state = 26;\n this.sequenceIndex = 0;\n } else {\n this.state = c === 45 ? 25 : 23;\n }\n }\n stateInDeclaration(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateInProcessingInstruction(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.cbs.onprocessinginstruction(this.sectionStart, this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeComment(c) {\n if (c === 45) {\n this.state = 28;\n this.currentSequence = Sequences.CommentEnd;\n this.sequenceIndex = 2;\n this.sectionStart = this.index + 1;\n } else {\n this.state = 23;\n }\n }\n stateInSpecialComment(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.cbs.oncomment(this.sectionStart, this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeSpecialS(c) {\n if (c === Sequences.ScriptEnd[3]) {\n this.startSpecial(Sequences.ScriptEnd, 4);\n } else if (c === Sequences.StyleEnd[3]) {\n this.startSpecial(Sequences.StyleEnd, 4);\n } else {\n this.state = 6;\n this.stateInTagName(c);\n }\n }\n stateBeforeSpecialT(c) {\n if (c === Sequences.TitleEnd[3]) {\n this.startSpecial(Sequences.TitleEnd, 4);\n } else if (c === Sequences.TextareaEnd[3]) {\n this.startSpecial(Sequences.TextareaEnd, 4);\n } else {\n this.state = 6;\n this.stateInTagName(c);\n }\n }\n startEntity() {\n {\n this.baseState = this.state;\n this.state = 33;\n this.entityStart = this.index;\n this.entityDecoder.startEntity(\n this.baseState === 1 || this.baseState === 32 ? decode.DecodingMode.Legacy : decode.DecodingMode.Attribute\n );\n }\n }\n stateInEntity() {\n {\n const length = this.entityDecoder.write(this.buffer, this.index);\n if (length >= 0) {\n this.state = this.baseState;\n if (length === 0) {\n this.index = this.entityStart;\n }\n } else {\n this.index = this.buffer.length - 1;\n }\n }\n }\n /**\n * Iterates through the buffer, calling the function corresponding to the current state.\n *\n * States that are more likely to be hit are higher up, as a performance improvement.\n */\n parse(input) {\n this.buffer = input;\n while (this.index < this.buffer.length) {\n const c = this.buffer.charCodeAt(this.index);\n if (c === 10 && this.state !== 33) {\n this.newlines.push(this.index);\n }\n switch (this.state) {\n case 1: {\n this.stateText(c);\n break;\n }\n case 2: {\n this.stateInterpolationOpen(c);\n break;\n }\n case 3: {\n this.stateInterpolation(c);\n break;\n }\n case 4: {\n this.stateInterpolationClose(c);\n break;\n }\n case 31: {\n this.stateSpecialStartSequence(c);\n break;\n }\n case 32: {\n this.stateInRCDATA(c);\n break;\n }\n case 26: {\n this.stateCDATASequence(c);\n break;\n }\n case 19: {\n this.stateInAttrValueDoubleQuotes(c);\n break;\n }\n case 12: {\n this.stateInAttrName(c);\n break;\n }\n case 13: {\n this.stateInDirName(c);\n break;\n }\n case 14: {\n this.stateInDirArg(c);\n break;\n }\n case 15: {\n this.stateInDynamicDirArg(c);\n break;\n }\n case 16: {\n this.stateInDirModifier(c);\n break;\n }\n case 28: {\n this.stateInCommentLike(c);\n break;\n }\n case 27: {\n this.stateInSpecialComment(c);\n break;\n }\n case 11: {\n this.stateBeforeAttrName(c);\n break;\n }\n case 6: {\n this.stateInTagName(c);\n break;\n }\n case 34: {\n this.stateInSFCRootTagName(c);\n break;\n }\n case 9: {\n this.stateInClosingTagName(c);\n break;\n }\n case 5: {\n this.stateBeforeTagName(c);\n break;\n }\n case 17: {\n this.stateAfterAttrName(c);\n break;\n }\n case 20: {\n this.stateInAttrValueSingleQuotes(c);\n break;\n }\n case 18: {\n this.stateBeforeAttrValue(c);\n break;\n }\n case 8: {\n this.stateBeforeClosingTagName(c);\n break;\n }\n case 10: {\n this.stateAfterClosingTagName(c);\n break;\n }\n case 29: {\n this.stateBeforeSpecialS(c);\n break;\n }\n case 30: {\n this.stateBeforeSpecialT(c);\n break;\n }\n case 21: {\n this.stateInAttrValueNoQuotes(c);\n break;\n }\n case 7: {\n this.stateInSelfClosingTag(c);\n break;\n }\n case 23: {\n this.stateInDeclaration(c);\n break;\n }\n case 22: {\n this.stateBeforeDeclaration(c);\n break;\n }\n case 25: {\n this.stateBeforeComment(c);\n break;\n }\n case 24: {\n this.stateInProcessingInstruction(c);\n break;\n }\n case 33: {\n this.stateInEntity();\n break;\n }\n }\n this.index++;\n }\n this.cleanup();\n this.finish();\n }\n /**\n * Remove data that has already been consumed from the buffer.\n */\n cleanup() {\n if (this.sectionStart !== this.index) {\n if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {\n this.cbs.ontext(this.sectionStart, this.index);\n this.sectionStart = this.index;\n } else if (this.state === 19 || this.state === 20 || this.state === 21) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = this.index;\n }\n }\n }\n finish() {\n if (this.state === 33) {\n this.entityDecoder.end();\n this.state = this.baseState;\n }\n this.handleTrailingData();\n this.cbs.onend();\n }\n /** Handle any trailing data. */\n handleTrailingData() {\n const endIndex = this.buffer.length;\n if (this.sectionStart >= endIndex) {\n return;\n }\n if (this.state === 28) {\n if (this.currentSequence === Sequences.CdataEnd) {\n this.cbs.oncdata(this.sectionStart, endIndex);\n } else {\n this.cbs.oncomment(this.sectionStart, endIndex);\n }\n } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {\n this.cbs.ontext(this.sectionStart, endIndex);\n }\n }\n emitCodePoint(cp, consumed) {\n {\n if (this.baseState !== 1 && this.baseState !== 32) {\n if (this.sectionStart < this.entityStart) {\n this.cbs.onattribdata(this.sectionStart, this.entityStart);\n }\n this.sectionStart = this.entityStart + consumed;\n this.index = this.sectionStart - 1;\n this.cbs.onattribentity(\n decode.fromCodePoint(cp),\n this.entityStart,\n this.sectionStart\n );\n } else {\n if (this.sectionStart < this.entityStart) {\n this.cbs.ontext(this.sectionStart, this.entityStart);\n }\n this.sectionStart = this.entityStart + consumed;\n this.index = this.sectionStart - 1;\n this.cbs.ontextentity(\n decode.fromCodePoint(cp),\n this.entityStart,\n this.sectionStart\n );\n }\n }\n }\n}\n\nconst CompilerDeprecationTypes = {\n \"COMPILER_IS_ON_ELEMENT\": \"COMPILER_IS_ON_ELEMENT\",\n \"COMPILER_V_BIND_SYNC\": \"COMPILER_V_BIND_SYNC\",\n \"COMPILER_V_BIND_OBJECT_ORDER\": \"COMPILER_V_BIND_OBJECT_ORDER\",\n \"COMPILER_V_ON_NATIVE\": \"COMPILER_V_ON_NATIVE\",\n \"COMPILER_V_IF_V_FOR_PRECEDENCE\": \"COMPILER_V_IF_V_FOR_PRECEDENCE\",\n \"COMPILER_NATIVE_TEMPLATE\": \"COMPILER_NATIVE_TEMPLATE\",\n \"COMPILER_INLINE_TEMPLATE\": \"COMPILER_INLINE_TEMPLATE\",\n \"COMPILER_FILTERS\": \"COMPILER_FILTERS\"\n};\nconst deprecationData = {\n [\"COMPILER_IS_ON_ELEMENT\"]: {\n message: `Platform-native elements with \"is\" prop will no longer be treated as components in Vue 3 unless the \"is\" value is explicitly prefixed with \"vue:\".`,\n link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`\n },\n [\"COMPILER_V_BIND_SYNC\"]: {\n message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \\`v-bind:${key}.sync\\` should be changed to \\`v-model:${key}\\`.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`\n },\n [\"COMPILER_V_BIND_OBJECT_ORDER\"]: {\n message: `v-bind=\"obj\" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`\n },\n [\"COMPILER_V_ON_NATIVE\"]: {\n message: `.native modifier for v-on has been removed as is no longer necessary.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`\n },\n [\"COMPILER_V_IF_V_FOR_PRECEDENCE\"]: {\n message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`\n },\n [\"COMPILER_NATIVE_TEMPLATE\"]: {\n message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`\n },\n [\"COMPILER_INLINE_TEMPLATE\"]: {\n message: `\"inline-template\" has been removed in Vue 3.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`\n },\n [\"COMPILER_FILTERS\"]: {\n message: `filters have been removed in Vue 3. The \"|\" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`\n }\n};\nfunction getCompatValue(key, { compatConfig }) {\n const value = compatConfig && compatConfig[key];\n if (key === \"MODE\") {\n return value || 3;\n } else {\n return value;\n }\n}\nfunction isCompatEnabled(key, context) {\n const mode = getCompatValue(\"MODE\", context);\n const value = getCompatValue(key, context);\n return mode === 3 ? value === true : value !== false;\n}\nfunction checkCompatEnabled(key, context, loc, ...args) {\n const enabled = isCompatEnabled(key, context);\n return enabled;\n}\nfunction warnDeprecation(key, context, loc, ...args) {\n const val = getCompatValue(key, context);\n if (val === \"suppress-warning\") {\n return;\n }\n const { message, link } = deprecationData[key];\n const msg = `(deprecation ${key}) ${typeof message === \"function\" ? message(...args) : message}${link ? `\n Details: ${link}` : ``}`;\n const err = new SyntaxError(msg);\n err.code = key;\n if (loc) err.loc = loc;\n context.onWarn(err);\n}\n\nfunction defaultOnError(error) {\n throw error;\n}\nfunction defaultOnWarn(msg) {\n}\nfunction createCompilerError(code, loc, messages, additionalMessage) {\n const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;\n const error = new SyntaxError(String(msg));\n error.code = code;\n error.loc = loc;\n return error;\n}\nconst ErrorCodes = {\n \"ABRUPT_CLOSING_OF_EMPTY_COMMENT\": 0,\n \"0\": \"ABRUPT_CLOSING_OF_EMPTY_COMMENT\",\n \"CDATA_IN_HTML_CONTENT\": 1,\n \"1\": \"CDATA_IN_HTML_CONTENT\",\n \"DUPLICATE_ATTRIBUTE\": 2,\n \"2\": \"DUPLICATE_ATTRIBUTE\",\n \"END_TAG_WITH_ATTRIBUTES\": 3,\n \"3\": \"END_TAG_WITH_ATTRIBUTES\",\n \"END_TAG_WITH_TRAILING_SOLIDUS\": 4,\n \"4\": \"END_TAG_WITH_TRAILING_SOLIDUS\",\n \"EOF_BEFORE_TAG_NAME\": 5,\n \"5\": \"EOF_BEFORE_TAG_NAME\",\n \"EOF_IN_CDATA\": 6,\n \"6\": \"EOF_IN_CDATA\",\n \"EOF_IN_COMMENT\": 7,\n \"7\": \"EOF_IN_COMMENT\",\n \"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT\": 8,\n \"8\": \"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT\",\n \"EOF_IN_TAG\": 9,\n \"9\": \"EOF_IN_TAG\",\n \"INCORRECTLY_CLOSED_COMMENT\": 10,\n \"10\": \"INCORRECTLY_CLOSED_COMMENT\",\n \"INCORRECTLY_OPENED_COMMENT\": 11,\n \"11\": \"INCORRECTLY_OPENED_COMMENT\",\n \"INVALID_FIRST_CHARACTER_OF_TAG_NAME\": 12,\n \"12\": \"INVALID_FIRST_CHARACTER_OF_TAG_NAME\",\n \"MISSING_ATTRIBUTE_VALUE\": 13,\n \"13\": \"MISSING_ATTRIBUTE_VALUE\",\n \"MISSING_END_TAG_NAME\": 14,\n \"14\": \"MISSING_END_TAG_NAME\",\n \"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES\": 15,\n \"15\": \"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES\",\n \"NESTED_COMMENT\": 16,\n \"16\": \"NESTED_COMMENT\",\n \"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME\": 17,\n \"17\": \"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME\",\n \"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE\": 18,\n \"18\": \"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE\",\n \"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME\": 19,\n \"19\": \"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME\",\n \"UNEXPECTED_NULL_CHARACTER\": 20,\n \"20\": \"UNEXPECTED_NULL_CHARACTER\",\n \"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME\": 21,\n \"21\": \"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME\",\n \"UNEXPECTED_SOLIDUS_IN_TAG\": 22,\n \"22\": \"UNEXPECTED_SOLIDUS_IN_TAG\",\n \"X_INVALID_END_TAG\": 23,\n \"23\": \"X_INVALID_END_TAG\",\n \"X_MISSING_END_TAG\": 24,\n \"24\": \"X_MISSING_END_TAG\",\n \"X_MISSING_INTERPOLATION_END\": 25,\n \"25\": \"X_MISSING_INTERPOLATION_END\",\n \"X_MISSING_DIRECTIVE_NAME\": 26,\n \"26\": \"X_MISSING_DIRECTIVE_NAME\",\n \"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END\": 27,\n \"27\": \"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END\",\n \"X_V_IF_NO_EXPRESSION\": 28,\n \"28\": \"X_V_IF_NO_EXPRESSION\",\n \"X_V_IF_SAME_KEY\": 29,\n \"29\": \"X_V_IF_SAME_KEY\",\n \"X_V_ELSE_NO_ADJACENT_IF\": 30,\n \"30\": \"X_V_ELSE_NO_ADJACENT_IF\",\n \"X_V_FOR_NO_EXPRESSION\": 31,\n \"31\": \"X_V_FOR_NO_EXPRESSION\",\n \"X_V_FOR_MALFORMED_EXPRESSION\": 32,\n \"32\": \"X_V_FOR_MALFORMED_EXPRESSION\",\n \"X_V_FOR_TEMPLATE_KEY_PLACEMENT\": 33,\n \"33\": \"X_V_FOR_TEMPLATE_KEY_PLACEMENT\",\n \"X_V_BIND_NO_EXPRESSION\": 34,\n \"34\": \"X_V_BIND_NO_EXPRESSION\",\n \"X_V_ON_NO_EXPRESSION\": 35,\n \"35\": \"X_V_ON_NO_EXPRESSION\",\n \"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET\": 36,\n \"36\": \"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET\",\n \"X_V_SLOT_MIXED_SLOT_USAGE\": 37,\n \"37\": \"X_V_SLOT_MIXED_SLOT_USAGE\",\n \"X_V_SLOT_DUPLICATE_SLOT_NAMES\": 38,\n \"38\": \"X_V_SLOT_DUPLICATE_SLOT_NAMES\",\n \"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN\": 39,\n \"39\": \"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN\",\n \"X_V_SLOT_MISPLACED\": 40,\n \"40\": \"X_V_SLOT_MISPLACED\",\n \"X_V_MODEL_NO_EXPRESSION\": 41,\n \"41\": \"X_V_MODEL_NO_EXPRESSION\",\n \"X_V_MODEL_MALFORMED_EXPRESSION\": 42,\n \"42\": \"X_V_MODEL_MALFORMED_EXPRESSION\",\n \"X_V_MODEL_ON_SCOPE_VARIABLE\": 43,\n \"43\": \"X_V_MODEL_ON_SCOPE_VARIABLE\",\n \"X_V_MODEL_ON_PROPS\": 44,\n \"44\": \"X_V_MODEL_ON_PROPS\",\n \"X_V_MODEL_ON_CONST\": 45,\n \"45\": \"X_V_MODEL_ON_CONST\",\n \"X_INVALID_EXPRESSION\": 46,\n \"46\": \"X_INVALID_EXPRESSION\",\n \"X_KEEP_ALIVE_INVALID_CHILDREN\": 47,\n \"47\": \"X_KEEP_ALIVE_INVALID_CHILDREN\",\n \"X_PREFIX_ID_NOT_SUPPORTED\": 48,\n \"48\": \"X_PREFIX_ID_NOT_SUPPORTED\",\n \"X_MODULE_MODE_NOT_SUPPORTED\": 49,\n \"49\": \"X_MODULE_MODE_NOT_SUPPORTED\",\n \"X_CACHE_HANDLER_NOT_SUPPORTED\": 50,\n \"50\": \"X_CACHE_HANDLER_NOT_SUPPORTED\",\n \"X_SCOPE_ID_NOT_SUPPORTED\": 51,\n \"51\": \"X_SCOPE_ID_NOT_SUPPORTED\",\n \"X_VNODE_HOOKS\": 52,\n \"52\": \"X_VNODE_HOOKS\",\n \"X_V_BIND_INVALID_SAME_NAME_ARGUMENT\": 53,\n \"53\": \"X_V_BIND_INVALID_SAME_NAME_ARGUMENT\",\n \"__EXTEND_POINT__\": 54,\n \"54\": \"__EXTEND_POINT__\"\n};\nconst errorMessages = {\n // parse errors\n [0]: \"Illegal comment.\",\n [1]: \"CDATA section is allowed only in XML context.\",\n [2]: \"Duplicate attribute.\",\n [3]: \"End tag cannot have attributes.\",\n [4]: \"Illegal '/' in tags.\",\n [5]: \"Unexpected EOF in tag.\",\n [6]: \"Unexpected EOF in CDATA section.\",\n [7]: \"Unexpected EOF in comment.\",\n [8]: \"Unexpected EOF in script.\",\n [9]: \"Unexpected EOF in tag.\",\n [10]: \"Incorrectly closed comment.\",\n [11]: \"Incorrectly opened comment.\",\n [12]: \"Illegal tag name. Use '<' to print '<'.\",\n [13]: \"Attribute value was expected.\",\n [14]: \"End tag name was expected.\",\n [15]: \"Whitespace was expected.\",\n [16]: \"Unexpected '<!--' in comment.\",\n [17]: `Attribute name cannot contain U+0022 (\"), U+0027 ('), and U+003C (<).`,\n [18]: \"Unquoted attribute value cannot contain U+0022 (\\\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).\",\n [19]: \"Attribute name cannot start with '='.\",\n [21]: \"'<?' is allowed only in XML context.\",\n [20]: `Unexpected null character.`,\n [22]: \"Illegal '/' in tags.\",\n // Vue-specific parse errors\n [23]: \"Invalid end tag.\",\n [24]: \"Element is missing end tag.\",\n [25]: \"Interpolation end sign was not found.\",\n [27]: \"End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.\",\n [26]: \"Legal directive name was expected.\",\n // transform errors\n [28]: `v-if/v-else-if is missing expression.`,\n [29]: `v-if/else branches must use unique keys.`,\n [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,\n [31]: `v-for is missing expression.`,\n [32]: `v-for has invalid expression.`,\n [33]: `<template v-for> key should be placed on the <template> tag.`,\n [34]: `v-bind is missing expression.`,\n [53]: `v-bind with same-name shorthand only allows static argument.`,\n [35]: `v-on is missing expression.`,\n [36]: `Unexpected custom directive on <slot> outlet.`,\n [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,\n [38]: `Duplicate slot names found. `,\n [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,\n [40]: `v-slot can only be used on components or <template> tags.`,\n [41]: `v-model is missing expression.`,\n [42]: `v-model value must be a valid JavaScript member expression.`,\n [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,\n [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`,\n [45]: `v-model cannot be used on a const binding because it is not writable.`,\n [46]: `Error parsing JavaScript expression: `,\n [47]: `<KeepAlive> expects exactly one child component.`,\n [52]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,\n // generic errors\n [48]: `\"prefixIdentifiers\" option is not supported in this build of compiler.`,\n [49]: `ES module mode is not supported in this build of compiler.`,\n [50]: `\"cacheHandlers\" option is only supported when the \"prefixIdentifiers\" option is enabled.`,\n [51]: `\"scopeId\" option is only supported in module mode.`,\n // just to fulfill types\n [54]: ``\n};\n\nfunction walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {\n const rootExp = root.type === \"Program\" ? root.body[0].type === \"ExpressionStatement\" && root.body[0].expression : root;\n estreeWalker.walk(root, {\n enter(node, parent) {\n parent && parentStack.push(parent);\n if (parent && parent.type.startsWith(\"TS\") && !TS_NODE_TYPES.includes(parent.type)) {\n return this.skip();\n }\n if (node.type === \"Identifier\") {\n const isLocal = !!knownIds[node.name];\n const isRefed = isReferencedIdentifier(node, parent, parentStack);\n if (includeAll || isRefed && !isLocal) {\n onIdentifier(node, parent, parentStack, isRefed, isLocal);\n }\n } else if (node.type === \"ObjectProperty\" && // eslint-disable-next-line no-restricted-syntax\n (parent == null ? void 0 : parent.type) === \"ObjectPattern\") {\n node.inPattern = true;\n } else if (isFunctionType(node)) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkFunctionParams(\n node,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"BlockStatement\") {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkBlockDeclarations(\n node,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"SwitchStatement\") {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkSwitchStatement(\n node,\n false,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"CatchClause\" && node.param) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n for (const id of extractIdentifiers(node.param)) {\n markScopeIdentifier(node, id, knownIds);\n }\n }\n } else if (isForStatement(node)) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkForStatement(\n node,\n false,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n }\n },\n leave(node, parent) {\n parent && parentStack.pop();\n if (node !== rootExp && node.scopeIds) {\n for (const id of node.scopeIds) {\n knownIds[id]--;\n if (knownIds[id] === 0) {\n delete knownIds[id];\n }\n }\n }\n }\n });\n}\nfunction isReferencedIdentifier(id, parent, parentStack) {\n if (!parent) {\n return true;\n }\n if (id.name === \"arguments\") {\n return false;\n }\n if (isReferenced(id, parent, parentStack[parentStack.length - 2])) {\n return true;\n }\n switch (parent.type) {\n case \"AssignmentExpression\":\n case \"AssignmentPattern\":\n return true;\n case \"ObjectProperty\":\n return parent.key !== id && isInDestructureAssignment(parent, parentStack);\n case \"ArrayPattern\":\n return isInDestructureAssignment(parent, parentStack);\n }\n return false;\n}\nfunction isInDestructureAssignment(parent, parentStack) {\n if (parent && (parent.type === \"ObjectProperty\" || parent.type === \"ArrayPattern\")) {\n let i = parentStack.length;\n while (i--) {\n const p = parentStack[i];\n if (p.type === \"AssignmentExpression\") {\n return true;\n } else if (p.type !== \"ObjectProperty\" && !p.type.endsWith(\"Pattern\")) {\n break;\n }\n }\n }\n return false;\n}\nfunction isInNewExpression(parentStack) {\n let i = parentStack.length;\n while (i--) {\n const p = parentStack[i];\n if (p.type === \"NewExpression\") {\n return true;\n } else if (p.type !== \"MemberExpression\") {\n break;\n }\n }\n return false;\n}\nfunction walkFunctionParams(node, onIdent) {\n for (const p of node.params) {\n for (const id of extractIdentifiers(p)) {\n onIdent(id);\n }\n }\n}\nfunction walkBlockDeclarations(block, onIdent) {\n const body = block.type === \"SwitchCase\" ? block.consequent : block.body;\n for (const stmt of body) {\n if (stmt.type === \"VariableDeclaration\") {\n if (stmt.declare) continue;\n for (const decl of stmt.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n } else if (stmt.type === \"FunctionDeclaration\" || stmt.type === \"ClassDeclaration\") {\n if (stmt.declare || !stmt.id) continue;\n onIdent(stmt.id);\n } else if (isForStatement(stmt)) {\n walkForStatement(stmt, true, onIdent);\n } else if (stmt.type === \"SwitchStatement\") {\n walkSwitchStatement(stmt, true, onIdent);\n }\n }\n}\nfunction isForStatement(stmt) {\n return stmt.type === \"ForOfStatement\" || stmt.type === \"ForInStatement\" || stmt.type === \"ForStatement\";\n}\nfunction walkForStatement(stmt, isVar, onIdent) {\n const variable = stmt.type === \"ForStatement\" ? stmt.init : stmt.left;\n if (variable && variable.type === \"VariableDeclaration\" && (variable.kind === \"var\" ? isVar : !isVar)) {\n for (const decl of variable.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n }\n}\nfunction walkSwitchStatement(stmt, isVar, onIdent) {\n for (const cs of stmt.cases) {\n for (const stmt2 of cs.consequent) {\n if (stmt2.type === \"VariableDeclaration\" && (stmt2.kind === \"var\" ? isVar : !isVar)) {\n for (const decl of stmt2.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n }\n }\n walkBlockDeclarations(cs, onIdent);\n }\n}\nfunction extractIdentifiers(param, nodes = []) {\n switch (param.type) {\n case \"Identifier\":\n nodes.push(param);\n break;\n case \"MemberExpression\":\n let object = param;\n while (object.type === \"MemberExpression\") {\n object = object.object;\n }\n nodes.push(object);\n break;\n case \"ObjectPattern\":\n for (const prop of param.properties) {\n if (prop.type === \"RestElement\") {\n extractIdentifiers(prop.argument, nodes);\n } else {\n extractIdentifiers(prop.value, nodes);\n }\n }\n break;\n case \"ArrayPattern\":\n param.elements.forEach((element) => {\n if (element) extractIdentifiers(element, nodes);\n });\n break;\n case \"RestElement\":\n extractIdentifiers(param.argument, nodes);\n break;\n case \"AssignmentPattern\":\n extractIdentifiers(param.left, nodes);\n break;\n }\n return nodes;\n}\nfunction markKnownIds(name, knownIds) {\n if (name in knownIds) {\n knownIds[name]++;\n } else {\n knownIds[name] = 1;\n }\n}\nfunction markScopeIdentifier(node, child, knownIds) {\n const { name } = child;\n if (node.scopeIds && node.scopeIds.has(name)) {\n return;\n }\n markKnownIds(name, knownIds);\n (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);\n}\nconst isFunctionType = (node) => {\n return /Function(?:Expression|Declaration)$|Method$/.test(node.type);\n};\nconst isStaticProperty = (node) => node && (node.type === \"ObjectProperty\" || node.type === \"ObjectMethod\") && !node.computed;\nconst isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;\nfunction isReferenced(node, parent, grandparent) {\n switch (parent.type) {\n // yes: PARENT[NODE]\n // yes: NODE.child\n // no: parent.NODE\n case \"MemberExpression\":\n case \"OptionalMemberExpression\":\n if (parent.property === node) {\n return !!parent.computed;\n }\n return parent.object === node;\n case \"JSXMemberExpression\":\n return parent.object === node;\n // no: let NODE = init;\n // yes: let id = NODE;\n case \"VariableDeclarator\":\n return parent.init === node;\n // yes: () => NODE\n // no: (NODE) => {}\n case \"ArrowFunctionExpression\":\n return parent.body === node;\n // no: class { #NODE; }\n // no: class { get #NODE() {} }\n // no: class { #NODE() {} }\n // no: class { fn() { return this.#NODE; } }\n case \"PrivateName\":\n return false;\n // no: class { NODE() {} }\n // yes: class { [NODE]() {} }\n // no: class { foo(NODE) {} }\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"ObjectMethod\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return false;\n // yes: { [NODE]: \"\" }\n // no: { NODE: \"\" }\n // depends: { NODE }\n // depends: { key: NODE }\n case \"ObjectProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return !grandparent || grandparent.type !== \"ObjectPattern\";\n // no: class { NODE = value; }\n // yes: class { [NODE] = value; }\n // yes: class { key = NODE; }\n case \"ClassProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n case \"ClassPrivateProperty\":\n return parent.key !== node;\n // no: class NODE {}\n // yes: class Foo extends NODE {}\n case \"ClassDeclaration\":\n case \"ClassExpression\":\n return parent.superClass === node;\n // yes: left = NODE;\n // no: NODE = right;\n case \"AssignmentExpression\":\n return parent.right === node;\n // no: [NODE = foo] = [];\n // yes: [foo = NODE] = [];\n case \"AssignmentPattern\":\n return parent.right === node;\n // no: NODE: for (;;) {}\n case \"LabeledStatement\":\n return false;\n // no: try {} catch (NODE) {}\n case \"CatchClause\":\n return false;\n // no: function foo(...NODE) {}\n case \"RestElement\":\n return false;\n case \"BreakStatement\":\n case \"ContinueStatement\":\n return false;\n // no: function NODE() {}\n // no: function foo(NODE) {}\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n return false;\n // no: export NODE from \"foo\";\n // no: export * as NODE from \"foo\";\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n return false;\n // no: export { foo as NODE };\n // yes: export { NODE as foo };\n // no: export { NODE as foo } from \"foo\";\n case \"ExportSpecifier\":\n if (grandparent == null ? void 0 : grandparent.source) {\n return false;\n }\n return parent.local === node;\n // no: import NODE from \"foo\";\n // no: import * as NODE from \"foo\";\n // no: import { NODE as foo } from \"foo\";\n // no: import { foo as NODE } from \"foo\";\n // no: import NODE from \"bar\";\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n return false;\n // no: import \"foo\" assert { NODE: \"json\" }\n case \"ImportAttribute\":\n return false;\n // no: <div NODE=\"foo\" />\n case \"JSXAttribute\":\n return false;\n // no: [NODE] = [];\n // no: ({ NODE }) = [];\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n return false;\n // no: new.NODE\n // no: NODE.target\n case \"MetaProperty\":\n return false;\n // yes: type X = { someProperty: NODE }\n // no: type X = { NODE: OtherType }\n case \"ObjectTypeProperty\":\n return parent.key !== node;\n // yes: enum X { Foo = NODE }\n // no: enum X { NODE }\n case \"TSEnumMember\":\n return parent.id !== node;\n // yes: { [NODE]: value }\n // no: { NODE: value }\n case \"TSPropertySignature\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n }\n return true;\n}\nconst TS_NODE_TYPES = [\n \"TSAsExpression\",\n // foo as number\n \"TSTypeAssertion\",\n // (<number>foo)\n \"TSNonNullExpression\",\n // foo!\n \"TSInstantiationExpression\",\n // foo<string>\n \"TSSatisfiesExpression\"\n // foo satisfies T\n];\nfunction unwrapTSNode(node) {\n if (TS_NODE_TYPES.includes(node.type)) {\n return unwrapTSNode(node.expression);\n } else {\n return node;\n }\n}\n\nconst isStaticExp = (p) => p.type === 4 && p.isStatic;\nfunction isCoreComponent(tag) {\n switch (tag) {\n case \"Teleport\":\n case \"teleport\":\n return TELEPORT;\n case \"Suspense\":\n case \"suspense\":\n return SUSPENSE;\n case \"KeepAlive\":\n case \"keep-alive\":\n return KEEP_ALIVE;\n case \"BaseTransition\":\n case \"base-transition\":\n return BASE_TRANSITION;\n }\n}\nconst nonIdentifierRE = /^$|^\\d|[^\\$\\w\\xA0-\\uFFFF]/;\nconst isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);\nconst validFirstIdentCharRE = /[A-Za-z_$\\xA0-\\uFFFF]/;\nconst validIdentCharRE = /[\\.\\?\\w$\\xA0-\\uFFFF]/;\nconst whitespaceRE = /\\s+[.[]\\s*|\\s*[.[]\\s+/g;\nconst getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;\nconst isMemberExpressionBrowser = (exp) => {\n const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());\n let state = 0 /* inMemberExp */;\n let stateStack = [];\n let currentOpenBracketCount = 0;\n let currentOpenParensCount = 0;\n let currentStringType = null;\n for (let i = 0; i < path.length; i++) {\n const char = path.charAt(i);\n switch (state) {\n case 0 /* inMemberExp */:\n if (char === \"[\") {\n stateStack.push(state);\n state = 1 /* inBrackets */;\n currentOpenBracketCount++;\n } else if (char === \"(\") {\n stateStack.push(state);\n state = 2 /* inParens */;\n currentOpenParensCount++;\n } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {\n return false;\n }\n break;\n case 1 /* inBrackets */:\n if (char === `'` || char === `\"` || char === \"`\") {\n stateStack.push(state);\n state = 3 /* inString */;\n currentStringType = char;\n } else if (char === `[`) {\n currentOpenBracketCount++;\n } else if (char === `]`) {\n if (!--currentOpenBracketCount) {\n state = stateStack.pop();\n }\n }\n break;\n case 2 /* inParens */:\n if (char === `'` || char === `\"` || char === \"`\") {\n stateStack.push(state);\n state = 3 /* inString */;\n currentStringType = char;\n } else if (char === `(`) {\n currentOpenParensCount++;\n } else if (char === `)`) {\n if (i === path.length - 1) {\n return false;\n }\n if (!--currentOpenParensCount) {\n state = stateStack.pop();\n }\n }\n break;\n case 3 /* inString */:\n if (char === currentStringType) {\n state = stateStack.pop();\n currentStringType = null;\n }\n break;\n }\n }\n return !currentOpenBracketCount && !currentOpenParensCount;\n};\nconst isMemberExpressionNode = (exp, context) => {\n try {\n let ret = exp.ast || parser.parseExpression(getExpSource(exp), {\n plugins: context.expressionPlugins ? [...context.expressionPlugins, \"typescript\"] : [\"typescript\"]\n });\n ret = unwrapTSNode(ret);\n return ret.type === \"MemberExpression\" || ret.type === \"OptionalMemberExpression\" || ret.type === \"Identifier\" && ret.name !== \"undefined\";\n } catch (e) {\n return false;\n }\n};\nconst isMemberExpression = isMemberExpressionNode;\nconst fnExpRE = /^\\s*(?:async\\s*)?(?:\\([^)]*?\\)|[\\w$_]+)\\s*(?::[^=]+)?=>|^\\s*(?:async\\s+)?function(?:\\s+[\\w$]+)?\\s*\\(/;\nconst isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));\nconst isFnExpressionNode = (exp, context) => {\n try {\n let ret = exp.ast || parser.parseExpression(getExpSource(exp), {\n plugins: context.expressionPlugins ? [...context.expressionPlugins, \"typescript\"] : [\"typescript\"]\n });\n if (ret.type === \"Program\") {\n ret = ret.body[0];\n if (ret.type === \"ExpressionStatement\") {\n ret = ret.expression;\n }\n }\n ret = unwrapTSNode(ret);\n return ret.type === \"FunctionExpression\" || ret.type === \"ArrowFunctionExpression\";\n } catch (e) {\n return false;\n }\n};\nconst isFnExpression = isFnExpressionNode;\nfunction advancePositionWithClone(pos, source, numberOfCharacters = source.length) {\n return advancePositionWithMutation(\n {\n offset: pos.offset,\n line: pos.line,\n column: pos.column\n },\n source,\n numberOfCharacters\n );\n}\nfunction advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {\n let linesCount = 0;\n let lastNewLinePos = -1;\n for (let i = 0; i < numberOfCharacters; i++) {\n if (source.charCodeAt(i) === 10) {\n linesCount++;\n lastNewLinePos = i;\n }\n }\n pos.offset += numberOfCharacters;\n pos.line += linesCount;\n pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;\n return pos;\n}\nfunction assert(condition, msg) {\n if (!condition) {\n throw new Error(msg || `unexpected compiler condition`);\n }\n}\nfunction findDir(node, name, allowEmpty = false) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) {\n return p;\n }\n }\n}\nfunction findProp(node, name, dynamicOnly = false, allowEmpty = false) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n if (dynamicOnly) continue;\n if (p.name === name && (p.value || allowEmpty)) {\n return p;\n }\n } else if (p.name === \"bind\" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {\n return p;\n }\n }\n}\nfunction isStaticArgOf(arg, name) {\n return !!(arg && isStaticExp(arg) && arg.content === name);\n}\nfunction hasDynamicKeyVBind(node) {\n return node.props.some(\n (p) => p.type === 7 && p.name === \"bind\" && (!p.arg || // v-bind=\"obj\"\n p.arg.type !== 4 || // v-bind:[_ctx.foo]\n !p.arg.isStatic)\n // v-bind:[foo]\n );\n}\nfunction isText$1(node) {\n return node.type === 5 || node.type === 2;\n}\nfunction isVPre(p) {\n return p.type === 7 && p.name === \"pre\";\n}\nfunction isVSlot(p) {\n return p.type === 7 && p.name === \"slot\";\n}\nfunction isTemplateNode(node) {\n return node.type === 1 && node.tagType === 3;\n}\nfunction isSlotOutlet(node) {\n return node.type === 1 && node.tagType === 2;\n}\nconst propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);\nfunction getUnnormalizedProps(props, callPath = []) {\n if (props && !shared.isString(props) && props.type === 14) {\n const callee = props.callee;\n if (!shared.isString(callee) && propsHelperSet.has(callee)) {\n return getUnnormalizedProps(\n props.arguments[0],\n callPath.concat(props)\n );\n }\n }\n return [props, callPath];\n}\nfunction injectProp(node, prop, context) {\n let propsWithInjection;\n let props = node.type === 13 ? node.props : node.arguments[2];\n let callPath = [];\n let parentCall;\n if (props && !shared.isString(props) && props.type === 14) {\n const ret = getUnnormalizedProps(props);\n props = ret[0];\n callPath = ret[1];\n parentCall = callPath[callPath.length - 1];\n }\n if (props == null || shared.isString(props)) {\n propsWithInjection = createObjectExpression([prop]);\n } else if (props.type === 14) {\n const first = props.arguments[0];\n if (!shared.isString(first) && first.type === 15) {\n if (!hasProp(prop, first)) {\n first.properties.unshift(prop);\n }\n } else {\n if (props.callee === TO_HANDLERS) {\n propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n createObjectExpression([prop]),\n props\n ]);\n } else {\n props.arguments.unshift(createObjectExpression([prop]));\n }\n }\n !propsWithInjection && (propsWithInjection = props);\n } else if (props.type === 15) {\n if (!hasProp(prop, props)) {\n props.properties.unshift(prop);\n }\n propsWithInjection = props;\n } else {\n propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n createObjectExpression([prop]),\n props\n ]);\n if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {\n parentCall = callPath[callPath.length - 2];\n }\n }\n if (node.type === 13) {\n if (parentCall) {\n parentCall.arguments[0] = propsWithInjection;\n } else {\n node.props = propsWithInjection;\n }\n } else {\n if (parentCall) {\n parentCall.arguments[0] = propsWithInjection;\n } else {\n node.arguments[2] = propsWithInjection;\n }\n }\n}\nfunction hasProp(prop, props) {\n let result = false;\n if (prop.key.type === 4) {\n const propKeyName = prop.key.content;\n result = props.properties.some(\n (p) => p.key.type === 4 && p.key.content === propKeyName\n );\n }\n return result;\n}\nfunction toValidAssetId(name, type) {\n return `_${type}_${name.replace(/[^\\w]/g, (searchValue, replaceValue) => {\n return searchValue === \"-\" ? \"_\" : name.charCodeAt(replaceValue).toString();\n })}`;\n}\nfunction hasScopeRef(node, ids) {\n if (!node || Object.keys(ids).length === 0) {\n return false;\n }\n switch (node.type) {\n case 1:\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {\n return true;\n }\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 11:\n if (hasScopeRef(node.source, ids)) {\n return true;\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 9:\n return node.branches.some((b) => hasScopeRef(b, ids));\n case 10:\n if (hasScopeRef(node.condition, ids)) {\n return true;\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 4:\n return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];\n case 8:\n return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids));\n case 5:\n case 12:\n return hasScopeRef(node.content, ids);\n case 2:\n case 3:\n case 20:\n return false;\n default:\n return false;\n }\n}\nfunction getMemoedVNodeCall(node) {\n if (node.type === 14 && node.callee === WITH_MEMO) {\n return node.arguments[1].returns;\n } else {\n return node;\n }\n}\nconst forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+(\\S[\\s\\S]*)/;\nfunction isAllWhitespace(str) {\n for (let i = 0; i < str.length; i++) {\n if (!isWhitespace(str.charCodeAt(i))) {\n return false;\n }\n }\n return true;\n}\nfunction isWhitespaceText(node) {\n return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content);\n}\nfunction isCommentOrWhitespace(node) {\n return node.type === 3 || isWhitespaceText(node);\n}\n\nconst defaultParserOptions = {\n parseMode: \"base\",\n ns: 0,\n delimiters: [`{{`, `}}`],\n getNamespace: () => 0,\n isVoidTag: shared.NO,\n isPreTag: shared.NO,\n isIgnoreNewlineTag: shared.NO,\n isCustomElement: shared.NO,\n onError: defaultOnError,\n onWarn: defaultOnWarn,\n comments: false,\n prefixIdentifiers: false\n};\nlet currentOptions = defaultParserOptions;\nlet currentRoot = null;\nlet currentInput = \"\";\nlet currentOpenTag = null;\nlet currentProp = null;\nlet currentAttrValue = \"\";\nlet currentAttrStartIndex = -1;\nlet currentAttrEndIndex = -1;\nlet inPre = 0;\nlet inVPre = false;\nlet currentVPreBoundary = null;\nconst stack = [];\nconst tokenizer = new Tokenizer(stack, {\n onerr: emitError,\n ontext(start, end) {\n onText(getSlice(start, end), start, end);\n },\n ontextentity(char, start, end) {\n onText(char, start, end);\n },\n oninterpolation(start, end) {\n if (inVPre) {\n return onText(getSlice(start, end), start, end);\n }\n let innerStart = start + tokenizer.delimiterOpen.length;\n let innerEnd = end - tokenizer.delimiterClose.length;\n while (isWhitespace(currentInput.charCodeAt(innerStart))) {\n innerStart++;\n }\n while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {\n innerEnd--;\n }\n let exp = getSlice(innerStart, innerEnd);\n if (exp.includes(\"&\")) {\n {\n exp = decode.decodeHTML(exp);\n }\n }\n addNode({\n type: 5,\n content: createExp(exp, false, getLoc(innerStart, innerEnd)),\n loc: getLoc(start, end)\n });\n },\n onopentagname(start, end) {\n const name = getSlice(start, end);\n currentOpenTag = {\n type: 1,\n tag: name,\n ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),\n tagType: 0,\n // will be refined on tag close\n props: [],\n children: [],\n loc: getLoc(start - 1, end),\n codegenNode: void 0\n };\n },\n onopentagend(end) {\n endOpenTag(end);\n },\n onclosetag(start, end) {\n const name = getSlice(start, end);\n if (!currentOptions.isVoidTag(name)) {\n let found = false;\n for (let i = 0; i < stack.length; i++) {\n const e = stack[i];\n if (e.tag.toLowerCase() === name.toLowerCase()) {\n found = true;\n if (i > 0) {\n emitError(24, stack[0].loc.start.offset);\n }\n for (let j = 0; j <= i; j++) {\n const el = stack.shift();\n onCloseTag(el, end, j < i);\n }\n break;\n }\n }\n if (!found) {\n emitError(23, backTrack(start, 60));\n }\n }\n },\n onselfclosingtag(end) {\n const name = currentOpenTag.tag;\n currentOpenTag.isSelfClosing = true;\n endOpenTag(end);\n if (stack[0] && stack[0].tag === name) {\n onCloseTag(stack.shift(), end);\n }\n },\n onattribname(start, end) {\n currentProp = {\n type: 6,\n name: getSlice(start, end),\n nameLoc: getLoc(start, end),\n value: void 0,\n loc: getLoc(start)\n };\n },\n ondirname(start, end) {\n const raw = getSlice(start, end);\n const name = raw === \".\" || raw === \":\" ? \"bind\" : raw === \"@\" ? \"on\" : raw === \"#\" ? \"slot\" : raw.slice(2);\n if (!inVPre && name === \"\") {\n emitError(26, start);\n }\n if (inVPre || name === \"\") {\n currentProp = {\n type: 6,\n name: raw,\n nameLoc: getLoc(start, end),\n value: void 0,\n loc: getLoc(start)\n };\n } else {\n currentProp = {\n type: 7,\n name,\n rawName: raw,\n exp: void 0,\n arg: void 0,\n modifiers: raw === \".\" ? [createSimpleExpression(\"prop\")] : [],\n loc: getLoc(start)\n };\n if (name === \"pre\") {\n inVPre = tokenizer.inVPre = true;\n currentVPreBoundary = currentOpenTag;\n const props = currentOpenTag.props;\n for (let i = 0; i < props.length; i++) {\n if (props[i].type === 7) {\n props[i] = dirToAttr(props[i]);\n }\n }\n }\n }\n },\n ondirarg(start, end) {\n if (start === end) return;\n const arg = getSlice(start, end);\n if (inVPre && !isVPre(currentProp)) {\n currentProp.name += arg;\n setLocEnd(currentProp.nameLoc, end);\n } else {\n const isStatic = arg[0] !== `[`;\n currentProp.arg = createExp(\n isStatic ? arg : arg.slice(1, -1),\n isStatic,\n getLoc(start, end),\n isStatic ? 3 : 0\n );\n }\n },\n ondirmodifier(start, end) {\n const mod = getSlice(start, end);\n if (inVPre && !isVPre(currentProp)) {\n currentProp.name += \".\" + mod;\n setLocEnd(currentProp.nameLoc, end);\n } else if (currentProp.name === \"slot\") {\n const arg = currentProp.arg;\n if (arg) {\n arg.content += \".\" + mod;\n setLocEnd(arg.loc, end);\n }\n } else {\n const exp = createSimpleExpression(mod, true, getLoc(start, end));\n currentProp.modifiers.push(exp);\n }\n },\n onattribdata(start, end) {\n currentAttrValue += getSlice(start, end);\n if (currentAttrStartIndex < 0) currentAttrStartIndex = start;\n currentAttrEndIndex = end;\n },\n onattribentity(char, start, end) {\n currentAttrValue += char;\n if (currentAttrStartIndex < 0) currentAttrStartIndex = start;\n currentAttrEndIndex = end;\n },\n onattribnameend(end) {\n const start = currentProp.loc.start.offset;\n const name = getSlice(start, end);\n if (currentProp.type === 7) {\n currentProp.rawName = name;\n }\n if (currentOpenTag.props.some(\n (p) => (p.type === 7 ? p.rawName : p.name) === name\n )) {\n emitError(2, start);\n }\n },\n onattribend(quote, end) {\n if (currentOpenTag && currentProp) {\n setLocEnd(currentProp.loc, end);\n if (quote !== 0) {\n if (currentProp.type === 6) {\n if (currentProp.name === \"class\") {\n currentAttrValue = condense(currentAttrValue).trim();\n }\n if (quote === 1 && !currentAttrValue) {\n emitError(13, end);\n }\n currentProp.value = {\n type: 2,\n content: currentAttrValue,\n loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)\n };\n if (tokenizer.inSFCRoot && currentOpenTag.tag === \"template\" && currentProp.name === \"lang\" && currentAttrValue && currentAttrValue !== \"html\") {\n tokenizer.enterRCDATA(toCharCodes(`</template`), 0);\n }\n } else {\n let expParseMode = 0 /* Normal */;\n {\n if (currentProp.name === \"for\") {\n expParseMode = 3 /* Skip */;\n } else if (currentProp.name === \"slot\") {\n expParseMode = 1 /* Params */;\n } else if (currentProp.name === \"on\" && currentAttrValue.includes(\";\")) {\n expParseMode = 2 /* Statements */;\n }\n }\n currentProp.exp = createExp(\n currentAttrValue,\n false,\n getLoc(currentAttrStartIndex, currentAttrEndIndex),\n 0,\n expParseMode\n );\n if (currentProp.name === \"for\") {\n currentProp.forParseResult = parseForExpression(currentProp.exp);\n }\n let syncIndex = -1;\n if (currentProp.name === \"bind\" && (syncIndex = currentProp.modifiers.findIndex(\n (mod) => mod.content === \"sync\"\n )) > -1 && checkCompatEnabled(\n \"COMPILER_V_BIND_SYNC\",\n currentOptions,\n currentProp.loc,\n currentProp.arg.loc.source\n )) {\n currentProp.name = \"model\";\n currentProp.modifiers.splice(syncIndex, 1);\n }\n }\n }\n if (currentProp.type !== 7 || currentProp.name !== \"pre\") {\n currentOpenTag.props.push(currentProp);\n }\n }\n currentAttrValue = \"\";\n currentAttrStartIndex = currentAttrEndIndex = -1;\n },\n oncomment(start, end) {\n if (currentOptions.comments) {\n addNode({\n type: 3,\n content: getSlice(start, end),\n loc: getLoc(start - 4, end + 3)\n });\n }\n },\n onend() {\n const end = currentInput.length;\n if (tokenizer.state !== 1) {\n switch (tokenizer.state) {\n case 5:\n case 8:\n emitError(5, end);\n break;\n case 3:\n case 4:\n emitError(\n 25,\n tokenizer.sectionStart\n );\n break;\n case 28:\n if (tokenizer.currentSequence === Sequences.CdataEnd) {\n emitError(6, end);\n } else {\n emitError(7, end);\n }\n break;\n case 6:\n case 7:\n case 9:\n case 11:\n case 12:\n case 13:\n case 14:\n case 15:\n case 16:\n case 17:\n case 18:\n case 19:\n // \"\n case 20:\n // '\n case 21:\n emitError(9, end);\n break;\n }\n }\n for (let index = 0; index < stack.length; index++) {\n onCloseTag(stack[index], end - 1);\n emitError(24, stack[index].loc.start.offset);\n }\n },\n oncdata(start, end) {\n if (stack[0].ns !== 0) {\n onText(getSlice(start, end), start, end);\n } else {\n emitError(1, start - 9);\n }\n },\n onprocessinginstruction(start) {\n if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {\n emitError(\n 21,\n start - 1\n );\n }\n }\n});\nconst forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nconst stripParensRE = /^\\(|\\)$/g;\nfunction parseForExpression(input) {\n const loc = input.loc;\n const exp = input.content;\n const inMatch = exp.match(forAliasRE);\n if (!inMatch) return;\n const [, LHS, RHS] = inMatch;\n const createAliasExpression = (content, offset, asParam = false) => {\n const start = loc.start.offset + offset;\n const end = start + content.length;\n return createExp(\n content,\n false,\n getLoc(start, end),\n 0,\n asParam ? 1 /* Params */ : 0 /* Normal */\n );\n };\n const result = {\n source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),\n value: void 0,\n key: void 0,\n index: void 0,\n finalized: false\n };\n let valueContent = LHS.trim().replace(stripParensRE, \"\").trim();\n const trimmedOffset = LHS.indexOf(valueContent);\n const iteratorMatch = valueContent.match(forIteratorRE);\n if (iteratorMatch) {\n valueContent = valueContent.replace(forIteratorRE, \"\").trim();\n const keyContent = iteratorMatch[1].trim();\n let keyOffset;\n if (keyContent) {\n keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);\n result.key = createAliasExpression(keyContent, keyOffset, true);\n }\n if (iteratorMatch[2]) {\n const indexContent = iteratorMatch[2].trim();\n if (indexContent) {\n result.index = createAliasExpression(\n indexContent,\n exp.indexOf(\n indexContent,\n result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length\n ),\n true\n );\n }\n }\n }\n if (valueContent) {\n result.value = createAliasExpression(valueContent, trimmedOffset, true);\n }\n return result;\n}\nfunction getSlice(start, end) {\n return currentInput.slice(start, end);\n}\nfunction endOpenTag(end) {\n if (tokenizer.inSFCRoot) {\n currentOpenTag.innerLoc = getLoc(end + 1, end + 1);\n }\n addNode(currentOpenTag);\n const { tag, ns } = currentOpenTag;\n if (ns === 0 && currentOptions.isPreTag(tag)) {\n inPre++;\n }\n if (currentOptions.isVoidTag(tag)) {\n onCloseTag(currentOpenTag, end);\n } else {\n stack.unshift(currentOpenTag);\n if (ns === 1 || ns === 2) {\n tokenizer.inXML = true;\n }\n }\n currentOpenTag = null;\n}\nfunction onText(content, start, end) {\n const parent = stack[0] || currentRoot;\n const lastNode = parent.children[parent.children.length - 1];\n if (lastNode && lastNode.type === 2) {\n lastNode.content += content;\n setLocEnd(lastNode.loc, end);\n } else {\n parent.children.push({\n type: 2,\n content,\n loc: getLoc(start, end)\n });\n }\n}\nfunction onCloseTag(el, end, isImplied = false) {\n if (isImplied) {\n setLocEnd(el.loc, backTrack(end, 60));\n } else {\n setLocEnd(el.loc, lookAhead(end, 62) + 1);\n }\n if (tokenizer.inSFCRoot) {\n if (el.children.length) {\n el.innerLoc.end = shared.extend({}, el.children[el.children.length - 1].loc.end);\n } else {\n el.innerLoc.end = shared.extend({}, el.innerLoc.start);\n }\n el.innerLoc.source = getSlice(\n el.innerLoc.start.offset,\n el.innerLoc.end.offset\n );\n }\n const { tag, ns, children } = el;\n if (!inVPre) {\n if (tag === \"slot\") {\n el.tagType = 2;\n } else if (isFragmentTemplate(el)) {\n el.tagType = 3;\n } else if (isComponent(el)) {\n el.tagType = 1;\n }\n }\n if (!tokenizer.inRCDATA) {\n el.children = condenseWhitespace(children);\n }\n if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {\n const first = children[0];\n if (first && first.type === 2) {\n first.content = first.content.replace(/^\\r?\\n/, \"\");\n }\n }\n if (ns === 0 && currentOptions.isPreTag(tag)) {\n inPre--;\n }\n if (currentVPreBoundary === el) {\n inVPre = tokenizer.inVPre = false;\n currentVPreBoundary = null;\n }\n if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {\n tokenizer.inXML = false;\n }\n {\n const props = el.props;\n if (!tokenizer.inSFCRoot && isCompatEnabled(\n \"COMPILER_NATIVE_TEMPLATE\",\n currentOptions\n ) && el.tag === \"template\" && !isFragmentTemplate(el)) {\n const parent = stack[0] || currentRoot;\n const index = parent.children.indexOf(el);\n parent.children.splice(index, 1, ...el.children);\n }\n const inlineTemplateProp = props.find(\n (p) => p.type === 6 && p.name === \"inline-template\"\n );\n if (inlineTemplateProp && checkCompatEnabled(\n \"COMPILER_INLINE_TEMPLATE\",\n currentOptions,\n inlineTemplateProp.loc\n ) && el.children.length) {\n inlineTemplateProp.value = {\n type: 2,\n content: getSlice(\n el.children[0].loc.start.offset,\n el.children[el.children.length - 1].loc.end.offset\n ),\n loc: inlineTemplateProp.loc\n };\n }\n }\n}\nfunction lookAhead(index, c) {\n let i = index;\n while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;\n return i;\n}\nfunction backTrack(index, c) {\n let i = index;\n while (currentInput.charCodeAt(i) !== c && i >= 0) i--;\n return i;\n}\nconst specialTemplateDir = /* @__PURE__ */ new Set([\"if\", \"else\", \"else-if\", \"for\", \"slot\"]);\nfunction isFragmentTemplate({ tag, props }) {\n if (tag === \"template\") {\n for (let i = 0; i < props.length; i++) {\n if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {\n return true;\n }\n }\n }\n return false;\n}\nfunction isComponent({ tag, props }) {\n if (currentOptions.isCustomElement(tag)) {\n return false;\n }\n if (tag === \"component\" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {\n return true;\n }\n for (let i = 0; i < props.length; i++) {\n const p = props[i];\n if (p.type === 6) {\n if (p.name === \"is\" && p.value) {\n if (p.value.content.startsWith(\"vue:\")) {\n return true;\n } else if (checkCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n currentOptions,\n p.loc\n )) {\n return true;\n }\n }\n } else if (// :is on plain element - only treat as component in compat mode\n p.name === \"bind\" && isStaticArgOf(p.arg, \"is\") && checkCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n currentOptions,\n p.loc\n )) {\n return true;\n }\n }\n return false;\n}\nfunction isUpperCase(c) {\n return c > 64 && c < 91;\n}\nconst windowsNewlineRE = /\\r\\n/g;\nfunction condenseWhitespace(nodes) {\n const shouldCondense = currentOptions.whitespace !== \"preserve\";\n let removedWhitespace = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === 2) {\n if (!inPre) {\n if (isAllWhitespace(node.content)) {\n const prev = nodes[i - 1] && nodes[i - 1].type;\n const next = nodes[i + 1] && nodes[i + 1].type;\n if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {\n removedWhitespace = true;\n nodes[i] = null;\n } else {\n node.content = \" \";\n }\n } else if (shouldCondense) {\n node.content = condense(node.content);\n }\n } else {\n node.content = node.content.replace(windowsNewlineRE, \"\\n\");\n }\n }\n }\n return removedWhitespace ? nodes.filter(Boolean) : nodes;\n}\nfunction hasNewlineChar(str) {\n for (let i = 0; i < str.length; i++) {\n const c = str.charCodeAt(i);\n if (c === 10 || c === 13) {\n return true;\n }\n }\n return false;\n}\nfunction condense(str) {\n let ret = \"\";\n let prevCharIsWhitespace = false;\n for (let i = 0; i < str.length; i++) {\n if (isWhitespace(str.charCodeAt(i))) {\n if (!prevCharIsWhitespace) {\n ret += \" \";\n prevCharIsWhitespace = true;\n }\n } else {\n ret += str[i];\n prevCharIsWhitespace = false;\n }\n }\n return ret;\n}\nfunction addNode(node) {\n (stack[0] || currentRoot).children.push(node);\n}\nfunction getLoc(start, end) {\n return {\n start: tokenizer.getPos(start),\n // @ts-expect-error allow late attachment\n end: end == null ? end : tokenizer.getPos(end),\n // @ts-expect-error allow late attachment\n source: end == null ? end : getSlice(start, end)\n };\n}\nfunction cloneLoc(loc) {\n return getLoc(loc.start.offset, loc.end.offset);\n}\nfunction setLocEnd(loc, end) {\n loc.end = tokenizer.getPos(end);\n loc.source = getSlice(loc.start.offset, end);\n}\nfunction dirToAttr(dir) {\n const attr = {\n type: 6,\n name: dir.rawName,\n nameLoc: getLoc(\n dir.loc.start.offset,\n dir.loc.start.offset + dir.rawName.length\n ),\n value: void 0,\n loc: dir.loc\n };\n if (dir.exp) {\n const loc = dir.exp.loc;\n if (loc.end.offset < dir.loc.end.offset) {\n loc.start.offset--;\n loc.start.column--;\n loc.end.offset++;\n loc.end.column++;\n }\n attr.value = {\n type: 2,\n content: dir.exp.content,\n loc\n };\n }\n return attr;\n}\nfunction createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {\n const exp = createSimpleExpression(content, isStatic, loc, constType);\n if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 /* Skip */ && content.trim()) {\n if (isSimpleIdentifier(content)) {\n exp.ast = null;\n return exp;\n }\n try {\n const plugins = currentOptions.expressionPlugins;\n const options = {\n plugins: plugins ? [...plugins, \"typescript\"] : [\"typescript\"]\n };\n if (parseMode === 2 /* Statements */) {\n exp.ast = parser.parse(` ${content} `, options).program;\n } else if (parseMode === 1 /* Params */) {\n exp.ast = parser.parseExpression(`(${content})=>{}`, options);\n } else {\n exp.ast = parser.parseExpression(`(${content})`, options);\n }\n } catch (e) {\n exp.ast = false;\n emitError(46, loc.start.offset, e.message);\n }\n }\n return exp;\n}\nfunction emitError(code, index, message) {\n currentOptions.onError(\n createCompilerError(code, getLoc(index, index), void 0, message)\n );\n}\nfunction reset() {\n tokenizer.reset();\n currentOpenTag = null;\n currentProp = null;\n currentAttrValue = \"\";\n currentAttrStartIndex = -1;\n currentAttrEndIndex = -1;\n stack.length = 0;\n}\nfunction baseParse(input, options) {\n reset();\n currentInput = input;\n currentOptions = shared.extend({}, defaultParserOptions);\n if (options) {\n let key;\n for (key in options) {\n if (options[key] != null) {\n currentOptions[key] = options[key];\n }\n }\n }\n tokenizer.mode = currentOptions.parseMode === \"html\" ? 1 : currentOptions.parseMode === \"sfc\" ? 2 : 0;\n tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;\n const delimiters = options && options.delimiters;\n if (delimiters) {\n tokenizer.delimiterOpen = toCharCodes(delimiters[0]);\n tokenizer.delimiterClose = toCharCodes(delimiters[1]);\n }\n const root = currentRoot = createRoot([], input);\n tokenizer.parse(currentInput);\n root.loc = getLoc(0, input.length);\n root.children = condenseWhitespace(root.children);\n currentRoot = null;\n return root;\n}\n\nfunction cacheStatic(root, context) {\n walk(\n root,\n void 0,\n context,\n // Root node is unfortunately non-hoistable due to potential parent\n // fallthrough attributes.\n !!getSingleElementRoot(root)\n );\n}\nfunction getSingleElementRoot(root) {\n const children = root.children.filter((x) => x.type !== 3);\n return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;\n}\nfunction walk(node, parent, context, doNotHoistNode = false, inFor = false) {\n const { children } = node;\n const toCache = [];\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (child.type === 1 && child.tagType === 0) {\n const constantType = doNotHoistNode ? 0 : getConstantType(child, context);\n if (constantType > 0) {\n if (constantType >= 2) {\n child.codegenNode.patchFlag = -1;\n toCache.push(child);\n continue;\n }\n } else {\n const codegenNode = child.codegenNode;\n if (codegenNode.type === 13) {\n const flag = codegenNode.patchFlag;\n if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {\n const props = getNodeProps(child);\n if (props) {\n codegenNode.props = context.hoist(props);\n }\n }\n if (codegenNode.dynamicProps) {\n codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);\n }\n }\n }\n } else if (child.type === 12) {\n const constantType = doNotHoistNode ? 0 : getConstantType(child, context);\n if (constantType >= 2) {\n if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) {\n child.codegenNode.arguments.push(\n -1 + (``)\n );\n }\n toCache.push(child);\n continue;\n }\n }\n if (child.type === 1) {\n const isComponent = child.tagType === 1;\n if (isComponent) {\n context.scopes.vSlot++;\n }\n walk(child, node, context, false, inFor);\n if (isComponent) {\n context.scopes.vSlot--;\n }\n } else if (child.type === 11) {\n walk(child, node, context, child.children.length === 1, true);\n } else if (child.type === 9) {\n for (let i2 = 0; i2 < child.branches.length; i2++) {\n walk(\n child.branches[i2],\n node,\n context,\n child.branches[i2].children.length === 1,\n inFor\n );\n }\n }\n }\n let cachedAsArray = false;\n if (toCache.length === children.length && node.type === 1) {\n if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) {\n node.codegenNode.children = getCacheExpression(\n createArrayExpression(node.codegenNode.children)\n );\n cachedAsArray = true;\n } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared.isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {\n const slot = getSlotNode(node.codegenNode, \"default\");\n if (slot) {\n slot.returns = getCacheExpression(\n createArrayExpression(slot.returns)\n );\n cachedAsArray = true;\n }\n } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {\n const slotName = findDir(node, \"slot\", true);\n const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);\n if (slot) {\n slot.returns = getCacheExpression(\n createArrayExpression(slot.returns)\n );\n cachedAsArray = true;\n }\n }\n }\n if (!cachedAsArray) {\n for (const child of toCache) {\n child.codegenNode = context.cache(child.codegenNode);\n }\n }\n function getCacheExpression(value) {\n const exp = context.cache(value);\n exp.needArraySpread = true;\n return exp;\n }\n function getSlotNode(node2, name) {\n if (node2.children && !shared.isArray(node2.children) && node2.children.type === 15) {\n const slot = node2.children.properties.find(\n (p) => p.key === name || p.key.content === name\n );\n return slot && slot.value;\n }\n }\n if (toCache.length && context.transformHoist) {\n context.transformHoist(children, context, node);\n }\n}\nfunction getConstantType(node, context) {\n const { constantCache } = context;\n switch (node.type) {\n case 1:\n if (node.tagType !== 0) {\n return 0;\n }\n const cached = constantCache.get(node);\n if (cached !== void 0) {\n return cached;\n }\n const codegenNode = node.codegenNode;\n if (codegenNode.type !== 13) {\n return 0;\n }\n if (codegenNode.isBlock && node.tag !== \"svg\" && node.tag !== \"foreignObject\" && node.tag !== \"math\") {\n return 0;\n }\n if (codegenNode.patchFlag === void 0) {\n let returnType2 = 3;\n const generatedPropsType = getGeneratedPropsConstantType(node, context);\n if (generatedPropsType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (generatedPropsType < returnType2) {\n returnType2 = generatedPropsType;\n }\n for (let i = 0; i < node.children.length; i++) {\n const childType = getConstantType(node.children[i], context);\n if (childType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (childType < returnType2) {\n returnType2 = childType;\n }\n }\n if (returnType2 > 1) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && p.name === \"bind\" && p.exp) {\n const expType = getConstantType(p.exp, context);\n if (expType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (expType < returnType2) {\n returnType2 = expType;\n }\n }\n }\n }\n if (codegenNode.isBlock) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7) {\n constantCache.set(node, 0);\n return 0;\n }\n }\n context.removeHelper(OPEN_BLOCK);\n context.removeHelper(\n getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)\n );\n codegenNode.isBlock = false;\n context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));\n }\n constantCache.set(node, returnType2);\n return returnType2;\n } else {\n constantCache.set(node, 0);\n return 0;\n }\n case 2:\n case 3:\n return 3;\n case 9:\n case 11:\n case 10:\n return 0;\n case 5:\n case 12:\n return getConstantType(node.content, context);\n case 4:\n return node.constType;\n case 8:\n let returnType = 3;\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (shared.isString(child) || shared.isSymbol(child)) {\n continue;\n }\n const childType = getConstantType(child, context);\n if (childType === 0) {\n return 0;\n } else if (childType < returnType) {\n returnType = childType;\n }\n }\n return returnType;\n case 20:\n return 2;\n default:\n return 0;\n }\n}\nconst allowHoistedHelperSet = /* @__PURE__ */ new Set([\n NORMALIZE_CLASS,\n NORMALIZE_STYLE,\n NORMALIZE_PROPS,\n GUARD_REACTIVE_PROPS\n]);\nfunction getConstantTypeOfHelperCall(value, context) {\n if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {\n const arg = value.arguments[0];\n if (arg.type === 4) {\n return getConstantType(arg, context);\n } else if (arg.type === 14) {\n return getConstantTypeOfHelperCall(arg, context);\n }\n }\n return 0;\n}\nfunction getGeneratedPropsConstantType(node, context) {\n let returnType = 3;\n const props = getNodeProps(node);\n if (props && props.type === 15) {\n const { properties } = props;\n for (let i = 0; i < properties.length; i++) {\n const { key, value } = properties[i];\n const keyType = getConstantType(key, context);\n if (keyType === 0) {\n return keyType;\n }\n if (keyType < returnType) {\n returnType = keyType;\n }\n let valueType;\n if (value.type === 4) {\n valueType = getConstantType(value, context);\n } else if (value.type === 14) {\n valueType = getConstantTypeOfHelperCall(value, context);\n } else {\n valueType = 0;\n }\n if (valueType === 0) {\n return valueType;\n }\n if (valueType < returnType) {\n returnType = valueType;\n }\n }\n }\n return returnType;\n}\nfunction getNodeProps(node) {\n const codegenNode = node.codegenNode;\n if (codegenNode.type === 13) {\n return codegenNode.props;\n }\n}\n\nfunction createTransformContext(root, {\n filename = \"\",\n prefixIdentifiers = false,\n hoistStatic = false,\n hmr = false,\n cacheHandlers = false,\n nodeTransforms = [],\n directiveTransforms = {},\n transformHoist = null,\n isBuiltInComponent = shared.NOOP,\n isCustomElement = shared.NOOP,\n expressionPlugins = [],\n scopeId = null,\n slotted = true,\n ssr = false,\n inSSR = false,\n ssrCssVars = ``,\n bindingMetadata = shared.EMPTY_OBJ,\n inline = false,\n isTS = false,\n onError = defaultOnError,\n onWarn = defaultOnWarn,\n compatConfig\n}) {\n const nameMatch = filename.replace(/\\?.*$/, \"\").match(/([^/\\\\]+)\\.\\w+$/);\n const context = {\n // options\n filename,\n selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),\n prefixIdentifiers,\n hoistStatic,\n hmr,\n cacheHandlers,\n nodeTransforms,\n directiveTransforms,\n transformHoist,\n isBuiltInComponent,\n isCustomElement,\n expressionPlugins,\n scopeId,\n slotted,\n ssr,\n inSSR,\n ssrCssVars,\n bindingMetadata,\n inline,\n isTS,\n onError,\n onWarn,\n compatConfig,\n // state\n root,\n helpers: /* @__PURE__ */ new Map(),\n components: /* @__PURE__ */ new Set(),\n directives: /* @__PURE__ */ new Set(),\n hoists: [],\n imports: [],\n cached: [],\n constantCache: /* @__PURE__ */ new WeakMap(),\n temps: 0,\n identifiers: /* @__PURE__ */ Object.create(null),\n scopes: {\n vFor: 0,\n vSlot: 0,\n vPre: 0,\n vOnce: 0\n },\n parent: null,\n grandParent: null,\n currentNode: root,\n childIndex: 0,\n inVOnce: false,\n // methods\n helper(name) {\n const count = context.helpers.get(name) || 0;\n context.helpers.set(name, count + 1);\n return name;\n },\n removeHelper(name) {\n const count = context.helpers.get(name);\n if (count) {\n const currentCount = count - 1;\n if (!currentCount) {\n context.helpers.delete(name);\n } else {\n context.helpers.set(name, currentCount);\n }\n }\n },\n helperString(name) {\n return `_${helperNameMap[context.helper(name)]}`;\n },\n replaceNode(node) {\n context.parent.children[context.childIndex] = context.currentNode = node;\n },\n removeNode(node) {\n const list = context.parent.children;\n const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;\n if (!node || node === context.currentNode) {\n context.currentNode = null;\n context.onNodeRemoved();\n } else {\n if (context.childIndex > removalIndex) {\n context.childIndex--;\n context.onNodeRemoved();\n }\n }\n context.parent.children.splice(removalIndex, 1);\n },\n onNodeRemoved: shared.NOOP,\n addIdentifiers(exp) {\n {\n if (shared.isString(exp)) {\n addId(exp);\n } else if (exp.identifiers) {\n exp.identifiers.forEach(addId);\n } else if (exp.type === 4) {\n addId(exp.content);\n }\n }\n },\n removeIdentifiers(exp) {\n {\n if (shared.isString(exp)) {\n removeId(exp);\n } else if (exp.identifiers) {\n exp.identifiers.forEach(removeId);\n } else if (exp.type === 4) {\n removeId(exp.content);\n }\n }\n },\n hoist(exp) {\n if (shared.isString(exp)) exp = createSimpleExpression(exp);\n context.hoists.push(exp);\n const identifier = createSimpleExpression(\n `_hoisted_${context.hoists.length}`,\n false,\n exp.loc,\n 2\n );\n identifier.hoisted = exp;\n return identifier;\n },\n cache(exp, isVNode = false, inVOnce = false) {\n const cacheExp = createCacheExpression(\n context.cached.length,\n exp,\n isVNode,\n inVOnce\n );\n context.cached.push(cacheExp);\n return cacheExp;\n }\n };\n {\n context.filters = /* @__PURE__ */ new Set();\n }\n function addId(id) {\n const { identifiers } = context;\n if (identifiers[id] === void 0) {\n identifiers[id] = 0;\n }\n identifiers[id]++;\n }\n function removeId(id) {\n context.identifiers[id]--;\n }\n return context;\n}\nfunction transform(root, options) {\n const context = createTransformContext(root, options);\n traverseNode(root, context);\n if (options.hoistStatic) {\n cacheStatic(root, context);\n }\n if (!options.ssr) {\n createRootCodegen(root, context);\n }\n root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);\n root.components = [...context.components];\n root.directives = [...context.directives];\n root.imports = context.imports;\n root.hoists = context.hoists;\n root.temps = context.temps;\n root.cached = context.cached;\n root.transformed = true;\n {\n root.filters = [...context.filters];\n }\n}\nfunction createRootCodegen(root, context) {\n const { helper } = context;\n const { children } = root;\n if (children.length === 1) {\n const singleElementRootChild = getSingleElementRoot(root);\n if (singleElementRootChild && singleElementRootChild.codegenNode) {\n const codegenNode = singleElementRootChild.codegenNode;\n if (codegenNode.type === 13) {\n convertToBlock(codegenNode, context);\n }\n root.codegenNode = codegenNode;\n } else {\n root.codegenNode = children[0];\n }\n } else if (children.length > 1) {\n let patchFlag = 64;\n root.codegenNode = createVNodeCall(\n context,\n helper(FRAGMENT),\n void 0,\n root.children,\n patchFlag,\n void 0,\n void 0,\n true,\n void 0,\n false\n );\n } else ;\n}\nfunction traverseChildren(parent, context) {\n let i = 0;\n const nodeRemoved = () => {\n i--;\n };\n for (; i < parent.children.length; i++) {\n const child = parent.children[i];\n if (shared.isString(child)) continue;\n context.grandParent = context.parent;\n context.parent = parent;\n context.childIndex = i;\n context.onNodeRemoved = nodeRemoved;\n traverseNode(child, context);\n }\n}\nfunction traverseNode(node, context) {\n context.currentNode = node;\n const { nodeTransforms } = context;\n const exitFns = [];\n for (let i2 = 0; i2 < nodeTransforms.length; i2++) {\n const onExit = nodeTransforms[i2](node, context);\n if (onExit) {\n if (shared.isArray(onExit)) {\n exitFns.push(...onExit);\n } else {\n exitFns.push(onExit);\n }\n }\n if (!context.currentNode) {\n return;\n } else {\n node = context.currentNode;\n }\n }\n switch (node.type) {\n case 3:\n if (!context.ssr) {\n context.helper(CREATE_COMMENT);\n }\n break;\n case 5:\n if (!context.ssr) {\n context.helper(TO_DISPLAY_STRING);\n }\n break;\n // for container types, further traverse downwards\n case 9:\n for (let i2 = 0; i2 < node.branches.length; i2++) {\n traverseNode(node.branches[i2], context);\n }\n break;\n case 10:\n case 11:\n case 1:\n case 0:\n traverseChildren(node, context);\n break;\n }\n context.currentNode = node;\n let i = exitFns.length;\n while (i--) {\n exitFns[i]();\n }\n}\nfunction createStructuralDirectiveTransform(name, fn) {\n const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n);\n return (node, context) => {\n if (node.type === 1) {\n const { props } = node;\n if (node.tagType === 3 && props.some(isVSlot)) {\n return;\n }\n const exitFns = [];\n for (let i = 0; i < props.length; i++) {\n const prop = props[i];\n if (prop.type === 7 && matches(prop.name)) {\n props.splice(i, 1);\n i--;\n const onExit = fn(node, prop, context);\n if (onExit) exitFns.push(onExit);\n }\n }\n return exitFns;\n }\n };\n}\n\nconst PURE_ANNOTATION = `/*@__PURE__*/`;\nconst aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;\nfunction createCodegenContext(ast, {\n mode = \"function\",\n prefixIdentifiers = mode === \"module\",\n sourceMap = false,\n filename = `template.vue.html`,\n scopeId = null,\n optimizeImports = false,\n runtimeGlobalName = `Vue`,\n runtimeModuleName = `vue`,\n ssrRuntimeModuleName = \"vue/server-renderer\",\n ssr = false,\n isTS = false,\n inSSR = false\n}) {\n const context = {\n mode,\n prefixIdentifiers,\n sourceMap,\n filename,\n scopeId,\n optimizeImports,\n runtimeGlobalName,\n runtimeModuleName,\n ssrRuntimeModuleName,\n ssr,\n isTS,\n inSSR,\n source: ast.source,\n code: ``,\n column: 1,\n line: 1,\n offset: 0,\n indentLevel: 0,\n pure: false,\n map: void 0,\n helper(key) {\n return `_${helperNameMap[key]}`;\n },\n push(code, newlineIndex = -2 /* None */, node) {\n context.code += code;\n if (context.map) {\n if (node) {\n let name;\n if (node.type === 4 && !node.isStatic) {\n const content = node.content.replace(/^_ctx\\./, \"\");\n if (content !== node.content && isSimpleIdentifier(content)) {\n name = content;\n }\n }\n if (node.loc.source) {\n addMapping(node.loc.start, name);\n }\n }\n if (newlineIndex === -3 /* Unknown */) {\n advancePositionWithMutation(context, code);\n } else {\n context.offset += code.length;\n if (newlineIndex === -2 /* None */) {\n context.column += code.length;\n } else {\n if (newlineIndex === -1 /* End */) {\n newlineIndex = code.length - 1;\n }\n context.line++;\n context.column = code.length - newlineIndex;\n }\n }\n if (node && node.loc !== locStub && node.loc.source) {\n addMapping(node.loc.end);\n }\n }\n },\n indent() {\n newline(++context.indentLevel);\n },\n deindent(withoutNewLine = false) {\n if (withoutNewLine) {\n --context.indentLevel;\n } else {\n newline(--context.indentLevel);\n }\n },\n newline() {\n newline(context.indentLevel);\n }\n };\n function newline(n) {\n context.push(\"\\n\" + ` `.repeat(n), 0 /* Start */);\n }\n function addMapping(loc, name = null) {\n const { _names, _mappings } = context.map;\n if (name !== null && !_names.has(name)) _names.add(name);\n _mappings.add({\n originalLine: loc.line,\n originalColumn: loc.column - 1,\n // source-map column is 0 based\n generatedLine: context.line,\n generatedColumn: context.column - 1,\n source: filename,\n name\n });\n }\n if (sourceMap) {\n context.map = new sourceMapJs.SourceMapGenerator();\n context.map.setSourceContent(filename, context.source);\n context.map._sources.add(filename);\n }\n return context;\n}\nfunction generate(ast, options = {}) {\n const context = createCodegenContext(ast, options);\n if (options.onContextCreated) options.onContextCreated(context);\n const {\n mode,\n push,\n prefixIdentifiers,\n indent,\n deindent,\n newline,\n scopeId,\n ssr\n } = context;\n const helpers = Array.from(ast.helpers);\n const hasHelpers = helpers.length > 0;\n const useWithBlock = !prefixIdentifiers && mode !== \"module\";\n const genScopeId = scopeId != null && mode === \"module\";\n const isSetupInlined = !!options.inline;\n const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;\n if (mode === \"module\") {\n genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);\n } else {\n genFunctionPreamble(ast, preambleContext);\n }\n const functionName = ssr ? `ssrRender` : `render`;\n const args = ssr ? [\"_ctx\", \"_push\", \"_parent\", \"_attrs\"] : [\"_ctx\", \"_cache\"];\n if (options.bindingMetadata && !options.inline) {\n args.push(\"$props\", \"$setup\", \"$data\", \"$options\");\n }\n const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(\",\") : args.join(\", \");\n if (isSetupInlined) {\n push(`(${signature}) => {`);\n } else {\n push(`function ${functionName}(${signature}) {`);\n }\n indent();\n if (useWithBlock) {\n push(`with (_ctx) {`);\n indent();\n if (hasHelpers) {\n push(\n `const { ${helpers.map(aliasHelper).join(\", \")} } = _Vue\n`,\n -1 /* End */\n );\n newline();\n }\n }\n if (ast.components.length) {\n genAssets(ast.components, \"component\", context);\n if (ast.directives.length || ast.temps > 0) {\n newline();\n }\n }\n if (ast.directives.length) {\n genAssets(ast.directives, \"directive\", context);\n if (ast.temps > 0) {\n newline();\n }\n }\n if (ast.filters && ast.filters.length) {\n newline();\n genAssets(ast.filters, \"filter\", context);\n newline();\n }\n if (ast.temps > 0) {\n push(`let `);\n for (let i = 0; i < ast.temps; i++) {\n push(`${i > 0 ? `, ` : ``}_temp${i}`);\n }\n }\n if (ast.components.length || ast.directives.length || ast.temps) {\n push(`\n`, 0 /* Start */);\n newline();\n }\n if (!ssr) {\n push(`return `);\n }\n if (ast.codegenNode) {\n genNode(ast.codegenNode, context);\n } else {\n push(`null`);\n }\n if (useWithBlock) {\n deindent();\n push(`}`);\n }\n deindent();\n push(`}`);\n return {\n ast,\n code: context.code,\n preamble: isSetupInlined ? preambleContext.code : ``,\n map: context.map ? context.map.toJSON() : void 0\n };\n}\nfunction genFunctionPreamble(ast, context) {\n const {\n ssr,\n prefixIdentifiers,\n push,\n newline,\n runtimeModuleName,\n runtimeGlobalName,\n ssrRuntimeModuleName\n } = context;\n const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;\n const helpers = Array.from(ast.helpers);\n if (helpers.length > 0) {\n if (prefixIdentifiers) {\n push(\n `const { ${helpers.map(aliasHelper).join(\", \")} } = ${VueBinding}\n`,\n -1 /* End */\n );\n } else {\n push(`const _Vue = ${VueBinding}\n`, -1 /* End */);\n if (ast.hoists.length) {\n const staticHelpers = [\n CREATE_VNODE,\n CREATE_ELEMENT_VNODE,\n CREATE_COMMENT,\n CREATE_TEXT,\n CREATE_STATIC\n ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(\", \");\n push(`const { ${staticHelpers} } = _Vue\n`, -1 /* End */);\n }\n }\n }\n if (ast.ssrHelpers && ast.ssrHelpers.length) {\n push(\n `const { ${ast.ssrHelpers.map(aliasHelper).join(\", \")} } = require(\"${ssrRuntimeModuleName}\")\n`,\n -1 /* End */\n );\n }\n genHoists(ast.hoists, context);\n newline();\n push(`return `);\n}\nfunction genModulePreamble(ast, context, genScopeId, inline) {\n const {\n push,\n newline,\n optimizeImports,\n runtimeModuleName,\n ssrRuntimeModuleName\n } = context;\n if (ast.helpers.size) {\n const helpers = Array.from(ast.helpers);\n if (optimizeImports) {\n push(\n `import { ${helpers.map((s) => helperNameMap[s]).join(\", \")} } from ${JSON.stringify(runtimeModuleName)}\n`,\n -1 /* End */\n );\n push(\n `\n// Binding optimization for webpack code-split\nconst ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(\", \")}\n`,\n -1 /* End */\n );\n } else {\n push(\n `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(\", \")} } from ${JSON.stringify(runtimeModuleName)}\n`,\n -1 /* End */\n );\n }\n }\n if (ast.ssrHelpers && ast.ssrHelpers.length) {\n push(\n `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(\", \")} } from \"${ssrRuntimeModuleName}\"\n`,\n -1 /* End */\n );\n }\n if (ast.imports.length) {\n genImports(ast.imports, context);\n newline();\n }\n genHoists(ast.hoists, context);\n newline();\n if (!inline) {\n push(`export `);\n }\n}\nfunction genAssets(assets, type, { helper, push, newline, isTS }) {\n const resolver = helper(\n type === \"filter\" ? RESOLVE_FILTER : type === \"component\" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE\n );\n for (let i = 0; i < assets.length; i++) {\n let id = assets[i];\n const maybeSelfReference = id.endsWith(\"__self\");\n if (maybeSelfReference) {\n id = id.slice(0, -6);\n }\n push(\n `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`\n );\n if (i < assets.length - 1) {\n newline();\n }\n }\n}\nfunction genHoists(hoists, context) {\n if (!hoists.length) {\n return;\n }\n context.pure = true;\n const { push, newline } = context;\n newline();\n for (let i = 0; i < hoists.length; i++) {\n const exp = hoists[i];\n if (exp) {\n push(`const _hoisted_${i + 1} = `);\n genNode(exp, context);\n newline();\n }\n }\n context.pure = false;\n}\nfunction genImports(importsOptions, context) {\n if (!importsOptions.length) {\n return;\n }\n importsOptions.forEach((imports) => {\n context.push(`import `);\n genNode(imports.exp, context);\n context.push(` from '${imports.path}'`);\n context.newline();\n });\n}\nfunction isText(n) {\n return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;\n}\nfunction genNodeListAsArray(nodes, context) {\n const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n));\n context.push(`[`);\n multilines && context.indent();\n genNodeList(nodes, context, multilines);\n multilines && context.deindent();\n context.push(`]`);\n}\nfunction genNodeList(nodes, context, multilines = false, comma = true) {\n const { push, newline } = context;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (shared.isString(node)) {\n push(node, -3 /* Unknown */);\n } else if (shared.isArray(node)) {\n genNodeListAsArray(node, context);\n } else {\n genNode(node, context);\n }\n if (i < nodes.length - 1) {\n if (multilines) {\n comma && push(\",\");\n newline();\n } else {\n comma && push(\", \");\n }\n }\n }\n}\nfunction genNode(node, context) {\n if (shared.isString(node)) {\n context.push(node, -3 /* Unknown */);\n return;\n }\n if (shared.isSymbol(node)) {\n context.push(context.helper(node));\n return;\n }\n switch (node.type) {\n case 1:\n case 9:\n case 11:\n genNode(node.codegenNode, context);\n break;\n case 2:\n genText(node, context);\n break;\n case 4:\n genExpression(node, context);\n break;\n case 5:\n genInterpolation(node, context);\n break;\n case 12:\n genNode(node.codegenNode, context);\n break;\n case 8:\n genCompoundExpression(node, context);\n break;\n case 3:\n genComment(node, context);\n break;\n case 13:\n genVNodeCall(node, context);\n break;\n case 14:\n genCallExpression(node, context);\n break;\n case 15:\n genObjectExpression(node, context);\n break;\n case 17:\n genArrayExpression(node, context);\n break;\n case 18:\n genFunctionExpression(node, context);\n break;\n case 19:\n genConditionalExpression(node, context);\n break;\n case 20:\n genCacheExpression(node, context);\n break;\n case 21:\n genNodeList(node.body, context, true, false);\n break;\n // SSR only types\n case 22:\n genTemplateLiteral(node, context);\n break;\n case 23:\n genIfStatement(node, context);\n break;\n case 24:\n genAssignmentExpression(node, context);\n break;\n case 25:\n genSequenceExpression(node, context);\n break;\n case 26:\n genReturnStatement(node, context);\n break;\n }\n}\nfunction genText(node, context) {\n context.push(JSON.stringify(node.content), -3 /* Unknown */, node);\n}\nfunction genExpression(node, context) {\n const { content, isStatic } = node;\n context.push(\n isStatic ? JSON.stringify(content) : content,\n -3 /* Unknown */,\n node\n );\n}\nfunction genInterpolation(node, context) {\n const { push, helper, pure } = context;\n if (pure) push(PURE_ANNOTATION);\n push(`${helper(TO_DISPLAY_STRING)}(`);\n genNode(node.content, context);\n push(`)`);\n}\nfunction genCompoundExpression(node, context) {\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (shared.isString(child)) {\n context.push(child, -3 /* Unknown */);\n } else {\n genNode(child, context);\n }\n }\n}\nfunction genExpressionAsPropertyKey(node, context) {\n const { push } = context;\n if (node.type === 8) {\n push(`[`);\n genCompoundExpression(node, context);\n push(`]`);\n } else if (node.isStatic) {\n const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);\n push(text, -2 /* None */, node);\n } else {\n push(`[${node.content}]`, -3 /* Unknown */, node);\n }\n}\nfunction genComment(node, context) {\n const { push, helper, pure } = context;\n if (pure) {\n push(PURE_ANNOTATION);\n }\n push(\n `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,\n -3 /* Unknown */,\n node\n );\n}\nfunction genVNodeCall(node, context) {\n const { push, helper, pure } = context;\n const {\n tag,\n props,\n children,\n patchFlag,\n dynamicProps,\n directives,\n isBlock,\n disableTracking,\n isComponent\n } = node;\n let patchFlagString;\n if (patchFlag) {\n {\n patchFlagString = String(patchFlag);\n }\n }\n if (directives) {\n push(helper(WITH_DIRECTIVES) + `(`);\n }\n if (isBlock) {\n push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);\n }\n if (pure) {\n push(PURE_ANNOTATION);\n }\n const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);\n push(helper(callHelper) + `(`, -2 /* None */, node);\n genNodeList(\n genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),\n context\n );\n push(`)`);\n if (isBlock) {\n push(`)`);\n }\n if (directives) {\n push(`, `);\n genNode(directives, context);\n push(`)`);\n }\n}\nfunction genNullableArgs(args) {\n let i = args.length;\n while (i--) {\n if (args[i] != null) break;\n }\n return args.slice(0, i + 1).map((arg) => arg || `null`);\n}\nfunction genCallExpression(node, context) {\n const { push, helper, pure } = context;\n const callee = shared.isString(node.callee) ? node.callee : helper(node.callee);\n if (pure) {\n push(PURE_ANNOTATION);\n }\n push(callee + `(`, -2 /* None */, node);\n genNodeList(node.arguments, context);\n push(`)`);\n}\nfunction genObjectExpression(node, context) {\n const { push, indent, deindent, newline } = context;\n const { properties } = node;\n if (!properties.length) {\n push(`{}`, -2 /* None */, node);\n return;\n }\n const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);\n push(multilines ? `{` : `{ `);\n multilines && indent();\n for (let i = 0; i < properties.length; i++) {\n const { key, value } = properties[i];\n genExpressionAsPropertyKey(key, context);\n push(`: `);\n genNode(value, context);\n if (i < properties.length - 1) {\n push(`,`);\n newline();\n }\n }\n multilines && deindent();\n push(multilines ? `}` : ` }`);\n}\nfunction genArrayExpression(node, context) {\n genNodeListAsArray(node.elements, context);\n}\nfunction genFunctionExpression(node, context) {\n const { push, indent, deindent } = context;\n const { params, returns, body, newline, isSlot } = node;\n if (isSlot) {\n push(`_${helperNameMap[WITH_CTX]}(`);\n }\n push(`(`, -2 /* None */, node);\n if (shared.isArray(params)) {\n genNodeList(params, context);\n } else if (params) {\n genNode(params, context);\n }\n push(`) => `);\n if (newline || body) {\n push(`{`);\n indent();\n }\n if (returns) {\n if (newline) {\n push(`return `);\n }\n if (shared.isArray(returns)) {\n genNodeListAsArray(returns, context);\n } else {\n genNode(returns, context);\n }\n } else if (body) {\n genNode(body, context);\n }\n if (newline || body) {\n deindent();\n push(`}`);\n }\n if (isSlot) {\n if (node.isNonScopedSlot) {\n push(`, undefined, true`);\n }\n push(`)`);\n }\n}\nfunction genConditionalExpression(node, context) {\n const { test, consequent, alternate, newline: needNewline } = node;\n const { push, indent, deindent, newline } = context;\n if (test.type === 4) {\n const needsParens = !isSimpleIdentifier(test.content);\n needsParens && push(`(`);\n genExpression(test, context);\n needsParens && push(`)`);\n } else {\n push(`(`);\n genNode(test, context);\n push(`)`);\n }\n needNewline && indent();\n context.indentLevel++;\n needNewline || push(` `);\n push(`? `);\n genNode(consequent, context);\n context.indentLevel--;\n needNewline && newline();\n needNewline || push(` `);\n push(`: `);\n const isNested = alternate.type === 19;\n if (!isNested) {\n context.indentLevel++;\n }\n genNode(alternate, context);\n if (!isNested) {\n context.indentLevel--;\n }\n needNewline && deindent(\n true\n /* without newline */\n );\n}\nfunction genCacheExpression(node, context) {\n const { push, helper, indent, deindent, newline } = context;\n const { needPauseTracking, needArraySpread } = node;\n if (needArraySpread) {\n push(`[...(`);\n }\n push(`_cache[${node.index}] || (`);\n if (needPauseTracking) {\n indent();\n push(`${helper(SET_BLOCK_TRACKING)}(-1`);\n if (node.inVOnce) push(`, true`);\n push(`),`);\n newline();\n push(`(`);\n }\n push(`_cache[${node.index}] = `);\n genNode(node.value, context);\n if (needPauseTracking) {\n push(`).cacheIndex = ${node.index},`);\n newline();\n push(`${helper(SET_BLOCK_TRACKING)}(1),`);\n newline();\n push(`_cache[${node.index}]`);\n deindent();\n }\n push(`)`);\n if (needArraySpread) {\n push(`)]`);\n }\n}\nfunction genTemplateLiteral(node, context) {\n const { push, indent, deindent } = context;\n push(\"`\");\n const l = node.elements.length;\n const multilines = l > 3;\n for (let i = 0; i < l; i++) {\n const e = node.elements[i];\n if (shared.isString(e)) {\n push(e.replace(/(`|\\$|\\\\)/g, \"\\\\$1\"), -3 /* Unknown */);\n } else {\n push(\"${\");\n if (multilines) indent();\n genNode(e, context);\n if (multilines) deindent();\n push(\"}\");\n }\n }\n push(\"`\");\n}\nfunction genIfStatement(node, context) {\n const { push, indent, deindent } = context;\n const { test, consequent, alternate } = node;\n push(`if (`);\n genNode(test, context);\n push(`) {`);\n indent();\n genNode(consequent, context);\n deindent();\n push(`}`);\n if (alternate) {\n push(` else `);\n if (alternate.type === 23) {\n genIfStatement(alternate, context);\n } else {\n push(`{`);\n indent();\n genNode(alternate, context);\n deindent();\n push(`}`);\n }\n }\n}\nfunction genAssignmentExpression(node, context) {\n genNode(node.left, context);\n context.push(` = `);\n genNode(node.right, context);\n}\nfunction genSequenceExpression(node, context) {\n context.push(`(`);\n genNodeList(node.expressions, context);\n context.push(`)`);\n}\nfunction genReturnStatement({ returns }, context) {\n context.push(`return `);\n if (shared.isArray(returns)) {\n genNodeListAsArray(returns, context);\n } else {\n genNode(returns, context);\n }\n}\n\nconst isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap(\"true,false,null,this\");\nconst transformExpression = (node, context) => {\n if (node.type === 5) {\n node.content = processExpression(\n node.content,\n context\n );\n } else if (node.type === 1) {\n const memo = findDir(node, \"memo\");\n for (let i = 0; i < node.props.length; i++) {\n const dir = node.props[i];\n if (dir.type === 7 && dir.name !== \"for\") {\n const exp = dir.exp;\n const arg = dir.arg;\n if (exp && exp.type === 4 && !(dir.name === \"on\" && arg) && // key has been processed in transformFor(vMemo + vFor)\n !(memo && arg && arg.type === 4 && arg.content === \"key\")) {\n dir.exp = processExpression(\n exp,\n context,\n // slot args must be processed as function params\n dir.name === \"slot\"\n );\n }\n if (arg && arg.type === 4 && !arg.isStatic) {\n dir.arg = processExpression(arg, context);\n }\n }\n }\n }\n};\nfunction processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {\n if (!context.prefixIdentifiers || !node.content.trim()) {\n return node;\n }\n const { inline, bindingMetadata } = context;\n const rewriteIdentifier = (raw, parent, id) => {\n const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw];\n if (inline) {\n const isAssignmentLVal = parent && parent.type === \"AssignmentExpression\" && parent.left === id;\n const isUpdateArg = parent && parent.type === \"UpdateExpression\" && parent.argument === id;\n const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);\n const isNewExpression = parent && isInNewExpression(parentStack);\n const wrapWithUnref = (raw2) => {\n const wrapped = `${context.helperString(UNREF)}(${raw2})`;\n return isNewExpression ? `(${wrapped})` : wrapped;\n };\n if (isConst(type) || type === \"setup-reactive-const\" || localVars[raw]) {\n return raw;\n } else if (type === \"setup-ref\") {\n return `${raw}.value`;\n } else if (type === \"setup-maybe-ref\") {\n return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw);\n } else if (type === \"setup-let\") {\n if (isAssignmentLVal) {\n const { right: rVal, operator } = parent;\n const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);\n const rExpString = stringifyExpression(\n processExpression(\n createSimpleExpression(rExp, false),\n context,\n false,\n false,\n knownIds\n )\n );\n return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;\n } else if (isUpdateArg) {\n id.start = parent.start;\n id.end = parent.end;\n const { prefix: isPrefix, operator } = parent;\n const prefix = isPrefix ? operator : ``;\n const postfix = isPrefix ? `` : operator;\n return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;\n } else if (isDestructureAssignment) {\n return raw;\n } else {\n return wrapWithUnref(raw);\n }\n } else if (type === \"props\") {\n return shared.genPropsAccessExp(raw);\n } else if (type === \"props-aliased\") {\n return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);\n }\n } else {\n if (type && type.startsWith(\"setup\") || type === \"literal-const\") {\n return `$setup.${raw}`;\n } else if (type === \"props-aliased\") {\n return `$props['${bindingMetadata.__propsAliases[raw]}']`;\n } else if (type) {\n return `$${type}.${raw}`;\n }\n }\n return `_ctx.${raw}`;\n };\n const rawExp = node.content;\n let ast = node.ast;\n if (ast === false) {\n return node;\n }\n if (ast === null || !ast && isSimpleIdentifier(rawExp)) {\n const isScopeVarReference = context.identifiers[rawExp];\n const isAllowedGlobal = shared.isGloballyAllowed(rawExp);\n const isLiteral = isLiteralWhitelisted(rawExp);\n if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {\n if (isConst(bindingMetadata[rawExp])) {\n node.constType = 1;\n }\n node.content = rewriteIdentifier(rawExp);\n } else if (!isScopeVarReference) {\n if (isLiteral) {\n node.constType = 3;\n } else {\n node.constType = 2;\n }\n }\n return node;\n }\n if (!ast) {\n const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;\n try {\n ast = parser.parseExpression(source, {\n sourceType: \"module\",\n plugins: context.expressionPlugins\n });\n } catch (e) {\n context.onError(\n createCompilerError(\n 46,\n node.loc,\n void 0,\n e.message\n )\n );\n return node;\n }\n }\n const ids = [];\n const parentStack = [];\n const knownIds = Object.create(context.identifiers);\n walkIdentifiers(\n ast,\n (node2, parent, _, isReferenced, isLocal) => {\n if (isStaticPropertyKey(node2, parent)) {\n return;\n }\n if (node2.name.startsWith(\"_filter_\")) {\n return;\n }\n const needPrefix = isReferenced && canPrefix(node2);\n if (needPrefix && !isLocal) {\n if (isStaticProperty(parent) && parent.shorthand) {\n node2.prefix = `${node2.name}: `;\n }\n node2.name = rewriteIdentifier(node2.name, parent, node2);\n ids.push(node2);\n } else {\n if (!(needPrefix && isLocal) && (!parent || parent.type !== \"CallExpression\" && parent.type !== \"NewExpression\" && parent.type !== \"MemberExpression\")) {\n node2.isConstant = true;\n }\n ids.push(node2);\n }\n },\n true,\n // invoke on ALL identifiers\n parentStack,\n knownIds\n );\n const children = [];\n ids.sort((a, b) => a.start - b.start);\n ids.forEach((id, i) => {\n const start = id.start - 1;\n const end = id.end - 1;\n const last = ids[i - 1];\n const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);\n if (leadingText.length || id.prefix) {\n children.push(leadingText + (id.prefix || ``));\n }\n const source = rawExp.slice(start, end);\n children.push(\n createSimpleExpression(\n id.name,\n false,\n {\n start: advancePositionWithClone(node.loc.start, source, start),\n end: advancePositionWithClone(node.loc.start, source, end),\n source\n },\n id.isConstant ? 3 : 0\n )\n );\n if (i === ids.length - 1 && end < rawExp.length) {\n children.push(rawExp.slice(end));\n }\n });\n let ret;\n if (children.length) {\n ret = createCompoundExpression(children, node.loc);\n ret.ast = ast;\n } else {\n ret = node;\n ret.constType = 3;\n }\n ret.identifiers = Object.keys(knownIds);\n return ret;\n}\nfunction canPrefix(id) {\n if (shared.isGloballyAllowed(id.name)) {\n return false;\n }\n if (id.name === \"require\") {\n return false;\n }\n return true;\n}\nfunction stringifyExpression(exp) {\n if (shared.isString(exp)) {\n return exp;\n } else if (exp.type === 4) {\n return exp.content;\n } else {\n return exp.children.map(stringifyExpression).join(\"\");\n }\n}\nfunction isConst(type) {\n return type === \"setup-const\" || type === \"literal-const\";\n}\n\nconst transformIf = createStructuralDirectiveTransform(\n /^(?:if|else|else-if)$/,\n (node, dir, context) => {\n return processIf(node, dir, context, (ifNode, branch, isRoot) => {\n const siblings = context.parent.children;\n let i = siblings.indexOf(ifNode);\n let key = 0;\n while (i-- >= 0) {\n const sibling = siblings[i];\n if (sibling && sibling.type === 9) {\n key += sibling.branches.length;\n }\n }\n return () => {\n if (isRoot) {\n ifNode.codegenNode = createCodegenNodeForBranch(\n branch,\n key,\n context\n );\n } else {\n const parentCondition = getParentCondition(ifNode.codegenNode);\n parentCondition.alternate = createCodegenNodeForBranch(\n branch,\n key + ifNode.branches.length - 1,\n context\n );\n }\n };\n });\n }\n);\nfunction processIf(node, dir, context, processCodegen) {\n if (dir.name !== \"else\" && (!dir.exp || !dir.exp.content.trim())) {\n const loc = dir.exp ? dir.exp.loc : node.loc;\n context.onError(\n createCompilerError(28, dir.loc)\n );\n dir.exp = createSimpleExpression(`true`, false, loc);\n }\n if (context.prefixIdentifiers && dir.exp) {\n dir.exp = processExpression(dir.exp, context);\n }\n if (dir.name === \"if\") {\n const branch = createIfBranch(node, dir);\n const ifNode = {\n type: 9,\n loc: cloneLoc(node.loc),\n branches: [branch]\n };\n context.replaceNode(ifNode);\n if (processCodegen) {\n return processCodegen(ifNode, branch, true);\n }\n } else {\n const siblings = context.parent.children;\n let i = siblings.indexOf(node);\n while (i-- >= -1) {\n const sibling = siblings[i];\n if (sibling && isCommentOrWhitespace(sibling)) {\n context.removeNode(sibling);\n continue;\n }\n if (sibling && sibling.type === 9) {\n if ((dir.name === \"else-if\" || dir.name === \"else\") && sibling.branches[sibling.branches.length - 1].condition === void 0) {\n context.onError(\n createCompilerError(30, node.loc)\n );\n }\n context.removeNode();\n const branch = createIfBranch(node, dir);\n {\n const key = branch.userKey;\n if (key) {\n sibling.branches.forEach(({ userKey }) => {\n if (isSameKey(userKey, key)) {\n context.onError(\n createCompilerError(\n 29,\n branch.userKey.loc\n )\n );\n }\n });\n }\n }\n sibling.branches.push(branch);\n const onExit = processCodegen && processCodegen(sibling, branch, false);\n traverseNode(branch, context);\n if (onExit) onExit();\n context.currentNode = null;\n } else {\n context.onError(\n createCompilerError(30, node.loc)\n );\n }\n break;\n }\n }\n}\nfunction createIfBranch(node, dir) {\n const isTemplateIf = node.tagType === 3;\n return {\n type: 10,\n loc: node.loc,\n condition: dir.name === \"else\" ? void 0 : dir.exp,\n children: isTemplateIf && !findDir(node, \"for\") ? node.children : [node],\n userKey: findProp(node, `key`),\n isTemplateIf\n };\n}\nfunction createCodegenNodeForBranch(branch, keyIndex, context) {\n if (branch.condition) {\n return createConditionalExpression(\n branch.condition,\n createChildrenCodegenNode(branch, keyIndex, context),\n // make sure to pass in asBlock: true so that the comment node call\n // closes the current block.\n createCallExpression(context.helper(CREATE_COMMENT), [\n '\"\"',\n \"true\"\n ])\n );\n } else {\n return createChildrenCodegenNode(branch, keyIndex, context);\n }\n}\nfunction createChildrenCodegenNode(branch, keyIndex, context) {\n const { helper } = context;\n const keyProperty = createObjectProperty(\n `key`,\n createSimpleExpression(\n `${keyIndex}`,\n false,\n locStub,\n 2\n )\n );\n const { children } = branch;\n const firstChild = children[0];\n const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;\n if (needFragmentWrapper) {\n if (children.length === 1 && firstChild.type === 11) {\n const vnodeCall = firstChild.codegenNode;\n injectProp(vnodeCall, keyProperty, context);\n return vnodeCall;\n } else {\n let patchFlag = 64;\n return createVNodeCall(\n context,\n helper(FRAGMENT),\n createObjectExpression([keyProperty]),\n children,\n patchFlag,\n void 0,\n void 0,\n true,\n false,\n false,\n branch.loc\n );\n }\n } else {\n const ret = firstChild.codegenNode;\n const vnodeCall = getMemoedVNodeCall(ret);\n if (vnodeCall.type === 13) {\n convertToBlock(vnodeCall, context);\n }\n injectProp(vnodeCall, keyProperty, context);\n return ret;\n }\n}\nfunction isSameKey(a, b) {\n if (!a || a.type !== b.type) {\n return false;\n }\n if (a.type === 6) {\n if (a.value.content !== b.value.content) {\n return false;\n }\n } else {\n const exp = a.exp;\n const branchExp = b.exp;\n if (exp.type !== branchExp.type) {\n return false;\n }\n if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {\n return false;\n }\n }\n return true;\n}\nfunction getParentCondition(node) {\n while (true) {\n if (node.type === 19) {\n if (node.alternate.type === 19) {\n node = node.alternate;\n } else {\n return node;\n }\n } else if (node.type === 20) {\n node = node.value;\n }\n }\n}\n\nconst transformFor = createStructuralDirectiveTransform(\n \"for\",\n (node, dir, context) => {\n const { helper, removeHelper } = context;\n return processFor(node, dir, context, (forNode) => {\n const renderExp = createCallExpression(helper(RENDER_LIST), [\n forNode.source\n ]);\n const isTemplate = isTemplateNode(node);\n const memo = findDir(node, \"memo\");\n const keyProp = findProp(node, `key`, false, true);\n const isDirKey = keyProp && keyProp.type === 7;\n let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);\n if (memo && keyExp && isDirKey) {\n {\n keyProp.exp = keyExp = processExpression(\n keyExp,\n context\n );\n }\n }\n const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;\n if (isTemplate) {\n if (memo) {\n memo.exp = processExpression(\n memo.exp,\n context\n );\n }\n if (keyProperty && keyProp.type !== 6) {\n keyProperty.value = processExpression(\n keyProperty.value,\n context\n );\n }\n }\n const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;\n const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;\n forNode.codegenNode = createVNodeCall(\n context,\n helper(FRAGMENT),\n void 0,\n renderExp,\n fragmentFlag,\n void 0,\n void 0,\n true,\n !isStableFragment,\n false,\n node.loc\n );\n return () => {\n let childBlock;\n const { children } = forNode;\n if (isTemplate) {\n node.children.some((c) => {\n if (c.type === 1) {\n const key = findProp(c, \"key\");\n if (key) {\n context.onError(\n createCompilerError(\n 33,\n key.loc\n )\n );\n return true;\n }\n }\n });\n }\n const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;\n const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;\n if (slotOutlet) {\n childBlock = slotOutlet.codegenNode;\n if (isTemplate && keyProperty) {\n injectProp(childBlock, keyProperty, context);\n }\n } else if (needFragmentWrapper) {\n childBlock = createVNodeCall(\n context,\n helper(FRAGMENT),\n keyProperty ? createObjectExpression([keyProperty]) : void 0,\n node.children,\n 64,\n void 0,\n void 0,\n true,\n void 0,\n false\n );\n } else {\n childBlock = children[0].codegenNode;\n if (isTemplate && keyProperty) {\n injectProp(childBlock, keyProperty, context);\n }\n if (childBlock.isBlock !== !isStableFragment) {\n if (childBlock.isBlock) {\n removeHelper(OPEN_BLOCK);\n removeHelper(\n getVNodeBlockHelper(context.inSSR, childBlock.isComponent)\n );\n } else {\n removeHelper(\n getVNodeHelper(context.inSSR, childBlock.isComponent)\n );\n }\n }\n childBlock.isBlock = !isStableFragment;\n if (childBlock.isBlock) {\n helper(OPEN_BLOCK);\n helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));\n } else {\n helper(getVNodeHelper(context.inSSR, childBlock.isComponent));\n }\n }\n if (memo) {\n const loop = createFunctionExpression(\n createForLoopParams(forNode.parseResult, [\n createSimpleExpression(`_cached`)\n ])\n );\n loop.body = createBlockStatement([\n createCompoundExpression([`const _memo = (`, memo.exp, `)`]),\n createCompoundExpression([\n `if (_cached`,\n ...keyExp ? [` && _cached.key === `, keyExp] : [],\n ` && ${context.helperString(\n IS_MEMO_SAME\n )}(_cached, _memo)) return _cached`\n ]),\n createCompoundExpression([`const _item = `, childBlock]),\n createSimpleExpression(`_item.memo = _memo`),\n createSimpleExpression(`return _item`)\n ]);\n renderExp.arguments.push(\n loop,\n createSimpleExpression(`_cache`),\n createSimpleExpression(String(context.cached.length))\n );\n context.cached.push(null);\n } else {\n renderExp.arguments.push(\n createFunctionExpression(\n createForLoopParams(forNode.parseResult),\n childBlock,\n true\n )\n );\n }\n };\n });\n }\n);\nfunction processFor(node, dir, context, processCodegen) {\n if (!dir.exp) {\n context.onError(\n createCompilerError(31, dir.loc)\n );\n return;\n }\n const parseResult = dir.forParseResult;\n if (!parseResult) {\n context.onError(\n createCompilerError(32, dir.loc)\n );\n return;\n }\n finalizeForParseResult(parseResult, context);\n const { addIdentifiers, removeIdentifiers, scopes } = context;\n const { source, value, key, index } = parseResult;\n const forNode = {\n type: 11,\n loc: dir.loc,\n source,\n valueAlias: value,\n keyAlias: key,\n objectIndexAlias: index,\n parseResult,\n children: isTemplateNode(node) ? node.children : [node]\n };\n context.replaceNode(forNode);\n scopes.vFor++;\n if (context.prefixIdentifiers) {\n value && addIdentifiers(value);\n key && addIdentifiers(key);\n index && addIdentifiers(index);\n }\n const onExit = processCodegen && processCodegen(forNode);\n return () => {\n scopes.vFor--;\n if (context.prefixIdentifiers) {\n value && removeIdentifiers(value);\n key && removeIdentifiers(key);\n index && removeIdentifiers(index);\n }\n if (onExit) onExit();\n };\n}\nfunction finalizeForParseResult(result, context) {\n if (result.finalized) return;\n if (context.prefixIdentifiers) {\n result.source = processExpression(\n result.source,\n context\n );\n if (result.key) {\n result.key = processExpression(\n result.key,\n context,\n true\n );\n }\n if (result.index) {\n result.index = processExpression(\n result.index,\n context,\n true\n );\n }\n if (result.value) {\n result.value = processExpression(\n result.value,\n context,\n true\n );\n }\n }\n result.finalized = true;\n}\nfunction createForLoopParams({ value, key, index }, memoArgs = []) {\n return createParamsList([value, key, index, ...memoArgs]);\n}\nfunction createParamsList(args) {\n let i = args.length;\n while (i--) {\n if (args[i]) break;\n }\n return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));\n}\n\nconst defaultFallback = createSimpleExpression(`undefined`, false);\nconst trackSlotScopes = (node, context) => {\n if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {\n const vSlot = findDir(node, \"slot\");\n if (vSlot) {\n const slotProps = vSlot.exp;\n if (context.prefixIdentifiers) {\n slotProps && context.addIdentifiers(slotProps);\n }\n context.scopes.vSlot++;\n return () => {\n if (context.prefixIdentifiers) {\n slotProps && context.removeIdentifiers(slotProps);\n }\n context.scopes.vSlot--;\n };\n }\n }\n};\nconst trackVForSlotScopes = (node, context) => {\n let vFor;\n if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, \"for\"))) {\n const result = vFor.forParseResult;\n if (result) {\n finalizeForParseResult(result, context);\n const { value, key, index } = result;\n const { addIdentifiers, removeIdentifiers } = context;\n value && addIdentifiers(value);\n key && addIdentifiers(key);\n index && addIdentifiers(index);\n return () => {\n value && removeIdentifiers(value);\n key && removeIdentifiers(key);\n index && removeIdentifiers(index);\n };\n }\n }\n};\nconst buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(\n props,\n children,\n false,\n true,\n children.length ? children[0].loc : loc\n);\nfunction buildSlots(node, context, buildSlotFn = buildClientSlotFn) {\n context.helper(WITH_CTX);\n const { children, loc } = node;\n const slotsProperties = [];\n const dynamicSlots = [];\n let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;\n if (!context.ssr && context.prefixIdentifiers) {\n hasDynamicSlots = node.props.some(\n (prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers))\n ) || children.some((child) => hasScopeRef(child, context.identifiers));\n }\n const onComponentSlot = findDir(node, \"slot\", true);\n if (onComponentSlot) {\n const { arg, exp } = onComponentSlot;\n if (arg && !isStaticExp(arg)) {\n hasDynamicSlots = true;\n }\n slotsProperties.push(\n createObjectProperty(\n arg || createSimpleExpression(\"default\", true),\n buildSlotFn(exp, void 0, children, loc)\n )\n );\n }\n let hasTemplateSlots = false;\n let hasNamedDefaultSlot = false;\n const implicitDefaultChildren = [];\n const seenSlotNames = /* @__PURE__ */ new Set();\n let conditionalBranchIndex = 0;\n for (let i = 0; i < children.length; i++) {\n const slotElement = children[i];\n let slotDir;\n if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, \"slot\", true))) {\n if (slotElement.type !== 3) {\n implicitDefaultChildren.push(slotElement);\n }\n continue;\n }\n if (onComponentSlot) {\n context.onError(\n createCompilerError(37, slotDir.loc)\n );\n break;\n }\n hasTemplateSlots = true;\n const { children: slotChildren, loc: slotLoc } = slotElement;\n const {\n arg: slotName = createSimpleExpression(`default`, true),\n exp: slotProps,\n loc: dirLoc\n } = slotDir;\n let staticSlotName;\n if (isStaticExp(slotName)) {\n staticSlotName = slotName ? slotName.content : `default`;\n } else {\n hasDynamicSlots = true;\n }\n const vFor = findDir(slotElement, \"for\");\n const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);\n let vIf;\n let vElse;\n if (vIf = findDir(slotElement, \"if\")) {\n hasDynamicSlots = true;\n dynamicSlots.push(\n createConditionalExpression(\n vIf.exp,\n buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),\n defaultFallback\n )\n );\n } else if (vElse = findDir(\n slotElement,\n /^else(?:-if)?$/,\n true\n /* allowEmpty */\n )) {\n let j = i;\n let prev;\n while (j--) {\n prev = children[j];\n if (!isCommentOrWhitespace(prev)) {\n break;\n }\n }\n if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) {\n let conditional = dynamicSlots[dynamicSlots.length - 1];\n while (conditional.alternate.type === 19) {\n conditional = conditional.alternate;\n }\n conditional.alternate = vElse.exp ? createConditionalExpression(\n vElse.exp,\n buildDynamicSlot(\n slotName,\n slotFunction,\n conditionalBranchIndex++\n ),\n defaultFallback\n ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);\n } else {\n context.onError(\n createCompilerError(30, vElse.loc)\n );\n }\n } else if (vFor) {\n hasDynamicSlots = true;\n const parseResult = vFor.forParseResult;\n if (parseResult) {\n finalizeForParseResult(parseResult, context);\n dynamicSlots.push(\n createCallExpression(context.helper(RENDER_LIST), [\n parseResult.source,\n createFunctionExpression(\n createForLoopParams(parseResult),\n buildDynamicSlot(slotName, slotFunction),\n true\n )\n ])\n );\n } else {\n context.onError(\n createCompilerError(\n 32,\n vFor.loc\n )\n );\n }\n } else {\n if (staticSlotName) {\n if (seenSlotNames.has(staticSlotName)) {\n context.onError(\n createCompilerError(\n 38,\n dirLoc\n )\n );\n continue;\n }\n seenSlotNames.add(staticSlotName);\n if (staticSlotName === \"default\") {\n hasNamedDefaultSlot = true;\n }\n }\n slotsProperties.push(createObjectProperty(slotName, slotFunction));\n }\n }\n if (!onComponentSlot) {\n const buildDefaultSlotProperty = (props, children2) => {\n const fn = buildSlotFn(props, void 0, children2, loc);\n if (context.compatConfig) {\n fn.isNonScopedSlot = true;\n }\n return createObjectProperty(`default`, fn);\n };\n if (!hasTemplateSlots) {\n slotsProperties.push(buildDefaultSlotProperty(void 0, children));\n } else if (implicitDefaultChildren.length && // #3766\n // with whitespace: 'preserve', whitespaces between slots will end up in\n // implicitDefaultChildren. Ignore if all implicit children are whitespaces.\n !implicitDefaultChildren.every(isWhitespaceText)) {\n if (hasNamedDefaultSlot) {\n context.onError(\n createCompilerError(\n 39,\n implicitDefaultChildren[0].loc\n )\n );\n } else {\n slotsProperties.push(\n buildDefaultSlotProperty(void 0, implicitDefaultChildren)\n );\n }\n }\n }\n const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;\n let slots = createObjectExpression(\n slotsProperties.concat(\n createObjectProperty(\n `_`,\n // 2 = compiled but dynamic = can skip normalization, but must run diff\n // 1 = compiled and static = can skip normalization AND diff as optimized\n createSimpleExpression(\n slotFlag + (``),\n false\n )\n )\n ),\n loc\n );\n if (dynamicSlots.length) {\n slots = createCallExpression(context.helper(CREATE_SLOTS), [\n slots,\n createArrayExpression(dynamicSlots)\n ]);\n }\n return {\n slots,\n hasDynamicSlots\n };\n}\nfunction buildDynamicSlot(name, fn, index) {\n const props = [\n createObjectProperty(`name`, name),\n createObjectProperty(`fn`, fn)\n ];\n if (index != null) {\n props.push(\n createObjectProperty(`key`, createSimpleExpression(String(index), true))\n );\n }\n return createObjectExpression(props);\n}\nfunction hasForwardedSlots(children) {\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n switch (child.type) {\n case 1:\n if (child.tagType === 2 || hasForwardedSlots(child.children)) {\n return true;\n }\n break;\n case 9:\n if (hasForwardedSlots(child.branches)) return true;\n break;\n case 10:\n case 11:\n if (hasForwardedSlots(child.children)) return true;\n break;\n }\n }\n return false;\n}\n\nconst directiveImportMap = /* @__PURE__ */ new WeakMap();\nconst transformElement = (node, context) => {\n return function postTransformElement() {\n node = context.currentNode;\n if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {\n return;\n }\n const { tag, props } = node;\n const isComponent = node.tagType === 1;\n let vnodeTag = isComponent ? resolveComponentType(node, context) : `\"${tag}\"`;\n const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;\n let vnodeProps;\n let vnodeChildren;\n let patchFlag = 0;\n let vnodeDynamicProps;\n let dynamicPropNames;\n let vnodeDirectives;\n let shouldUseBlock = (\n // dynamic component may resolve to plain elements\n isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block\n // updates inside get proper isSVG flag at runtime. (#639, #643)\n // This is technically web-specific, but splitting the logic out of core\n // leads to too much unnecessary complexity.\n (tag === \"svg\" || tag === \"foreignObject\" || tag === \"math\")\n );\n if (props.length > 0) {\n const propsBuildResult = buildProps(\n node,\n context,\n void 0,\n isComponent,\n isDynamicComponent\n );\n vnodeProps = propsBuildResult.props;\n patchFlag = propsBuildResult.patchFlag;\n dynamicPropNames = propsBuildResult.dynamicPropNames;\n const directives = propsBuildResult.directives;\n vnodeDirectives = directives && directives.length ? createArrayExpression(\n directives.map((dir) => buildDirectiveArgs(dir, context))\n ) : void 0;\n if (propsBuildResult.shouldUseBlock) {\n shouldUseBlock = true;\n }\n }\n if (node.children.length > 0) {\n if (vnodeTag === KEEP_ALIVE) {\n shouldUseBlock = true;\n patchFlag |= 1024;\n }\n const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling\n vnodeTag !== TELEPORT && // explained above.\n vnodeTag !== KEEP_ALIVE;\n if (shouldBuildAsSlots) {\n const { slots, hasDynamicSlots } = buildSlots(node, context);\n vnodeChildren = slots;\n if (hasDynamicSlots) {\n patchFlag |= 1024;\n }\n } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {\n const child = node.children[0];\n const type = child.type;\n const hasDynamicTextChild = type === 5 || type === 8;\n if (hasDynamicTextChild && getConstantType(child, context) === 0) {\n patchFlag |= 1;\n }\n if (hasDynamicTextChild || type === 2) {\n vnodeChildren = child;\n } else {\n vnodeChildren = node.children;\n }\n } else {\n vnodeChildren = node.children;\n }\n }\n if (dynamicPropNames && dynamicPropNames.length) {\n vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);\n }\n node.codegenNode = createVNodeCall(\n context,\n vnodeTag,\n vnodeProps,\n vnodeChildren,\n patchFlag === 0 ? void 0 : patchFlag,\n vnodeDynamicProps,\n vnodeDirectives,\n !!shouldUseBlock,\n false,\n isComponent,\n node.loc\n );\n };\n};\nfunction resolveComponentType(node, context, ssr = false) {\n let { tag } = node;\n const isExplicitDynamic = isComponentTag(tag);\n const isProp = findProp(\n node,\n \"is\",\n false,\n true\n /* allow empty */\n );\n if (isProp) {\n if (isExplicitDynamic || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n )) {\n let exp;\n if (isProp.type === 6) {\n exp = isProp.value && createSimpleExpression(isProp.value.content, true);\n } else {\n exp = isProp.exp;\n if (!exp) {\n exp = createSimpleExpression(`is`, false, isProp.arg.loc);\n {\n exp = isProp.exp = processExpression(exp, context);\n }\n }\n }\n if (exp) {\n return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [\n exp\n ]);\n }\n } else if (isProp.type === 6 && isProp.value.content.startsWith(\"vue:\")) {\n tag = isProp.value.content.slice(4);\n }\n }\n const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);\n if (builtIn) {\n if (!ssr) context.helper(builtIn);\n return builtIn;\n }\n {\n const fromSetup = resolveSetupReference(tag, context);\n if (fromSetup) {\n return fromSetup;\n }\n const dotIndex = tag.indexOf(\".\");\n if (dotIndex > 0) {\n const ns = resolveSetupReference(tag.slice(0, dotIndex), context);\n if (ns) {\n return ns + tag.slice(dotIndex);\n }\n }\n }\n if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) {\n context.helper(RESOLVE_COMPONENT);\n context.components.add(tag + `__self`);\n return toValidAssetId(tag, `component`);\n }\n context.helper(RESOLVE_COMPONENT);\n context.components.add(tag);\n return toValidAssetId(tag, `component`);\n}\nfunction resolveSetupReference(name, context) {\n const bindings = context.bindingMetadata;\n if (!bindings || bindings.__isScriptSetup === false) {\n return;\n }\n const camelName = shared.camelize(name);\n const PascalName = shared.capitalize(camelName);\n const checkType = (type) => {\n if (bindings[name] === type) {\n return name;\n }\n if (bindings[camelName] === type) {\n return camelName;\n }\n if (bindings[PascalName] === type) {\n return PascalName;\n }\n };\n const fromConst = checkType(\"setup-const\") || checkType(\"setup-reactive-const\") || checkType(\"literal-const\");\n if (fromConst) {\n return context.inline ? (\n // in inline mode, const setup bindings (e.g. imports) can be used as-is\n fromConst\n ) : `$setup[${JSON.stringify(fromConst)}]`;\n }\n const fromMaybeRef = checkType(\"setup-let\") || checkType(\"setup-ref\") || checkType(\"setup-maybe-ref\");\n if (fromMaybeRef) {\n return context.inline ? (\n // setup scope bindings that may be refs need to be unrefed\n `${context.helperString(UNREF)}(${fromMaybeRef})`\n ) : `$setup[${JSON.stringify(fromMaybeRef)}]`;\n }\n const fromProps = checkType(\"props\");\n if (fromProps) {\n return `${context.helperString(UNREF)}(${context.inline ? \"__props\" : \"$props\"}[${JSON.stringify(fromProps)}])`;\n }\n}\nfunction buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {\n const { tag, loc: elementLoc, children } = node;\n let properties = [];\n const mergeArgs = [];\n const runtimeDirectives = [];\n const hasChildren = children.length > 0;\n let shouldUseBlock = false;\n let patchFlag = 0;\n let hasRef = false;\n let hasClassBinding = false;\n let hasStyleBinding = false;\n let hasHydrationEventBinding = false;\n let hasDynamicKeys = false;\n let hasVnodeHook = false;\n const dynamicPropNames = [];\n const pushMergeArg = (arg) => {\n if (properties.length) {\n mergeArgs.push(\n createObjectExpression(dedupeProperties(properties), elementLoc)\n );\n properties = [];\n }\n if (arg) mergeArgs.push(arg);\n };\n const pushRefVForMarker = () => {\n if (context.scopes.vFor > 0) {\n properties.push(\n createObjectProperty(\n createSimpleExpression(\"ref_for\", true),\n createSimpleExpression(\"true\")\n )\n );\n }\n };\n const analyzePatchFlag = ({ key, value }) => {\n if (isStaticExp(key)) {\n const name = key.content;\n const isEventHandler = shared.isOn(name);\n if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click\n // dedicated fast path.\n name.toLowerCase() !== \"onclick\" && // omit v-model handlers\n name !== \"onUpdate:modelValue\" && // omit onVnodeXXX hooks\n !shared.isReservedProp(name)) {\n hasHydrationEventBinding = true;\n }\n if (isEventHandler && shared.isReservedProp(name)) {\n hasVnodeHook = true;\n }\n if (isEventHandler && value.type === 14) {\n value = value.arguments[0];\n }\n if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {\n return;\n }\n if (name === \"ref\") {\n hasRef = true;\n } else if (name === \"class\") {\n hasClassBinding = true;\n } else if (name === \"style\") {\n hasStyleBinding = true;\n } else if (name !== \"key\" && !dynamicPropNames.includes(name)) {\n dynamicPropNames.push(name);\n }\n if (isComponent && (name === \"class\" || name === \"style\") && !dynamicPropNames.includes(name)) {\n dynamicPropNames.push(name);\n }\n } else {\n hasDynamicKeys = true;\n }\n };\n for (let i = 0; i < props.length; i++) {\n const prop = props[i];\n if (prop.type === 6) {\n const { loc, name, nameLoc, value } = prop;\n let isStatic = true;\n if (name === \"ref\") {\n hasRef = true;\n pushRefVForMarker();\n if (value && context.inline) {\n const binding = context.bindingMetadata[value.content];\n if (binding === \"setup-let\" || binding === \"setup-ref\" || binding === \"setup-maybe-ref\") {\n isStatic = false;\n properties.push(\n createObjectProperty(\n createSimpleExpression(\"ref_key\", true),\n createSimpleExpression(value.content, true, value.loc)\n )\n );\n }\n }\n }\n if (name === \"is\" && (isComponentTag(tag) || value && value.content.startsWith(\"vue:\") || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n ))) {\n continue;\n }\n properties.push(\n createObjectProperty(\n createSimpleExpression(name, true, nameLoc),\n createSimpleExpression(\n value ? value.content : \"\",\n isStatic,\n value ? value.loc : loc\n )\n )\n );\n } else {\n const { name, arg, exp, loc, modifiers } = prop;\n const isVBind = name === \"bind\";\n const isVOn = name === \"on\";\n if (name === \"slot\") {\n if (!isComponent) {\n context.onError(\n createCompilerError(40, loc)\n );\n }\n continue;\n }\n if (name === \"once\" || name === \"memo\") {\n continue;\n }\n if (name === \"is\" || isVBind && isStaticArgOf(arg, \"is\") && (isComponentTag(tag) || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n ))) {\n continue;\n }\n if (isVOn && ssr) {\n continue;\n }\n if (\n // #938: elements with dynamic keys should be forced into blocks\n isVBind && isStaticArgOf(arg, \"key\") || // inline before-update hooks need to force block so that it is invoked\n // before children\n isVOn && hasChildren && isStaticArgOf(arg, \"vue:before-update\")\n ) {\n shouldUseBlock = true;\n }\n if (isVBind && isStaticArgOf(arg, \"ref\")) {\n pushRefVForMarker();\n }\n if (!arg && (isVBind || isVOn)) {\n hasDynamicKeys = true;\n if (exp) {\n if (isVBind) {\n {\n pushMergeArg();\n if (isCompatEnabled(\n \"COMPILER_V_BIND_OBJECT_ORDER\",\n context\n )) {\n mergeArgs.unshift(exp);\n continue;\n }\n }\n pushRefVForMarker();\n pushMergeArg();\n mergeArgs.push(exp);\n } else {\n pushMergeArg({\n type: 14,\n loc,\n callee: context.helper(TO_HANDLERS),\n arguments: isComponent ? [exp] : [exp, `true`]\n });\n }\n } else {\n context.onError(\n createCompilerError(\n isVBind ? 34 : 35,\n loc\n )\n );\n }\n continue;\n }\n if (isVBind && modifiers.some((mod) => mod.content === \"prop\")) {\n patchFlag |= 32;\n }\n const directiveTransform = context.directiveTransforms[name];\n if (directiveTransform) {\n const { props: props2, needRuntime } = directiveTransform(prop, node, context);\n !ssr && props2.forEach(analyzePatchFlag);\n if (isVOn && arg && !isStaticExp(arg)) {\n pushMergeArg(createObjectExpression(props2, elementLoc));\n } else {\n properties.push(...props2);\n }\n if (needRuntime) {\n runtimeDirectives.push(prop);\n if (shared.isSymbol(needRuntime)) {\n directiveImportMap.set(prop, needRuntime);\n }\n }\n } else if (!shared.isBuiltInDirective(name)) {\n runtimeDirectives.push(prop);\n if (hasChildren) {\n shouldUseBlock = true;\n }\n }\n }\n }\n let propsExpression = void 0;\n if (mergeArgs.length) {\n pushMergeArg();\n if (mergeArgs.length > 1) {\n propsExpression = createCallExpression(\n context.helper(MERGE_PROPS),\n mergeArgs,\n elementLoc\n );\n } else {\n propsExpression = mergeArgs[0];\n }\n } else if (properties.length) {\n propsExpression = createObjectExpression(\n dedupeProperties(properties),\n elementLoc\n );\n }\n if (hasDynamicKeys) {\n patchFlag |= 16;\n } else {\n if (hasClassBinding && !isComponent) {\n patchFlag |= 2;\n }\n if (hasStyleBinding && !isComponent) {\n patchFlag |= 4;\n }\n if (dynamicPropNames.length) {\n patchFlag |= 8;\n }\n if (hasHydrationEventBinding) {\n patchFlag |= 32;\n }\n }\n if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {\n patchFlag |= 512;\n }\n if (!context.inSSR && propsExpression) {\n switch (propsExpression.type) {\n case 15:\n let classKeyIndex = -1;\n let styleKeyIndex = -1;\n let hasDynamicKey = false;\n for (let i = 0; i < propsExpression.properties.length; i++) {\n const key = propsExpression.properties[i].key;\n if (isStaticExp(key)) {\n if (key.content === \"class\") {\n classKeyIndex = i;\n } else if (key.content === \"style\") {\n styleKeyIndex = i;\n }\n } else if (!key.isHandlerKey) {\n hasDynamicKey = true;\n }\n }\n const classProp = propsExpression.properties[classKeyIndex];\n const styleProp = propsExpression.properties[styleKeyIndex];\n if (!hasDynamicKey) {\n if (classProp && !isStaticExp(classProp.value)) {\n classProp.value = createCallExpression(\n context.helper(NORMALIZE_CLASS),\n [classProp.value]\n );\n }\n if (styleProp && // the static style is compiled into an object,\n // so use `hasStyleBinding` to ensure that it is a dynamic style binding\n (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,\n // v-bind:style with static literal object\n styleProp.value.type === 17)) {\n styleProp.value = createCallExpression(\n context.helper(NORMALIZE_STYLE),\n [styleProp.value]\n );\n }\n } else {\n propsExpression = createCallExpression(\n context.helper(NORMALIZE_PROPS),\n [propsExpression]\n );\n }\n break;\n case 14:\n break;\n default:\n propsExpression = createCallExpression(\n context.helper(NORMALIZE_PROPS),\n [\n createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [\n propsExpression\n ])\n ]\n );\n break;\n }\n }\n return {\n props: propsExpression,\n directives: runtimeDirectives,\n patchFlag,\n dynamicPropNames,\n shouldUseBlock\n };\n}\nfunction dedupeProperties(properties) {\n const knownProps = /* @__PURE__ */ new Map();\n const deduped = [];\n for (let i = 0; i < properties.length; i++) {\n const prop = properties[i];\n if (prop.key.type === 8 || !prop.key.isStatic) {\n deduped.push(prop);\n continue;\n }\n const name = prop.key.content;\n const existing = knownProps.get(name);\n if (existing) {\n if (name === \"style\" || name === \"class\" || shared.isOn(name)) {\n mergeAsArray(existing, prop);\n }\n } else {\n knownProps.set(name, prop);\n deduped.push(prop);\n }\n }\n return deduped;\n}\nfunction mergeAsArray(existing, incoming) {\n if (existing.value.type === 17) {\n existing.value.elements.push(incoming.value);\n } else {\n existing.value = createArrayExpression(\n [existing.value, incoming.value],\n existing.loc\n );\n }\n}\nfunction buildDirectiveArgs(dir, context) {\n const dirArgs = [];\n const runtime = directiveImportMap.get(dir);\n if (runtime) {\n dirArgs.push(context.helperString(runtime));\n } else {\n const fromSetup = resolveSetupReference(\"v-\" + dir.name, context);\n if (fromSetup) {\n dirArgs.push(fromSetup);\n } else {\n context.helper(RESOLVE_DIRECTIVE);\n context.directives.add(dir.name);\n dirArgs.push(toValidAssetId(dir.name, `directive`));\n }\n }\n const { loc } = dir;\n if (dir.exp) dirArgs.push(dir.exp);\n if (dir.arg) {\n if (!dir.exp) {\n dirArgs.push(`void 0`);\n }\n dirArgs.push(dir.arg);\n }\n if (Object.keys(dir.modifiers).length) {\n if (!dir.arg) {\n if (!dir.exp) {\n dirArgs.push(`void 0`);\n }\n dirArgs.push(`void 0`);\n }\n const trueExpression = createSimpleExpression(`true`, false, loc);\n dirArgs.push(\n createObjectExpression(\n dir.modifiers.map(\n (modifier) => createObjectProperty(modifier, trueExpression)\n ),\n loc\n )\n );\n }\n return createArrayExpression(dirArgs, dir.loc);\n}\nfunction stringifyDynamicPropNames(props) {\n let propsNamesString = `[`;\n for (let i = 0, l = props.length; i < l; i++) {\n propsNamesString += JSON.stringify(props[i]);\n if (i < l - 1) propsNamesString += \", \";\n }\n return propsNamesString + `]`;\n}\nfunction isComponentTag(tag) {\n return tag === \"component\" || tag === \"Component\";\n}\n\nconst transformSlotOutlet = (node, context) => {\n if (isSlotOutlet(node)) {\n const { children, loc } = node;\n const { slotName, slotProps } = processSlotOutlet(node, context);\n const slotArgs = [\n context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,\n slotName,\n \"{}\",\n \"undefined\",\n \"true\"\n ];\n let expectedLen = 2;\n if (slotProps) {\n slotArgs[2] = slotProps;\n expectedLen = 3;\n }\n if (children.length) {\n slotArgs[3] = createFunctionExpression([], children, false, false, loc);\n expectedLen = 4;\n }\n if (context.scopeId && !context.slotted) {\n expectedLen = 5;\n }\n slotArgs.splice(expectedLen);\n node.codegenNode = createCallExpression(\n context.helper(RENDER_SLOT),\n slotArgs,\n loc\n );\n }\n};\nfunction processSlotOutlet(node, context) {\n let slotName = `\"default\"`;\n let slotProps = void 0;\n const nonNameProps = [];\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n if (p.value) {\n if (p.name === \"name\") {\n slotName = JSON.stringify(p.value.content);\n } else {\n p.name = shared.camelize(p.name);\n nonNameProps.push(p);\n }\n }\n } else {\n if (p.name === \"bind\" && isStaticArgOf(p.arg, \"name\")) {\n if (p.exp) {\n slotName = p.exp;\n } else if (p.arg && p.arg.type === 4) {\n const name = shared.camelize(p.arg.content);\n slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);\n {\n slotName = p.exp = processExpression(p.exp, context);\n }\n }\n } else {\n if (p.name === \"bind\" && p.arg && isStaticExp(p.arg)) {\n p.arg.content = shared.camelize(p.arg.content);\n }\n nonNameProps.push(p);\n }\n }\n }\n if (nonNameProps.length > 0) {\n const { props, directives } = buildProps(\n node,\n context,\n nonNameProps,\n false,\n false\n );\n slotProps = props;\n if (directives.length) {\n context.onError(\n createCompilerError(\n 36,\n directives[0].loc\n )\n );\n }\n }\n return {\n slotName,\n slotProps\n };\n}\n\nconst transformOn = (dir, node, context, augmentor) => {\n const { loc, modifiers, arg } = dir;\n if (!dir.exp && !modifiers.length) {\n context.onError(createCompilerError(35, loc));\n }\n let eventName;\n if (arg.type === 4) {\n if (arg.isStatic) {\n let rawName = arg.content;\n if (rawName.startsWith(\"vue:\")) {\n rawName = `vnode-${rawName.slice(4)}`;\n }\n const eventString = node.tagType !== 0 || rawName.startsWith(\"vnode\") || !/[A-Z]/.test(rawName) ? (\n // for non-element and vnode lifecycle event listeners, auto convert\n // it to camelCase. See issue #2249\n shared.toHandlerKey(shared.camelize(rawName))\n ) : (\n // preserve case for plain element listeners that have uppercase\n // letters, as these may be custom elements' custom events\n `on:${rawName}`\n );\n eventName = createSimpleExpression(eventString, true, arg.loc);\n } else {\n eventName = createCompoundExpression([\n `${context.helperString(TO_HANDLER_KEY)}(`,\n arg,\n `)`\n ]);\n }\n } else {\n eventName = arg;\n eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);\n eventName.children.push(`)`);\n }\n let exp = dir.exp;\n if (exp && !exp.content.trim()) {\n exp = void 0;\n }\n let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;\n if (exp) {\n const isMemberExp = isMemberExpression(exp, context);\n const isInlineStatement = !(isMemberExp || isFnExpression(exp, context));\n const hasMultipleStatements = exp.content.includes(`;`);\n if (context.prefixIdentifiers) {\n isInlineStatement && context.addIdentifiers(`$event`);\n exp = dir.exp = processExpression(\n exp,\n context,\n false,\n hasMultipleStatements\n );\n isInlineStatement && context.removeIdentifiers(`$event`);\n shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once\n !context.inVOnce && // runtime constants don't need to be cached\n // (this is analyzed by compileScript in SFC <script setup>)\n !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -\n // we need to use the original function to preserve arity,\n // e.g. <transition> relies on checking cb.length to determine\n // transition end handling. Inline function is ok since its arity\n // is preserved even when cached.\n !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)\n // it must be passed fresh to avoid stale values.\n !hasScopeRef(exp, context.identifiers);\n if (shouldCache && isMemberExp) {\n if (exp.type === 4) {\n exp.content = `${exp.content} && ${exp.content}(...args)`;\n } else {\n exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];\n }\n }\n }\n if (isInlineStatement || shouldCache && isMemberExp) {\n exp = createCompoundExpression([\n `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `\n//@ts-ignore\n` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,\n exp,\n hasMultipleStatements ? `}` : `)`\n ]);\n }\n }\n let ret = {\n props: [\n createObjectProperty(\n eventName,\n exp || createSimpleExpression(`() => {}`, false, loc)\n )\n ]\n };\n if (augmentor) {\n ret = augmentor(ret);\n }\n if (shouldCache) {\n ret.props[0].value = context.cache(ret.props[0].value);\n }\n ret.props.forEach((p) => p.key.isHandlerKey = true);\n return ret;\n};\n\nconst transformBind = (dir, _node, context) => {\n const { modifiers, loc } = dir;\n const arg = dir.arg;\n let { exp } = dir;\n if (exp && exp.type === 4 && !exp.content.trim()) {\n {\n context.onError(\n createCompilerError(34, loc)\n );\n return {\n props: [\n createObjectProperty(arg, createSimpleExpression(\"\", true, loc))\n ]\n };\n }\n }\n if (arg.type !== 4) {\n arg.children.unshift(`(`);\n arg.children.push(`) || \"\"`);\n } else if (!arg.isStatic) {\n arg.content = arg.content ? `${arg.content} || \"\"` : `\"\"`;\n }\n if (modifiers.some((mod) => mod.content === \"camel\")) {\n if (arg.type === 4) {\n if (arg.isStatic) {\n arg.content = shared.camelize(arg.content);\n } else {\n arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;\n }\n } else {\n arg.children.unshift(`${context.helperString(CAMELIZE)}(`);\n arg.children.push(`)`);\n }\n }\n if (!context.inSSR) {\n if (modifiers.some((mod) => mod.content === \"prop\")) {\n injectPrefix(arg, \".\");\n }\n if (modifiers.some((mod) => mod.content === \"attr\")) {\n injectPrefix(arg, \"^\");\n }\n }\n return {\n props: [createObjectProperty(arg, exp)]\n };\n};\nconst injectPrefix = (arg, prefix) => {\n if (arg.type === 4) {\n if (arg.isStatic) {\n arg.content = prefix + arg.content;\n } else {\n arg.content = `\\`${prefix}\\${${arg.content}}\\``;\n }\n } else {\n arg.children.unshift(`'${prefix}' + (`);\n arg.children.push(`)`);\n }\n};\n\nconst transformText = (node, context) => {\n if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {\n return () => {\n const children = node.children;\n let currentContainer = void 0;\n let hasText = false;\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (isText$1(child)) {\n hasText = true;\n for (let j = i + 1; j < children.length; j++) {\n const next = children[j];\n if (isText$1(next)) {\n if (!currentContainer) {\n currentContainer = children[i] = createCompoundExpression(\n [child],\n child.loc\n );\n }\n currentContainer.children.push(` + `, next);\n children.splice(j, 1);\n j--;\n } else {\n currentContainer = void 0;\n break;\n }\n }\n }\n }\n if (!hasText || // if this is a plain element with a single text child, leave it\n // as-is since the runtime has dedicated fast path for this by directly\n // setting textContent of the element.\n // for component root it's always normalized anyway.\n children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756\n // custom directives can potentially add DOM elements arbitrarily,\n // we need to avoid setting textContent of the element at runtime\n // to avoid accidentally overwriting the DOM elements added\n // by the user through custom directives.\n !node.props.find(\n (p) => p.type === 7 && !context.directiveTransforms[p.name]\n ) && // in compat mode, <template> tags with no special directives\n // will be rendered as a fragment so its children must be\n // converted into vnodes.\n !(node.tag === \"template\"))) {\n return;\n }\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (isText$1(child) || child.type === 8) {\n const callArgs = [];\n if (child.type !== 2 || child.content !== \" \") {\n callArgs.push(child);\n }\n if (!context.ssr && getConstantType(child, context) === 0) {\n callArgs.push(\n 1 + (``)\n );\n }\n children[i] = {\n type: 12,\n content: child,\n loc: child.loc,\n codegenNode: createCallExpression(\n context.helper(CREATE_TEXT),\n callArgs\n )\n };\n }\n }\n };\n }\n};\n\nconst seen$1 = /* @__PURE__ */ new WeakSet();\nconst transformOnce = (node, context) => {\n if (node.type === 1 && findDir(node, \"once\", true)) {\n if (seen$1.has(node) || context.inVOnce || context.inSSR) {\n return;\n }\n seen$1.add(node);\n context.inVOnce = true;\n context.helper(SET_BLOCK_TRACKING);\n return () => {\n context.inVOnce = false;\n const cur = context.currentNode;\n if (cur.codegenNode) {\n cur.codegenNode = context.cache(\n cur.codegenNode,\n true,\n true\n );\n }\n };\n }\n};\n\nconst transformModel = (dir, node, context) => {\n const { exp, arg } = dir;\n if (!exp) {\n context.onError(\n createCompilerError(41, dir.loc)\n );\n return createTransformProps();\n }\n const rawExp = exp.loc.source.trim();\n const expString = exp.type === 4 ? exp.content : rawExp;\n const bindingType = context.bindingMetadata[rawExp];\n if (bindingType === \"props\" || bindingType === \"props-aliased\") {\n context.onError(createCompilerError(44, exp.loc));\n return createTransformProps();\n }\n if (bindingType === \"literal-const\" || bindingType === \"setup-const\") {\n context.onError(createCompilerError(45, exp.loc));\n return createTransformProps();\n }\n const maybeRef = context.inline && (bindingType === \"setup-let\" || bindingType === \"setup-ref\" || bindingType === \"setup-maybe-ref\");\n if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) {\n context.onError(\n createCompilerError(42, exp.loc)\n );\n return createTransformProps();\n }\n if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {\n context.onError(\n createCompilerError(43, exp.loc)\n );\n return createTransformProps();\n }\n const propName = arg ? arg : createSimpleExpression(\"modelValue\", true);\n const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['\"onUpdate:\" + ', arg]) : `onUpdate:modelValue`;\n let assignmentExp;\n const eventArg = context.isTS ? `($event: any)` : `$event`;\n if (maybeRef) {\n if (bindingType === \"setup-ref\") {\n assignmentExp = createCompoundExpression([\n `${eventArg} => ((`,\n createSimpleExpression(rawExp, false, exp.loc),\n `).value = $event)`\n ]);\n } else {\n const altAssignment = bindingType === \"setup-let\" ? `${rawExp} = $event` : `null`;\n assignmentExp = createCompoundExpression([\n `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,\n createSimpleExpression(rawExp, false, exp.loc),\n `).value = $event : ${altAssignment})`\n ]);\n }\n } else {\n assignmentExp = createCompoundExpression([\n `${eventArg} => ((`,\n exp,\n `) = $event)`\n ]);\n }\n const props = [\n // modelValue: foo\n createObjectProperty(propName, dir.exp),\n // \"onUpdate:modelValue\": $event => (foo = $event)\n createObjectProperty(eventName, assignmentExp)\n ];\n if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {\n props[1].value = context.cache(props[1].value);\n }\n if (dir.modifiers.length && node.tagType === 1) {\n const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);\n const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + \"Modifiers\"']) : `modelModifiers`;\n props.push(\n createObjectProperty(\n modifiersKey,\n createSimpleExpression(\n `{ ${modifiers} }`,\n false,\n dir.loc,\n 2\n )\n )\n );\n }\n return createTransformProps(props);\n};\nfunction createTransformProps(props = []) {\n return { props };\n}\n\nconst validDivisionCharRE = /[\\w).+\\-_$\\]]/;\nconst transformFilter = (node, context) => {\n if (!isCompatEnabled(\"COMPILER_FILTERS\", context)) {\n return;\n }\n if (node.type === 5) {\n rewriteFilter(node.content, context);\n } else if (node.type === 1) {\n node.props.forEach((prop) => {\n if (prop.type === 7 && prop.name !== \"for\" && prop.exp) {\n rewriteFilter(prop.exp, context);\n }\n });\n }\n};\nfunction rewriteFilter(node, context) {\n if (node.type === 4) {\n parseFilter(node, context);\n } else {\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (typeof child !== \"object\") continue;\n if (child.type === 4) {\n parseFilter(child, context);\n } else if (child.type === 8) {\n rewriteFilter(node, context);\n } else if (child.type === 5) {\n rewriteFilter(child.content, context);\n }\n }\n }\n}\nfunction parseFilter(node, context) {\n const exp = node.content;\n let inSingle = false;\n let inDouble = false;\n let inTemplateString = false;\n let inRegex = false;\n let curly = 0;\n let square = 0;\n let paren = 0;\n let lastFilterIndex = 0;\n let c, prev, i, expression, filters = [];\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 39 && prev !== 92) inSingle = false;\n } else if (inDouble) {\n if (c === 34 && prev !== 92) inDouble = false;\n } else if (inTemplateString) {\n if (c === 96 && prev !== 92) inTemplateString = false;\n } else if (inRegex) {\n if (c === 47 && prev !== 92) inRegex = false;\n } else if (c === 124 && // pipe\n exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {\n if (expression === void 0) {\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 34:\n inDouble = true;\n break;\n // \"\n case 39:\n inSingle = true;\n break;\n // '\n case 96:\n inTemplateString = true;\n break;\n // `\n case 40:\n paren++;\n break;\n // (\n case 41:\n paren--;\n break;\n // )\n case 91:\n square++;\n break;\n // [\n case 93:\n square--;\n break;\n // ]\n case 123:\n curly++;\n break;\n // {\n case 125:\n curly--;\n break;\n }\n if (c === 47) {\n let j = i - 1;\n let p;\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== \" \") break;\n }\n if (!p || !validDivisionCharRE.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n if (expression === void 0) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n function pushFilter() {\n filters.push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n if (filters.length) {\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i], context);\n }\n node.content = expression;\n node.ast = void 0;\n }\n}\nfunction wrapFilter(exp, filter, context) {\n context.helper(RESOLVE_FILTER);\n const i = filter.indexOf(\"(\");\n if (i < 0) {\n context.filters.add(filter);\n return `${toValidAssetId(filter, \"filter\")}(${exp})`;\n } else {\n const name = filter.slice(0, i);\n const args = filter.slice(i + 1);\n context.filters.add(name);\n return `${toValidAssetId(name, \"filter\")}(${exp}${args !== \")\" ? \",\" + args : args}`;\n }\n}\n\nconst seen = /* @__PURE__ */ new WeakSet();\nconst transformMemo = (node, context) => {\n if (node.type === 1) {\n const dir = findDir(node, \"memo\");\n if (!dir || seen.has(node) || context.inSSR) {\n return;\n }\n seen.add(node);\n return () => {\n const codegenNode = node.codegenNode || context.currentNode.codegenNode;\n if (codegenNode && codegenNode.type === 13) {\n if (node.tagType !== 1) {\n convertToBlock(codegenNode, context);\n }\n node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [\n dir.exp,\n createFunctionExpression(void 0, codegenNode),\n `_cache`,\n String(context.cached.length)\n ]);\n context.cached.push(null);\n }\n };\n }\n};\n\nconst transformVBindShorthand = (node, context) => {\n if (node.type === 1) {\n for (const prop of node.props) {\n if (prop.type === 7 && prop.name === \"bind\" && (!prop.exp || // #13930 :foo in in-DOM templates will be parsed into :foo=\"\" by browser\n false) && prop.arg) {\n const arg = prop.arg;\n if (arg.type !== 4 || !arg.isStatic) {\n context.onError(\n createCompilerError(\n 53,\n arg.loc\n )\n );\n prop.exp = createSimpleExpression(\"\", true, arg.loc);\n } else {\n const propName = shared.camelize(arg.content);\n if (validFirstIdentCharRE.test(propName[0]) || // allow hyphen first char for https://github.com/vuejs/language-tools/pull/3424\n propName[0] === \"-\") {\n prop.exp = createSimpleExpression(propName, false, arg.loc);\n }\n }\n }\n }\n }\n};\n\nfunction getBaseTransformPreset(prefixIdentifiers) {\n return [\n [\n transformVBindShorthand,\n transformOnce,\n transformIf,\n transformMemo,\n transformFor,\n ...[transformFilter] ,\n ...prefixIdentifiers ? [\n // order is important\n trackVForSlotScopes,\n transformExpression\n ] : [],\n transformSlotOutlet,\n transformElement,\n trackSlotScopes,\n transformText\n ],\n {\n on: transformOn,\n bind: transformBind,\n model: transformModel\n }\n ];\n}\nfunction baseCompile(source, options = {}) {\n const onError = options.onError || defaultOnError;\n const isModuleMode = options.mode === \"module\";\n const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;\n if (!prefixIdentifiers && options.cacheHandlers) {\n onError(createCompilerError(50));\n }\n if (options.scopeId && !isModuleMode) {\n onError(createCompilerError(51));\n }\n const resolvedOptions = shared.extend({}, options, {\n prefixIdentifiers\n });\n const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source;\n const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);\n if (options.isTS) {\n const { expressionPlugins } = options;\n if (!expressionPlugins || !expressionPlugins.includes(\"typescript\")) {\n options.expressionPlugins = [...expressionPlugins || [], \"typescript\"];\n }\n }\n transform(\n ast,\n shared.extend({}, resolvedOptions, {\n nodeTransforms: [\n ...nodeTransforms,\n ...options.nodeTransforms || []\n // user transforms\n ],\n directiveTransforms: shared.extend(\n {},\n directiveTransforms,\n options.directiveTransforms || {}\n // user transforms\n )\n })\n );\n return generate(ast, resolvedOptions);\n}\n\nconst BindingTypes = {\n \"DATA\": \"data\",\n \"PROPS\": \"props\",\n \"PROPS_ALIASED\": \"props-aliased\",\n \"SETUP_LET\": \"setup-let\",\n \"SETUP_CONST\": \"setup-const\",\n \"SETUP_REACTIVE_CONST\": \"setup-reactive-const\",\n \"SETUP_MAYBE_REF\": \"setup-maybe-ref\",\n \"SETUP_REF\": \"setup-ref\",\n \"OPTIONS\": \"options\",\n \"LITERAL_CONST\": \"literal-const\"\n};\n\nconst noopDirectiveTransform = () => ({ props: [] });\n\nexports.generateCodeFrame = shared.generateCodeFrame;\nexports.BASE_TRANSITION = BASE_TRANSITION;\nexports.BindingTypes = BindingTypes;\nexports.CAMELIZE = CAMELIZE;\nexports.CAPITALIZE = CAPITALIZE;\nexports.CREATE_BLOCK = CREATE_BLOCK;\nexports.CREATE_COMMENT = CREATE_COMMENT;\nexports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK;\nexports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE;\nexports.CREATE_SLOTS = CREATE_SLOTS;\nexports.CREATE_STATIC = CREATE_STATIC;\nexports.CREATE_TEXT = CREATE_TEXT;\nexports.CREATE_VNODE = CREATE_VNODE;\nexports.CompilerDeprecationTypes = CompilerDeprecationTypes;\nexports.ConstantTypes = ConstantTypes;\nexports.ElementTypes = ElementTypes;\nexports.ErrorCodes = ErrorCodes;\nexports.FRAGMENT = FRAGMENT;\nexports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS;\nexports.IS_MEMO_SAME = IS_MEMO_SAME;\nexports.IS_REF = IS_REF;\nexports.KEEP_ALIVE = KEEP_ALIVE;\nexports.MERGE_PROPS = MERGE_PROPS;\nexports.NORMALIZE_CLASS = NORMALIZE_CLASS;\nexports.NORMALIZE_PROPS = NORMALIZE_PROPS;\nexports.NORMALIZE_STYLE = NORMALIZE_STYLE;\nexports.Namespaces = Namespaces;\nexports.NodeTypes = NodeTypes;\nexports.OPEN_BLOCK = OPEN_BLOCK;\nexports.POP_SCOPE_ID = POP_SCOPE_ID;\nexports.PUSH_SCOPE_ID = PUSH_SCOPE_ID;\nexports.RENDER_LIST = RENDER_LIST;\nexports.RENDER_SLOT = RENDER_SLOT;\nexports.RESOLVE_COMPONENT = RESOLVE_COMPONENT;\nexports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE;\nexports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT;\nexports.RESOLVE_FILTER = RESOLVE_FILTER;\nexports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING;\nexports.SUSPENSE = SUSPENSE;\nexports.TELEPORT = TELEPORT;\nexports.TO_DISPLAY_STRING = TO_DISPLAY_STRING;\nexports.TO_HANDLERS = TO_HANDLERS;\nexports.TO_HANDLER_KEY = TO_HANDLER_KEY;\nexports.TS_NODE_TYPES = TS_NODE_TYPES;\nexports.UNREF = UNREF;\nexports.WITH_CTX = WITH_CTX;\nexports.WITH_DIRECTIVES = WITH_DIRECTIVES;\nexports.WITH_MEMO = WITH_MEMO;\nexports.advancePositionWithClone = advancePositionWithClone;\nexports.advancePositionWithMutation = advancePositionWithMutation;\nexports.assert = assert;\nexports.baseCompile = baseCompile;\nexports.baseParse = baseParse;\nexports.buildDirectiveArgs = buildDirectiveArgs;\nexports.buildProps = buildProps;\nexports.buildSlots = buildSlots;\nexports.checkCompatEnabled = checkCompatEnabled;\nexports.convertToBlock = convertToBlock;\nexports.createArrayExpression = createArrayExpression;\nexports.createAssignmentExpression = createAssignmentExpression;\nexports.createBlockStatement = createBlockStatement;\nexports.createCacheExpression = createCacheExpression;\nexports.createCallExpression = createCallExpression;\nexports.createCompilerError = createCompilerError;\nexports.createCompoundExpression = createCompoundExpression;\nexports.createConditionalExpression = createConditionalExpression;\nexports.createForLoopParams = createForLoopParams;\nexports.createFunctionExpression = createFunctionExpression;\nexports.createIfStatement = createIfStatement;\nexports.createInterpolation = createInterpolation;\nexports.createObjectExpression = createObjectExpression;\nexports.createObjectProperty = createObjectProperty;\nexports.createReturnStatement = createReturnStatement;\nexports.createRoot = createRoot;\nexports.createSequenceExpression = createSequenceExpression;\nexports.createSimpleExpression = createSimpleExpression;\nexports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;\nexports.createTemplateLiteral = createTemplateLiteral;\nexports.createTransformContext = createTransformContext;\nexports.createVNodeCall = createVNodeCall;\nexports.errorMessages = errorMessages;\nexports.extractIdentifiers = extractIdentifiers;\nexports.findDir = findDir;\nexports.findProp = findProp;\nexports.forAliasRE = forAliasRE;\nexports.generate = generate;\nexports.getBaseTransformPreset = getBaseTransformPreset;\nexports.getConstantType = getConstantType;\nexports.getMemoedVNodeCall = getMemoedVNodeCall;\nexports.getVNodeBlockHelper = getVNodeBlockHelper;\nexports.getVNodeHelper = getVNodeHelper;\nexports.hasDynamicKeyVBind = hasDynamicKeyVBind;\nexports.hasScopeRef = hasScopeRef;\nexports.helperNameMap = helperNameMap;\nexports.injectProp = injectProp;\nexports.isAllWhitespace = isAllWhitespace;\nexports.isCommentOrWhitespace = isCommentOrWhitespace;\nexports.isCoreComponent = isCoreComponent;\nexports.isFnExpression = isFnExpression;\nexports.isFnExpressionBrowser = isFnExpressionBrowser;\nexports.isFnExpressionNode = isFnExpressionNode;\nexports.isFunctionType = isFunctionType;\nexports.isInDestructureAssignment = isInDestructureAssignment;\nexports.isInNewExpression = isInNewExpression;\nexports.isMemberExpression = isMemberExpression;\nexports.isMemberExpressionBrowser = isMemberExpressionBrowser;\nexports.isMemberExpressionNode = isMemberExpressionNode;\nexports.isReferencedIdentifier = isReferencedIdentifier;\nexports.isSimpleIdentifier = isSimpleIdentifier;\nexports.isSlotOutlet = isSlotOutlet;\nexports.isStaticArgOf = isStaticArgOf;\nexports.isStaticExp = isStaticExp;\nexports.isStaticProperty = isStaticProperty;\nexports.isStaticPropertyKey = isStaticPropertyKey;\nexports.isTemplateNode = isTemplateNode;\nexports.isText = isText$1;\nexports.isVPre = isVPre;\nexports.isVSlot = isVSlot;\nexports.isWhitespaceText = isWhitespaceText;\nexports.locStub = locStub;\nexports.noopDirectiveTransform = noopDirectiveTransform;\nexports.processExpression = processExpression;\nexports.processFor = processFor;\nexports.processIf = processIf;\nexports.processSlotOutlet = processSlotOutlet;\nexports.registerRuntimeHelpers = registerRuntimeHelpers;\nexports.resolveComponentType = resolveComponentType;\nexports.stringifyExpression = stringifyExpression;\nexports.toValidAssetId = toValidAssetId;\nexports.trackSlotScopes = trackSlotScopes;\nexports.trackVForSlotScopes = trackVForSlotScopes;\nexports.transform = transform;\nexports.transformBind = transformBind;\nexports.transformElement = transformElement;\nexports.transformExpression = transformExpression;\nexports.transformModel = transformModel;\nexports.transformOn = transformOn;\nexports.transformVBindShorthand = transformVBindShorthand;\nexports.traverseNode = traverseNode;\nexports.unwrapTSNode = unwrapTSNode;\nexports.validFirstIdentCharRE = validFirstIdentCharRE;\nexports.walkBlockDeclarations = walkBlockDeclarations;\nexports.walkFunctionParams = walkFunctionParams;\nexports.walkIdentifiers = walkIdentifiers;\nexports.warnDeprecation = warnDeprecation;\n","/**\n* @vue/compiler-core v3.5.28\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\n* @license MIT\n**/\n\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar shared = require('@vue/shared');\nvar decode = require('entities/decode');\nvar parser = require('@babel/parser');\nvar estreeWalker = require('estree-walker');\nvar sourceMapJs = require('source-map-js');\n\nconst FRAGMENT = /* @__PURE__ */ Symbol(`Fragment` );\nconst TELEPORT = /* @__PURE__ */ Symbol(`Teleport` );\nconst SUSPENSE = /* @__PURE__ */ Symbol(`Suspense` );\nconst KEEP_ALIVE = /* @__PURE__ */ Symbol(`KeepAlive` );\nconst BASE_TRANSITION = /* @__PURE__ */ Symbol(\n `BaseTransition` \n);\nconst OPEN_BLOCK = /* @__PURE__ */ Symbol(`openBlock` );\nconst CREATE_BLOCK = /* @__PURE__ */ Symbol(`createBlock` );\nconst CREATE_ELEMENT_BLOCK = /* @__PURE__ */ Symbol(\n `createElementBlock` \n);\nconst CREATE_VNODE = /* @__PURE__ */ Symbol(`createVNode` );\nconst CREATE_ELEMENT_VNODE = /* @__PURE__ */ Symbol(\n `createElementVNode` \n);\nconst CREATE_COMMENT = /* @__PURE__ */ Symbol(\n `createCommentVNode` \n);\nconst CREATE_TEXT = /* @__PURE__ */ Symbol(\n `createTextVNode` \n);\nconst CREATE_STATIC = /* @__PURE__ */ Symbol(\n `createStaticVNode` \n);\nconst RESOLVE_COMPONENT = /* @__PURE__ */ Symbol(\n `resolveComponent` \n);\nconst RESOLVE_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol(\n `resolveDynamicComponent` \n);\nconst RESOLVE_DIRECTIVE = /* @__PURE__ */ Symbol(\n `resolveDirective` \n);\nconst RESOLVE_FILTER = /* @__PURE__ */ Symbol(\n `resolveFilter` \n);\nconst WITH_DIRECTIVES = /* @__PURE__ */ Symbol(\n `withDirectives` \n);\nconst RENDER_LIST = /* @__PURE__ */ Symbol(`renderList` );\nconst RENDER_SLOT = /* @__PURE__ */ Symbol(`renderSlot` );\nconst CREATE_SLOTS = /* @__PURE__ */ Symbol(`createSlots` );\nconst TO_DISPLAY_STRING = /* @__PURE__ */ Symbol(\n `toDisplayString` \n);\nconst MERGE_PROPS = /* @__PURE__ */ Symbol(`mergeProps` );\nconst NORMALIZE_CLASS = /* @__PURE__ */ Symbol(\n `normalizeClass` \n);\nconst NORMALIZE_STYLE = /* @__PURE__ */ Symbol(\n `normalizeStyle` \n);\nconst NORMALIZE_PROPS = /* @__PURE__ */ Symbol(\n `normalizeProps` \n);\nconst GUARD_REACTIVE_PROPS = /* @__PURE__ */ Symbol(\n `guardReactiveProps` \n);\nconst TO_HANDLERS = /* @__PURE__ */ Symbol(`toHandlers` );\nconst CAMELIZE = /* @__PURE__ */ Symbol(`camelize` );\nconst CAPITALIZE = /* @__PURE__ */ Symbol(`capitalize` );\nconst TO_HANDLER_KEY = /* @__PURE__ */ Symbol(\n `toHandlerKey` \n);\nconst SET_BLOCK_TRACKING = /* @__PURE__ */ Symbol(\n `setBlockTracking` \n);\nconst PUSH_SCOPE_ID = /* @__PURE__ */ Symbol(`pushScopeId` );\nconst POP_SCOPE_ID = /* @__PURE__ */ Symbol(`popScopeId` );\nconst WITH_CTX = /* @__PURE__ */ Symbol(`withCtx` );\nconst UNREF = /* @__PURE__ */ Symbol(`unref` );\nconst IS_REF = /* @__PURE__ */ Symbol(`isRef` );\nconst WITH_MEMO = /* @__PURE__ */ Symbol(`withMemo` );\nconst IS_MEMO_SAME = /* @__PURE__ */ Symbol(`isMemoSame` );\nconst helperNameMap = {\n [FRAGMENT]: `Fragment`,\n [TELEPORT]: `Teleport`,\n [SUSPENSE]: `Suspense`,\n [KEEP_ALIVE]: `KeepAlive`,\n [BASE_TRANSITION]: `BaseTransition`,\n [OPEN_BLOCK]: `openBlock`,\n [CREATE_BLOCK]: `createBlock`,\n [CREATE_ELEMENT_BLOCK]: `createElementBlock`,\n [CREATE_VNODE]: `createVNode`,\n [CREATE_ELEMENT_VNODE]: `createElementVNode`,\n [CREATE_COMMENT]: `createCommentVNode`,\n [CREATE_TEXT]: `createTextVNode`,\n [CREATE_STATIC]: `createStaticVNode`,\n [RESOLVE_COMPONENT]: `resolveComponent`,\n [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,\n [RESOLVE_DIRECTIVE]: `resolveDirective`,\n [RESOLVE_FILTER]: `resolveFilter`,\n [WITH_DIRECTIVES]: `withDirectives`,\n [RENDER_LIST]: `renderList`,\n [RENDER_SLOT]: `renderSlot`,\n [CREATE_SLOTS]: `createSlots`,\n [TO_DISPLAY_STRING]: `toDisplayString`,\n [MERGE_PROPS]: `mergeProps`,\n [NORMALIZE_CLASS]: `normalizeClass`,\n [NORMALIZE_STYLE]: `normalizeStyle`,\n [NORMALIZE_PROPS]: `normalizeProps`,\n [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,\n [TO_HANDLERS]: `toHandlers`,\n [CAMELIZE]: `camelize`,\n [CAPITALIZE]: `capitalize`,\n [TO_HANDLER_KEY]: `toHandlerKey`,\n [SET_BLOCK_TRACKING]: `setBlockTracking`,\n [PUSH_SCOPE_ID]: `pushScopeId`,\n [POP_SCOPE_ID]: `popScopeId`,\n [WITH_CTX]: `withCtx`,\n [UNREF]: `unref`,\n [IS_REF]: `isRef`,\n [WITH_MEMO]: `withMemo`,\n [IS_MEMO_SAME]: `isMemoSame`\n};\nfunction registerRuntimeHelpers(helpers) {\n Object.getOwnPropertySymbols(helpers).forEach((s) => {\n helperNameMap[s] = helpers[s];\n });\n}\n\nconst Namespaces = {\n \"HTML\": 0,\n \"0\": \"HTML\",\n \"SVG\": 1,\n \"1\": \"SVG\",\n \"MATH_ML\": 2,\n \"2\": \"MATH_ML\"\n};\nconst NodeTypes = {\n \"ROOT\": 0,\n \"0\": \"ROOT\",\n \"ELEMENT\": 1,\n \"1\": \"ELEMENT\",\n \"TEXT\": 2,\n \"2\": \"TEXT\",\n \"COMMENT\": 3,\n \"3\": \"COMMENT\",\n \"SIMPLE_EXPRESSION\": 4,\n \"4\": \"SIMPLE_EXPRESSION\",\n \"INTERPOLATION\": 5,\n \"5\": \"INTERPOLATION\",\n \"ATTRIBUTE\": 6,\n \"6\": \"ATTRIBUTE\",\n \"DIRECTIVE\": 7,\n \"7\": \"DIRECTIVE\",\n \"COMPOUND_EXPRESSION\": 8,\n \"8\": \"COMPOUND_EXPRESSION\",\n \"IF\": 9,\n \"9\": \"IF\",\n \"IF_BRANCH\": 10,\n \"10\": \"IF_BRANCH\",\n \"FOR\": 11,\n \"11\": \"FOR\",\n \"TEXT_CALL\": 12,\n \"12\": \"TEXT_CALL\",\n \"VNODE_CALL\": 13,\n \"13\": \"VNODE_CALL\",\n \"JS_CALL_EXPRESSION\": 14,\n \"14\": \"JS_CALL_EXPRESSION\",\n \"JS_OBJECT_EXPRESSION\": 15,\n \"15\": \"JS_OBJECT_EXPRESSION\",\n \"JS_PROPERTY\": 16,\n \"16\": \"JS_PROPERTY\",\n \"JS_ARRAY_EXPRESSION\": 17,\n \"17\": \"JS_ARRAY_EXPRESSION\",\n \"JS_FUNCTION_EXPRESSION\": 18,\n \"18\": \"JS_FUNCTION_EXPRESSION\",\n \"JS_CONDITIONAL_EXPRESSION\": 19,\n \"19\": \"JS_CONDITIONAL_EXPRESSION\",\n \"JS_CACHE_EXPRESSION\": 20,\n \"20\": \"JS_CACHE_EXPRESSION\",\n \"JS_BLOCK_STATEMENT\": 21,\n \"21\": \"JS_BLOCK_STATEMENT\",\n \"JS_TEMPLATE_LITERAL\": 22,\n \"22\": \"JS_TEMPLATE_LITERAL\",\n \"JS_IF_STATEMENT\": 23,\n \"23\": \"JS_IF_STATEMENT\",\n \"JS_ASSIGNMENT_EXPRESSION\": 24,\n \"24\": \"JS_ASSIGNMENT_EXPRESSION\",\n \"JS_SEQUENCE_EXPRESSION\": 25,\n \"25\": \"JS_SEQUENCE_EXPRESSION\",\n \"JS_RETURN_STATEMENT\": 26,\n \"26\": \"JS_RETURN_STATEMENT\"\n};\nconst ElementTypes = {\n \"ELEMENT\": 0,\n \"0\": \"ELEMENT\",\n \"COMPONENT\": 1,\n \"1\": \"COMPONENT\",\n \"SLOT\": 2,\n \"2\": \"SLOT\",\n \"TEMPLATE\": 3,\n \"3\": \"TEMPLATE\"\n};\nconst ConstantTypes = {\n \"NOT_CONSTANT\": 0,\n \"0\": \"NOT_CONSTANT\",\n \"CAN_SKIP_PATCH\": 1,\n \"1\": \"CAN_SKIP_PATCH\",\n \"CAN_CACHE\": 2,\n \"2\": \"CAN_CACHE\",\n \"CAN_STRINGIFY\": 3,\n \"3\": \"CAN_STRINGIFY\"\n};\nconst locStub = {\n start: { line: 1, column: 1, offset: 0 },\n end: { line: 1, column: 1, offset: 0 },\n source: \"\"\n};\nfunction createRoot(children, source = \"\") {\n return {\n type: 0,\n source,\n children,\n helpers: /* @__PURE__ */ new Set(),\n components: [],\n directives: [],\n hoists: [],\n imports: [],\n cached: [],\n temps: 0,\n codegenNode: void 0,\n loc: locStub\n };\n}\nfunction createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {\n if (context) {\n if (isBlock) {\n context.helper(OPEN_BLOCK);\n context.helper(getVNodeBlockHelper(context.inSSR, isComponent));\n } else {\n context.helper(getVNodeHelper(context.inSSR, isComponent));\n }\n if (directives) {\n context.helper(WITH_DIRECTIVES);\n }\n }\n return {\n type: 13,\n tag,\n props,\n children,\n patchFlag,\n dynamicProps,\n directives,\n isBlock,\n disableTracking,\n isComponent,\n loc\n };\n}\nfunction createArrayExpression(elements, loc = locStub) {\n return {\n type: 17,\n loc,\n elements\n };\n}\nfunction createObjectExpression(properties, loc = locStub) {\n return {\n type: 15,\n loc,\n properties\n };\n}\nfunction createObjectProperty(key, value) {\n return {\n type: 16,\n loc: locStub,\n key: shared.isString(key) ? createSimpleExpression(key, true) : key,\n value\n };\n}\nfunction createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {\n return {\n type: 4,\n loc,\n content,\n isStatic,\n constType: isStatic ? 3 : constType\n };\n}\nfunction createInterpolation(content, loc) {\n return {\n type: 5,\n loc,\n content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content\n };\n}\nfunction createCompoundExpression(children, loc = locStub) {\n return {\n type: 8,\n loc,\n children\n };\n}\nfunction createCallExpression(callee, args = [], loc = locStub) {\n return {\n type: 14,\n loc,\n callee,\n arguments: args\n };\n}\nfunction createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {\n return {\n type: 18,\n params,\n returns,\n newline,\n isSlot,\n loc\n };\n}\nfunction createConditionalExpression(test, consequent, alternate, newline = true) {\n return {\n type: 19,\n test,\n consequent,\n alternate,\n newline,\n loc: locStub\n };\n}\nfunction createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {\n return {\n type: 20,\n index,\n value,\n needPauseTracking,\n inVOnce,\n needArraySpread: false,\n loc: locStub\n };\n}\nfunction createBlockStatement(body) {\n return {\n type: 21,\n body,\n loc: locStub\n };\n}\nfunction createTemplateLiteral(elements) {\n return {\n type: 22,\n elements,\n loc: locStub\n };\n}\nfunction createIfStatement(test, consequent, alternate) {\n return {\n type: 23,\n test,\n consequent,\n alternate,\n loc: locStub\n };\n}\nfunction createAssignmentExpression(left, right) {\n return {\n type: 24,\n left,\n right,\n loc: locStub\n };\n}\nfunction createSequenceExpression(expressions) {\n return {\n type: 25,\n expressions,\n loc: locStub\n };\n}\nfunction createReturnStatement(returns) {\n return {\n type: 26,\n returns,\n loc: locStub\n };\n}\nfunction getVNodeHelper(ssr, isComponent) {\n return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;\n}\nfunction getVNodeBlockHelper(ssr, isComponent) {\n return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;\n}\nfunction convertToBlock(node, { helper, removeHelper, inSSR }) {\n if (!node.isBlock) {\n node.isBlock = true;\n removeHelper(getVNodeHelper(inSSR, node.isComponent));\n helper(OPEN_BLOCK);\n helper(getVNodeBlockHelper(inSSR, node.isComponent));\n }\n}\n\nconst defaultDelimitersOpen = new Uint8Array([123, 123]);\nconst defaultDelimitersClose = new Uint8Array([125, 125]);\nfunction isTagStartChar(c) {\n return c >= 97 && c <= 122 || c >= 65 && c <= 90;\n}\nfunction isWhitespace(c) {\n return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;\n}\nfunction isEndOfTagSection(c) {\n return c === 47 || c === 62 || isWhitespace(c);\n}\nfunction toCharCodes(str) {\n const ret = new Uint8Array(str.length);\n for (let i = 0; i < str.length; i++) {\n ret[i] = str.charCodeAt(i);\n }\n return ret;\n}\nconst Sequences = {\n Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),\n // CDATA[\n CdataEnd: new Uint8Array([93, 93, 62]),\n // ]]>\n CommentEnd: new Uint8Array([45, 45, 62]),\n // `-->`\n ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),\n // `<\\/script`\n StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),\n // `</style`\n TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),\n // `</title`\n TextareaEnd: new Uint8Array([\n 60,\n 47,\n 116,\n 101,\n 120,\n 116,\n 97,\n 114,\n 101,\n 97\n ])\n // `</textarea\n};\nclass Tokenizer {\n constructor(stack, cbs) {\n this.stack = stack;\n this.cbs = cbs;\n /** The current state the tokenizer is in. */\n this.state = 1;\n /** The read buffer. */\n this.buffer = \"\";\n /** The beginning of the section that is currently being read. */\n this.sectionStart = 0;\n /** The index within the buffer that we are currently looking at. */\n this.index = 0;\n /** The start of the last entity. */\n this.entityStart = 0;\n /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */\n this.baseState = 1;\n /** For special parsing behavior inside of script and style tags. */\n this.inRCDATA = false;\n /** For disabling RCDATA tags handling */\n this.inXML = false;\n /** For disabling interpolation parsing in v-pre */\n this.inVPre = false;\n /** Record newline positions for fast line / column calculation */\n this.newlines = [];\n this.mode = 0;\n this.delimiterOpen = defaultDelimitersOpen;\n this.delimiterClose = defaultDelimitersClose;\n this.delimiterIndex = -1;\n this.currentSequence = void 0;\n this.sequenceIndex = 0;\n {\n this.entityDecoder = new decode.EntityDecoder(\n decode.htmlDecodeTree,\n (cp, consumed) => this.emitCodePoint(cp, consumed)\n );\n }\n }\n get inSFCRoot() {\n return this.mode === 2 && this.stack.length === 0;\n }\n reset() {\n this.state = 1;\n this.mode = 0;\n this.buffer = \"\";\n this.sectionStart = 0;\n this.index = 0;\n this.baseState = 1;\n this.inRCDATA = false;\n this.currentSequence = void 0;\n this.newlines.length = 0;\n this.delimiterOpen = defaultDelimitersOpen;\n this.delimiterClose = defaultDelimitersClose;\n }\n /**\n * Generate Position object with line / column information using recorded\n * newline positions. We know the index is always going to be an already\n * processed index, so all the newlines up to this index should have been\n * recorded.\n */\n getPos(index) {\n let line = 1;\n let column = index + 1;\n const length = this.newlines.length;\n let j = -1;\n if (length > 100) {\n let l = -1;\n let r = length;\n while (l + 1 < r) {\n const m = l + r >>> 1;\n this.newlines[m] < index ? l = m : r = m;\n }\n j = l;\n } else {\n for (let i = length - 1; i >= 0; i--) {\n if (index > this.newlines[i]) {\n j = i;\n break;\n }\n }\n }\n if (j >= 0) {\n line = j + 2;\n column = index - this.newlines[j];\n }\n return {\n column,\n line,\n offset: index\n };\n }\n peek() {\n return this.buffer.charCodeAt(this.index + 1);\n }\n stateText(c) {\n if (c === 60) {\n if (this.index > this.sectionStart) {\n this.cbs.ontext(this.sectionStart, this.index);\n }\n this.state = 5;\n this.sectionStart = this.index;\n } else if (c === 38) {\n this.startEntity();\n } else if (!this.inVPre && c === this.delimiterOpen[0]) {\n this.state = 2;\n this.delimiterIndex = 0;\n this.stateInterpolationOpen(c);\n }\n }\n stateInterpolationOpen(c) {\n if (c === this.delimiterOpen[this.delimiterIndex]) {\n if (this.delimiterIndex === this.delimiterOpen.length - 1) {\n const start = this.index + 1 - this.delimiterOpen.length;\n if (start > this.sectionStart) {\n this.cbs.ontext(this.sectionStart, start);\n }\n this.state = 3;\n this.sectionStart = start;\n } else {\n this.delimiterIndex++;\n }\n } else if (this.inRCDATA) {\n this.state = 32;\n this.stateInRCDATA(c);\n } else {\n this.state = 1;\n this.stateText(c);\n }\n }\n stateInterpolation(c) {\n if (c === this.delimiterClose[0]) {\n this.state = 4;\n this.delimiterIndex = 0;\n this.stateInterpolationClose(c);\n }\n }\n stateInterpolationClose(c) {\n if (c === this.delimiterClose[this.delimiterIndex]) {\n if (this.delimiterIndex === this.delimiterClose.length - 1) {\n this.cbs.oninterpolation(this.sectionStart, this.index + 1);\n if (this.inRCDATA) {\n this.state = 32;\n } else {\n this.state = 1;\n }\n this.sectionStart = this.index + 1;\n } else {\n this.delimiterIndex++;\n }\n } else {\n this.state = 3;\n this.stateInterpolation(c);\n }\n }\n stateSpecialStartSequence(c) {\n const isEnd = this.sequenceIndex === this.currentSequence.length;\n const isMatch = isEnd ? (\n // If we are at the end of the sequence, make sure the tag name has ended\n isEndOfTagSection(c)\n ) : (\n // Otherwise, do a case-insensitive comparison\n (c | 32) === this.currentSequence[this.sequenceIndex]\n );\n if (!isMatch) {\n this.inRCDATA = false;\n } else if (!isEnd) {\n this.sequenceIndex++;\n return;\n }\n this.sequenceIndex = 0;\n this.state = 6;\n this.stateInTagName(c);\n }\n /** Look for an end tag. For <title> and <textarea>, also decode entities. */\n stateInRCDATA(c) {\n if (this.sequenceIndex === this.currentSequence.length) {\n if (c === 62 || isWhitespace(c)) {\n const endOfText = this.index - this.currentSequence.length;\n if (this.sectionStart < endOfText) {\n const actualIndex = this.index;\n this.index = endOfText;\n this.cbs.ontext(this.sectionStart, endOfText);\n this.index = actualIndex;\n }\n this.sectionStart = endOfText + 2;\n this.stateInClosingTagName(c);\n this.inRCDATA = false;\n return;\n }\n this.sequenceIndex = 0;\n }\n if ((c | 32) === this.currentSequence[this.sequenceIndex]) {\n this.sequenceIndex += 1;\n } else if (this.sequenceIndex === 0) {\n if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {\n if (c === 38) {\n this.startEntity();\n } else if (!this.inVPre && c === this.delimiterOpen[0]) {\n this.state = 2;\n this.delimiterIndex = 0;\n this.stateInterpolationOpen(c);\n }\n } else if (this.fastForwardTo(60)) {\n this.sequenceIndex = 1;\n }\n } else {\n this.sequenceIndex = Number(c === 60);\n }\n }\n stateCDATASequence(c) {\n if (c === Sequences.Cdata[this.sequenceIndex]) {\n if (++this.sequenceIndex === Sequences.Cdata.length) {\n this.state = 28;\n this.currentSequence = Sequences.CdataEnd;\n this.sequenceIndex = 0;\n this.sectionStart = this.index + 1;\n }\n } else {\n this.sequenceIndex = 0;\n this.state = 23;\n this.stateInDeclaration(c);\n }\n }\n /**\n * When we wait for one specific character, we can speed things up\n * by skipping through the buffer until we find it.\n *\n * @returns Whether the character was found.\n */\n fastForwardTo(c) {\n while (++this.index < this.buffer.length) {\n const cc = this.buffer.charCodeAt(this.index);\n if (cc === 10) {\n this.newlines.push(this.index);\n }\n if (cc === c) {\n return true;\n }\n }\n this.index = this.buffer.length - 1;\n return false;\n }\n /**\n * Comments and CDATA end with `-->` and `]]>`.\n *\n * Their common qualities are:\n * - Their end sequences have a distinct character they start with.\n * - That character is then repeated, so we have to check multiple repeats.\n * - All characters but the start character of the sequence can be skipped.\n */\n stateInCommentLike(c) {\n if (c === this.currentSequence[this.sequenceIndex]) {\n if (++this.sequenceIndex === this.currentSequence.length) {\n if (this.currentSequence === Sequences.CdataEnd) {\n this.cbs.oncdata(this.sectionStart, this.index - 2);\n } else {\n this.cbs.oncomment(this.sectionStart, this.index - 2);\n }\n this.sequenceIndex = 0;\n this.sectionStart = this.index + 1;\n this.state = 1;\n }\n } else if (this.sequenceIndex === 0) {\n if (this.fastForwardTo(this.currentSequence[0])) {\n this.sequenceIndex = 1;\n }\n } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {\n this.sequenceIndex = 0;\n }\n }\n startSpecial(sequence, offset) {\n this.enterRCDATA(sequence, offset);\n this.state = 31;\n }\n enterRCDATA(sequence, offset) {\n this.inRCDATA = true;\n this.currentSequence = sequence;\n this.sequenceIndex = offset;\n }\n stateBeforeTagName(c) {\n if (c === 33) {\n this.state = 22;\n this.sectionStart = this.index + 1;\n } else if (c === 63) {\n this.state = 24;\n this.sectionStart = this.index + 1;\n } else if (isTagStartChar(c)) {\n this.sectionStart = this.index;\n if (this.mode === 0) {\n this.state = 6;\n } else if (this.inSFCRoot) {\n this.state = 34;\n } else if (!this.inXML) {\n if (c === 116) {\n this.state = 30;\n } else {\n this.state = c === 115 ? 29 : 6;\n }\n } else {\n this.state = 6;\n }\n } else if (c === 47) {\n this.state = 8;\n } else {\n this.state = 1;\n this.stateText(c);\n }\n }\n stateInTagName(c) {\n if (isEndOfTagSection(c)) {\n this.handleTagName(c);\n }\n }\n stateInSFCRootTagName(c) {\n if (isEndOfTagSection(c)) {\n const tag = this.buffer.slice(this.sectionStart, this.index);\n if (tag !== \"template\") {\n this.enterRCDATA(toCharCodes(`</` + tag), 0);\n }\n this.handleTagName(c);\n }\n }\n handleTagName(c) {\n this.cbs.onopentagname(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.state = 11;\n this.stateBeforeAttrName(c);\n }\n stateBeforeClosingTagName(c) {\n if (isWhitespace(c)) ; else if (c === 62) {\n {\n this.cbs.onerr(14, this.index);\n }\n this.state = 1;\n this.sectionStart = this.index + 1;\n } else {\n this.state = isTagStartChar(c) ? 9 : 27;\n this.sectionStart = this.index;\n }\n }\n stateInClosingTagName(c) {\n if (c === 62 || isWhitespace(c)) {\n this.cbs.onclosetag(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.state = 10;\n this.stateAfterClosingTagName(c);\n }\n }\n stateAfterClosingTagName(c) {\n if (c === 62) {\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeAttrName(c) {\n if (c === 62) {\n this.cbs.onopentagend(this.index);\n if (this.inRCDATA) {\n this.state = 32;\n } else {\n this.state = 1;\n }\n this.sectionStart = this.index + 1;\n } else if (c === 47) {\n this.state = 7;\n if (this.peek() !== 62) {\n this.cbs.onerr(22, this.index);\n }\n } else if (c === 60 && this.peek() === 47) {\n this.cbs.onopentagend(this.index);\n this.state = 5;\n this.sectionStart = this.index;\n } else if (!isWhitespace(c)) {\n if (c === 61) {\n this.cbs.onerr(\n 19,\n this.index\n );\n }\n this.handleAttrStart(c);\n }\n }\n handleAttrStart(c) {\n if (c === 118 && this.peek() === 45) {\n this.state = 13;\n this.sectionStart = this.index;\n } else if (c === 46 || c === 58 || c === 64 || c === 35) {\n this.cbs.ondirname(this.index, this.index + 1);\n this.state = 14;\n this.sectionStart = this.index + 1;\n } else {\n this.state = 12;\n this.sectionStart = this.index;\n }\n }\n stateInSelfClosingTag(c) {\n if (c === 62) {\n this.cbs.onselfclosingtag(this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n this.inRCDATA = false;\n } else if (!isWhitespace(c)) {\n this.state = 11;\n this.stateBeforeAttrName(c);\n }\n }\n stateInAttrName(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.onattribname(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 34 || c === 39 || c === 60) {\n this.cbs.onerr(\n 17,\n this.index\n );\n }\n }\n stateInDirName(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 58) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.state = 14;\n this.sectionStart = this.index + 1;\n } else if (c === 46) {\n this.cbs.ondirname(this.sectionStart, this.index);\n this.state = 16;\n this.sectionStart = this.index + 1;\n }\n }\n stateInDirArg(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirarg(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 91) {\n this.state = 15;\n } else if (c === 46) {\n this.cbs.ondirarg(this.sectionStart, this.index);\n this.state = 16;\n this.sectionStart = this.index + 1;\n }\n }\n stateInDynamicDirArg(c) {\n if (c === 93) {\n this.state = 14;\n } else if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirarg(this.sectionStart, this.index + 1);\n this.handleAttrNameEnd(c);\n {\n this.cbs.onerr(\n 27,\n this.index\n );\n }\n }\n }\n stateInDirModifier(c) {\n if (c === 61 || isEndOfTagSection(c)) {\n this.cbs.ondirmodifier(this.sectionStart, this.index);\n this.handleAttrNameEnd(c);\n } else if (c === 46) {\n this.cbs.ondirmodifier(this.sectionStart, this.index);\n this.sectionStart = this.index + 1;\n }\n }\n handleAttrNameEnd(c) {\n this.sectionStart = this.index;\n this.state = 17;\n this.cbs.onattribnameend(this.index);\n this.stateAfterAttrName(c);\n }\n stateAfterAttrName(c) {\n if (c === 61) {\n this.state = 18;\n } else if (c === 47 || c === 62) {\n this.cbs.onattribend(0, this.sectionStart);\n this.sectionStart = -1;\n this.state = 11;\n this.stateBeforeAttrName(c);\n } else if (!isWhitespace(c)) {\n this.cbs.onattribend(0, this.sectionStart);\n this.handleAttrStart(c);\n }\n }\n stateBeforeAttrValue(c) {\n if (c === 34) {\n this.state = 19;\n this.sectionStart = this.index + 1;\n } else if (c === 39) {\n this.state = 20;\n this.sectionStart = this.index + 1;\n } else if (!isWhitespace(c)) {\n this.sectionStart = this.index;\n this.state = 21;\n this.stateInAttrValueNoQuotes(c);\n }\n }\n handleInAttrValue(c, quote) {\n if (c === quote || false) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.cbs.onattribend(\n quote === 34 ? 3 : 2,\n this.index + 1\n );\n this.state = 11;\n } else if (c === 38) {\n this.startEntity();\n }\n }\n stateInAttrValueDoubleQuotes(c) {\n this.handleInAttrValue(c, 34);\n }\n stateInAttrValueSingleQuotes(c) {\n this.handleInAttrValue(c, 39);\n }\n stateInAttrValueNoQuotes(c) {\n if (isWhitespace(c) || c === 62) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = -1;\n this.cbs.onattribend(1, this.index);\n this.state = 11;\n this.stateBeforeAttrName(c);\n } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {\n this.cbs.onerr(\n 18,\n this.index\n );\n } else if (c === 38) {\n this.startEntity();\n }\n }\n stateBeforeDeclaration(c) {\n if (c === 91) {\n this.state = 26;\n this.sequenceIndex = 0;\n } else {\n this.state = c === 45 ? 25 : 23;\n }\n }\n stateInDeclaration(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateInProcessingInstruction(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.cbs.onprocessinginstruction(this.sectionStart, this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeComment(c) {\n if (c === 45) {\n this.state = 28;\n this.currentSequence = Sequences.CommentEnd;\n this.sequenceIndex = 2;\n this.sectionStart = this.index + 1;\n } else {\n this.state = 23;\n }\n }\n stateInSpecialComment(c) {\n if (c === 62 || this.fastForwardTo(62)) {\n this.cbs.oncomment(this.sectionStart, this.index);\n this.state = 1;\n this.sectionStart = this.index + 1;\n }\n }\n stateBeforeSpecialS(c) {\n if (c === Sequences.ScriptEnd[3]) {\n this.startSpecial(Sequences.ScriptEnd, 4);\n } else if (c === Sequences.StyleEnd[3]) {\n this.startSpecial(Sequences.StyleEnd, 4);\n } else {\n this.state = 6;\n this.stateInTagName(c);\n }\n }\n stateBeforeSpecialT(c) {\n if (c === Sequences.TitleEnd[3]) {\n this.startSpecial(Sequences.TitleEnd, 4);\n } else if (c === Sequences.TextareaEnd[3]) {\n this.startSpecial(Sequences.TextareaEnd, 4);\n } else {\n this.state = 6;\n this.stateInTagName(c);\n }\n }\n startEntity() {\n {\n this.baseState = this.state;\n this.state = 33;\n this.entityStart = this.index;\n this.entityDecoder.startEntity(\n this.baseState === 1 || this.baseState === 32 ? decode.DecodingMode.Legacy : decode.DecodingMode.Attribute\n );\n }\n }\n stateInEntity() {\n {\n const length = this.entityDecoder.write(this.buffer, this.index);\n if (length >= 0) {\n this.state = this.baseState;\n if (length === 0) {\n this.index = this.entityStart;\n }\n } else {\n this.index = this.buffer.length - 1;\n }\n }\n }\n /**\n * Iterates through the buffer, calling the function corresponding to the current state.\n *\n * States that are more likely to be hit are higher up, as a performance improvement.\n */\n parse(input) {\n this.buffer = input;\n while (this.index < this.buffer.length) {\n const c = this.buffer.charCodeAt(this.index);\n if (c === 10 && this.state !== 33) {\n this.newlines.push(this.index);\n }\n switch (this.state) {\n case 1: {\n this.stateText(c);\n break;\n }\n case 2: {\n this.stateInterpolationOpen(c);\n break;\n }\n case 3: {\n this.stateInterpolation(c);\n break;\n }\n case 4: {\n this.stateInterpolationClose(c);\n break;\n }\n case 31: {\n this.stateSpecialStartSequence(c);\n break;\n }\n case 32: {\n this.stateInRCDATA(c);\n break;\n }\n case 26: {\n this.stateCDATASequence(c);\n break;\n }\n case 19: {\n this.stateInAttrValueDoubleQuotes(c);\n break;\n }\n case 12: {\n this.stateInAttrName(c);\n break;\n }\n case 13: {\n this.stateInDirName(c);\n break;\n }\n case 14: {\n this.stateInDirArg(c);\n break;\n }\n case 15: {\n this.stateInDynamicDirArg(c);\n break;\n }\n case 16: {\n this.stateInDirModifier(c);\n break;\n }\n case 28: {\n this.stateInCommentLike(c);\n break;\n }\n case 27: {\n this.stateInSpecialComment(c);\n break;\n }\n case 11: {\n this.stateBeforeAttrName(c);\n break;\n }\n case 6: {\n this.stateInTagName(c);\n break;\n }\n case 34: {\n this.stateInSFCRootTagName(c);\n break;\n }\n case 9: {\n this.stateInClosingTagName(c);\n break;\n }\n case 5: {\n this.stateBeforeTagName(c);\n break;\n }\n case 17: {\n this.stateAfterAttrName(c);\n break;\n }\n case 20: {\n this.stateInAttrValueSingleQuotes(c);\n break;\n }\n case 18: {\n this.stateBeforeAttrValue(c);\n break;\n }\n case 8: {\n this.stateBeforeClosingTagName(c);\n break;\n }\n case 10: {\n this.stateAfterClosingTagName(c);\n break;\n }\n case 29: {\n this.stateBeforeSpecialS(c);\n break;\n }\n case 30: {\n this.stateBeforeSpecialT(c);\n break;\n }\n case 21: {\n this.stateInAttrValueNoQuotes(c);\n break;\n }\n case 7: {\n this.stateInSelfClosingTag(c);\n break;\n }\n case 23: {\n this.stateInDeclaration(c);\n break;\n }\n case 22: {\n this.stateBeforeDeclaration(c);\n break;\n }\n case 25: {\n this.stateBeforeComment(c);\n break;\n }\n case 24: {\n this.stateInProcessingInstruction(c);\n break;\n }\n case 33: {\n this.stateInEntity();\n break;\n }\n }\n this.index++;\n }\n this.cleanup();\n this.finish();\n }\n /**\n * Remove data that has already been consumed from the buffer.\n */\n cleanup() {\n if (this.sectionStart !== this.index) {\n if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {\n this.cbs.ontext(this.sectionStart, this.index);\n this.sectionStart = this.index;\n } else if (this.state === 19 || this.state === 20 || this.state === 21) {\n this.cbs.onattribdata(this.sectionStart, this.index);\n this.sectionStart = this.index;\n }\n }\n }\n finish() {\n if (this.state === 33) {\n this.entityDecoder.end();\n this.state = this.baseState;\n }\n this.handleTrailingData();\n this.cbs.onend();\n }\n /** Handle any trailing data. */\n handleTrailingData() {\n const endIndex = this.buffer.length;\n if (this.sectionStart >= endIndex) {\n return;\n }\n if (this.state === 28) {\n if (this.currentSequence === Sequences.CdataEnd) {\n this.cbs.oncdata(this.sectionStart, endIndex);\n } else {\n this.cbs.oncomment(this.sectionStart, endIndex);\n }\n } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {\n this.cbs.ontext(this.sectionStart, endIndex);\n }\n }\n emitCodePoint(cp, consumed) {\n {\n if (this.baseState !== 1 && this.baseState !== 32) {\n if (this.sectionStart < this.entityStart) {\n this.cbs.onattribdata(this.sectionStart, this.entityStart);\n }\n this.sectionStart = this.entityStart + consumed;\n this.index = this.sectionStart - 1;\n this.cbs.onattribentity(\n decode.fromCodePoint(cp),\n this.entityStart,\n this.sectionStart\n );\n } else {\n if (this.sectionStart < this.entityStart) {\n this.cbs.ontext(this.sectionStart, this.entityStart);\n }\n this.sectionStart = this.entityStart + consumed;\n this.index = this.sectionStart - 1;\n this.cbs.ontextentity(\n decode.fromCodePoint(cp),\n this.entityStart,\n this.sectionStart\n );\n }\n }\n }\n}\n\nconst CompilerDeprecationTypes = {\n \"COMPILER_IS_ON_ELEMENT\": \"COMPILER_IS_ON_ELEMENT\",\n \"COMPILER_V_BIND_SYNC\": \"COMPILER_V_BIND_SYNC\",\n \"COMPILER_V_BIND_OBJECT_ORDER\": \"COMPILER_V_BIND_OBJECT_ORDER\",\n \"COMPILER_V_ON_NATIVE\": \"COMPILER_V_ON_NATIVE\",\n \"COMPILER_V_IF_V_FOR_PRECEDENCE\": \"COMPILER_V_IF_V_FOR_PRECEDENCE\",\n \"COMPILER_NATIVE_TEMPLATE\": \"COMPILER_NATIVE_TEMPLATE\",\n \"COMPILER_INLINE_TEMPLATE\": \"COMPILER_INLINE_TEMPLATE\",\n \"COMPILER_FILTERS\": \"COMPILER_FILTERS\"\n};\nconst deprecationData = {\n [\"COMPILER_IS_ON_ELEMENT\"]: {\n message: `Platform-native elements with \"is\" prop will no longer be treated as components in Vue 3 unless the \"is\" value is explicitly prefixed with \"vue:\".`,\n link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`\n },\n [\"COMPILER_V_BIND_SYNC\"]: {\n message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \\`v-bind:${key}.sync\\` should be changed to \\`v-model:${key}\\`.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`\n },\n [\"COMPILER_V_BIND_OBJECT_ORDER\"]: {\n message: `v-bind=\"obj\" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`\n },\n [\"COMPILER_V_ON_NATIVE\"]: {\n message: `.native modifier for v-on has been removed as is no longer necessary.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`\n },\n [\"COMPILER_V_IF_V_FOR_PRECEDENCE\"]: {\n message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`\n },\n [\"COMPILER_NATIVE_TEMPLATE\"]: {\n message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`\n },\n [\"COMPILER_INLINE_TEMPLATE\"]: {\n message: `\"inline-template\" has been removed in Vue 3.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`\n },\n [\"COMPILER_FILTERS\"]: {\n message: `filters have been removed in Vue 3. The \"|\" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,\n link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`\n }\n};\nfunction getCompatValue(key, { compatConfig }) {\n const value = compatConfig && compatConfig[key];\n if (key === \"MODE\") {\n return value || 3;\n } else {\n return value;\n }\n}\nfunction isCompatEnabled(key, context) {\n const mode = getCompatValue(\"MODE\", context);\n const value = getCompatValue(key, context);\n return mode === 3 ? value === true : value !== false;\n}\nfunction checkCompatEnabled(key, context, loc, ...args) {\n const enabled = isCompatEnabled(key, context);\n if (enabled) {\n warnDeprecation(key, context, loc, ...args);\n }\n return enabled;\n}\nfunction warnDeprecation(key, context, loc, ...args) {\n const val = getCompatValue(key, context);\n if (val === \"suppress-warning\") {\n return;\n }\n const { message, link } = deprecationData[key];\n const msg = `(deprecation ${key}) ${typeof message === \"function\" ? message(...args) : message}${link ? `\n Details: ${link}` : ``}`;\n const err = new SyntaxError(msg);\n err.code = key;\n if (loc) err.loc = loc;\n context.onWarn(err);\n}\n\nfunction defaultOnError(error) {\n throw error;\n}\nfunction defaultOnWarn(msg) {\n console.warn(`[Vue warn] ${msg.message}`);\n}\nfunction createCompilerError(code, loc, messages, additionalMessage) {\n const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;\n const error = new SyntaxError(String(msg));\n error.code = code;\n error.loc = loc;\n return error;\n}\nconst ErrorCodes = {\n \"ABRUPT_CLOSING_OF_EMPTY_COMMENT\": 0,\n \"0\": \"ABRUPT_CLOSING_OF_EMPTY_COMMENT\",\n \"CDATA_IN_HTML_CONTENT\": 1,\n \"1\": \"CDATA_IN_HTML_CONTENT\",\n \"DUPLICATE_ATTRIBUTE\": 2,\n \"2\": \"DUPLICATE_ATTRIBUTE\",\n \"END_TAG_WITH_ATTRIBUTES\": 3,\n \"3\": \"END_TAG_WITH_ATTRIBUTES\",\n \"END_TAG_WITH_TRAILING_SOLIDUS\": 4,\n \"4\": \"END_TAG_WITH_TRAILING_SOLIDUS\",\n \"EOF_BEFORE_TAG_NAME\": 5,\n \"5\": \"EOF_BEFORE_TAG_NAME\",\n \"EOF_IN_CDATA\": 6,\n \"6\": \"EOF_IN_CDATA\",\n \"EOF_IN_COMMENT\": 7,\n \"7\": \"EOF_IN_COMMENT\",\n \"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT\": 8,\n \"8\": \"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT\",\n \"EOF_IN_TAG\": 9,\n \"9\": \"EOF_IN_TAG\",\n \"INCORRECTLY_CLOSED_COMMENT\": 10,\n \"10\": \"INCORRECTLY_CLOSED_COMMENT\",\n \"INCORRECTLY_OPENED_COMMENT\": 11,\n \"11\": \"INCORRECTLY_OPENED_COMMENT\",\n \"INVALID_FIRST_CHARACTER_OF_TAG_NAME\": 12,\n \"12\": \"INVALID_FIRST_CHARACTER_OF_TAG_NAME\",\n \"MISSING_ATTRIBUTE_VALUE\": 13,\n \"13\": \"MISSING_ATTRIBUTE_VALUE\",\n \"MISSING_END_TAG_NAME\": 14,\n \"14\": \"MISSING_END_TAG_NAME\",\n \"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES\": 15,\n \"15\": \"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES\",\n \"NESTED_COMMENT\": 16,\n \"16\": \"NESTED_COMMENT\",\n \"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME\": 17,\n \"17\": \"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME\",\n \"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE\": 18,\n \"18\": \"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE\",\n \"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME\": 19,\n \"19\": \"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME\",\n \"UNEXPECTED_NULL_CHARACTER\": 20,\n \"20\": \"UNEXPECTED_NULL_CHARACTER\",\n \"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME\": 21,\n \"21\": \"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME\",\n \"UNEXPECTED_SOLIDUS_IN_TAG\": 22,\n \"22\": \"UNEXPECTED_SOLIDUS_IN_TAG\",\n \"X_INVALID_END_TAG\": 23,\n \"23\": \"X_INVALID_END_TAG\",\n \"X_MISSING_END_TAG\": 24,\n \"24\": \"X_MISSING_END_TAG\",\n \"X_MISSING_INTERPOLATION_END\": 25,\n \"25\": \"X_MISSING_INTERPOLATION_END\",\n \"X_MISSING_DIRECTIVE_NAME\": 26,\n \"26\": \"X_MISSING_DIRECTIVE_NAME\",\n \"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END\": 27,\n \"27\": \"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END\",\n \"X_V_IF_NO_EXPRESSION\": 28,\n \"28\": \"X_V_IF_NO_EXPRESSION\",\n \"X_V_IF_SAME_KEY\": 29,\n \"29\": \"X_V_IF_SAME_KEY\",\n \"X_V_ELSE_NO_ADJACENT_IF\": 30,\n \"30\": \"X_V_ELSE_NO_ADJACENT_IF\",\n \"X_V_FOR_NO_EXPRESSION\": 31,\n \"31\": \"X_V_FOR_NO_EXPRESSION\",\n \"X_V_FOR_MALFORMED_EXPRESSION\": 32,\n \"32\": \"X_V_FOR_MALFORMED_EXPRESSION\",\n \"X_V_FOR_TEMPLATE_KEY_PLACEMENT\": 33,\n \"33\": \"X_V_FOR_TEMPLATE_KEY_PLACEMENT\",\n \"X_V_BIND_NO_EXPRESSION\": 34,\n \"34\": \"X_V_BIND_NO_EXPRESSION\",\n \"X_V_ON_NO_EXPRESSION\": 35,\n \"35\": \"X_V_ON_NO_EXPRESSION\",\n \"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET\": 36,\n \"36\": \"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET\",\n \"X_V_SLOT_MIXED_SLOT_USAGE\": 37,\n \"37\": \"X_V_SLOT_MIXED_SLOT_USAGE\",\n \"X_V_SLOT_DUPLICATE_SLOT_NAMES\": 38,\n \"38\": \"X_V_SLOT_DUPLICATE_SLOT_NAMES\",\n \"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN\": 39,\n \"39\": \"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN\",\n \"X_V_SLOT_MISPLACED\": 40,\n \"40\": \"X_V_SLOT_MISPLACED\",\n \"X_V_MODEL_NO_EXPRESSION\": 41,\n \"41\": \"X_V_MODEL_NO_EXPRESSION\",\n \"X_V_MODEL_MALFORMED_EXPRESSION\": 42,\n \"42\": \"X_V_MODEL_MALFORMED_EXPRESSION\",\n \"X_V_MODEL_ON_SCOPE_VARIABLE\": 43,\n \"43\": \"X_V_MODEL_ON_SCOPE_VARIABLE\",\n \"X_V_MODEL_ON_PROPS\": 44,\n \"44\": \"X_V_MODEL_ON_PROPS\",\n \"X_V_MODEL_ON_CONST\": 45,\n \"45\": \"X_V_MODEL_ON_CONST\",\n \"X_INVALID_EXPRESSION\": 46,\n \"46\": \"X_INVALID_EXPRESSION\",\n \"X_KEEP_ALIVE_INVALID_CHILDREN\": 47,\n \"47\": \"X_KEEP_ALIVE_INVALID_CHILDREN\",\n \"X_PREFIX_ID_NOT_SUPPORTED\": 48,\n \"48\": \"X_PREFIX_ID_NOT_SUPPORTED\",\n \"X_MODULE_MODE_NOT_SUPPORTED\": 49,\n \"49\": \"X_MODULE_MODE_NOT_SUPPORTED\",\n \"X_CACHE_HANDLER_NOT_SUPPORTED\": 50,\n \"50\": \"X_CACHE_HANDLER_NOT_SUPPORTED\",\n \"X_SCOPE_ID_NOT_SUPPORTED\": 51,\n \"51\": \"X_SCOPE_ID_NOT_SUPPORTED\",\n \"X_VNODE_HOOKS\": 52,\n \"52\": \"X_VNODE_HOOKS\",\n \"X_V_BIND_INVALID_SAME_NAME_ARGUMENT\": 53,\n \"53\": \"X_V_BIND_INVALID_SAME_NAME_ARGUMENT\",\n \"__EXTEND_POINT__\": 54,\n \"54\": \"__EXTEND_POINT__\"\n};\nconst errorMessages = {\n // parse errors\n [0]: \"Illegal comment.\",\n [1]: \"CDATA section is allowed only in XML context.\",\n [2]: \"Duplicate attribute.\",\n [3]: \"End tag cannot have attributes.\",\n [4]: \"Illegal '/' in tags.\",\n [5]: \"Unexpected EOF in tag.\",\n [6]: \"Unexpected EOF in CDATA section.\",\n [7]: \"Unexpected EOF in comment.\",\n [8]: \"Unexpected EOF in script.\",\n [9]: \"Unexpected EOF in tag.\",\n [10]: \"Incorrectly closed comment.\",\n [11]: \"Incorrectly opened comment.\",\n [12]: \"Illegal tag name. Use '<' to print '<'.\",\n [13]: \"Attribute value was expected.\",\n [14]: \"End tag name was expected.\",\n [15]: \"Whitespace was expected.\",\n [16]: \"Unexpected '<!--' in comment.\",\n [17]: `Attribute name cannot contain U+0022 (\"), U+0027 ('), and U+003C (<).`,\n [18]: \"Unquoted attribute value cannot contain U+0022 (\\\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).\",\n [19]: \"Attribute name cannot start with '='.\",\n [21]: \"'<?' is allowed only in XML context.\",\n [20]: `Unexpected null character.`,\n [22]: \"Illegal '/' in tags.\",\n // Vue-specific parse errors\n [23]: \"Invalid end tag.\",\n [24]: \"Element is missing end tag.\",\n [25]: \"Interpolation end sign was not found.\",\n [27]: \"End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.\",\n [26]: \"Legal directive name was expected.\",\n // transform errors\n [28]: `v-if/v-else-if is missing expression.`,\n [29]: `v-if/else branches must use unique keys.`,\n [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,\n [31]: `v-for is missing expression.`,\n [32]: `v-for has invalid expression.`,\n [33]: `<template v-for> key should be placed on the <template> tag.`,\n [34]: `v-bind is missing expression.`,\n [53]: `v-bind with same-name shorthand only allows static argument.`,\n [35]: `v-on is missing expression.`,\n [36]: `Unexpected custom directive on <slot> outlet.`,\n [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,\n [38]: `Duplicate slot names found. `,\n [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,\n [40]: `v-slot can only be used on components or <template> tags.`,\n [41]: `v-model is missing expression.`,\n [42]: `v-model value must be a valid JavaScript member expression.`,\n [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,\n [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`,\n [45]: `v-model cannot be used on a const binding because it is not writable.`,\n [46]: `Error parsing JavaScript expression: `,\n [47]: `<KeepAlive> expects exactly one child component.`,\n [52]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,\n // generic errors\n [48]: `\"prefixIdentifiers\" option is not supported in this build of compiler.`,\n [49]: `ES module mode is not supported in this build of compiler.`,\n [50]: `\"cacheHandlers\" option is only supported when the \"prefixIdentifiers\" option is enabled.`,\n [51]: `\"scopeId\" option is only supported in module mode.`,\n // just to fulfill types\n [54]: ``\n};\n\nfunction walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {\n const rootExp = root.type === \"Program\" ? root.body[0].type === \"ExpressionStatement\" && root.body[0].expression : root;\n estreeWalker.walk(root, {\n enter(node, parent) {\n parent && parentStack.push(parent);\n if (parent && parent.type.startsWith(\"TS\") && !TS_NODE_TYPES.includes(parent.type)) {\n return this.skip();\n }\n if (node.type === \"Identifier\") {\n const isLocal = !!knownIds[node.name];\n const isRefed = isReferencedIdentifier(node, parent, parentStack);\n if (includeAll || isRefed && !isLocal) {\n onIdentifier(node, parent, parentStack, isRefed, isLocal);\n }\n } else if (node.type === \"ObjectProperty\" && // eslint-disable-next-line no-restricted-syntax\n (parent == null ? void 0 : parent.type) === \"ObjectPattern\") {\n node.inPattern = true;\n } else if (isFunctionType(node)) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkFunctionParams(\n node,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"BlockStatement\") {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkBlockDeclarations(\n node,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"SwitchStatement\") {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkSwitchStatement(\n node,\n false,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n } else if (node.type === \"CatchClause\" && node.param) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n for (const id of extractIdentifiers(node.param)) {\n markScopeIdentifier(node, id, knownIds);\n }\n }\n } else if (isForStatement(node)) {\n if (node.scopeIds) {\n node.scopeIds.forEach((id) => markKnownIds(id, knownIds));\n } else {\n walkForStatement(\n node,\n false,\n (id) => markScopeIdentifier(node, id, knownIds)\n );\n }\n }\n },\n leave(node, parent) {\n parent && parentStack.pop();\n if (node !== rootExp && node.scopeIds) {\n for (const id of node.scopeIds) {\n knownIds[id]--;\n if (knownIds[id] === 0) {\n delete knownIds[id];\n }\n }\n }\n }\n });\n}\nfunction isReferencedIdentifier(id, parent, parentStack) {\n if (!parent) {\n return true;\n }\n if (id.name === \"arguments\") {\n return false;\n }\n if (isReferenced(id, parent, parentStack[parentStack.length - 2])) {\n return true;\n }\n switch (parent.type) {\n case \"AssignmentExpression\":\n case \"AssignmentPattern\":\n return true;\n case \"ObjectProperty\":\n return parent.key !== id && isInDestructureAssignment(parent, parentStack);\n case \"ArrayPattern\":\n return isInDestructureAssignment(parent, parentStack);\n }\n return false;\n}\nfunction isInDestructureAssignment(parent, parentStack) {\n if (parent && (parent.type === \"ObjectProperty\" || parent.type === \"ArrayPattern\")) {\n let i = parentStack.length;\n while (i--) {\n const p = parentStack[i];\n if (p.type === \"AssignmentExpression\") {\n return true;\n } else if (p.type !== \"ObjectProperty\" && !p.type.endsWith(\"Pattern\")) {\n break;\n }\n }\n }\n return false;\n}\nfunction isInNewExpression(parentStack) {\n let i = parentStack.length;\n while (i--) {\n const p = parentStack[i];\n if (p.type === \"NewExpression\") {\n return true;\n } else if (p.type !== \"MemberExpression\") {\n break;\n }\n }\n return false;\n}\nfunction walkFunctionParams(node, onIdent) {\n for (const p of node.params) {\n for (const id of extractIdentifiers(p)) {\n onIdent(id);\n }\n }\n}\nfunction walkBlockDeclarations(block, onIdent) {\n const body = block.type === \"SwitchCase\" ? block.consequent : block.body;\n for (const stmt of body) {\n if (stmt.type === \"VariableDeclaration\") {\n if (stmt.declare) continue;\n for (const decl of stmt.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n } else if (stmt.type === \"FunctionDeclaration\" || stmt.type === \"ClassDeclaration\") {\n if (stmt.declare || !stmt.id) continue;\n onIdent(stmt.id);\n } else if (isForStatement(stmt)) {\n walkForStatement(stmt, true, onIdent);\n } else if (stmt.type === \"SwitchStatement\") {\n walkSwitchStatement(stmt, true, onIdent);\n }\n }\n}\nfunction isForStatement(stmt) {\n return stmt.type === \"ForOfStatement\" || stmt.type === \"ForInStatement\" || stmt.type === \"ForStatement\";\n}\nfunction walkForStatement(stmt, isVar, onIdent) {\n const variable = stmt.type === \"ForStatement\" ? stmt.init : stmt.left;\n if (variable && variable.type === \"VariableDeclaration\" && (variable.kind === \"var\" ? isVar : !isVar)) {\n for (const decl of variable.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n }\n}\nfunction walkSwitchStatement(stmt, isVar, onIdent) {\n for (const cs of stmt.cases) {\n for (const stmt2 of cs.consequent) {\n if (stmt2.type === \"VariableDeclaration\" && (stmt2.kind === \"var\" ? isVar : !isVar)) {\n for (const decl of stmt2.declarations) {\n for (const id of extractIdentifiers(decl.id)) {\n onIdent(id);\n }\n }\n }\n }\n walkBlockDeclarations(cs, onIdent);\n }\n}\nfunction extractIdentifiers(param, nodes = []) {\n switch (param.type) {\n case \"Identifier\":\n nodes.push(param);\n break;\n case \"MemberExpression\":\n let object = param;\n while (object.type === \"MemberExpression\") {\n object = object.object;\n }\n nodes.push(object);\n break;\n case \"ObjectPattern\":\n for (const prop of param.properties) {\n if (prop.type === \"RestElement\") {\n extractIdentifiers(prop.argument, nodes);\n } else {\n extractIdentifiers(prop.value, nodes);\n }\n }\n break;\n case \"ArrayPattern\":\n param.elements.forEach((element) => {\n if (element) extractIdentifiers(element, nodes);\n });\n break;\n case \"RestElement\":\n extractIdentifiers(param.argument, nodes);\n break;\n case \"AssignmentPattern\":\n extractIdentifiers(param.left, nodes);\n break;\n }\n return nodes;\n}\nfunction markKnownIds(name, knownIds) {\n if (name in knownIds) {\n knownIds[name]++;\n } else {\n knownIds[name] = 1;\n }\n}\nfunction markScopeIdentifier(node, child, knownIds) {\n const { name } = child;\n if (node.scopeIds && node.scopeIds.has(name)) {\n return;\n }\n markKnownIds(name, knownIds);\n (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);\n}\nconst isFunctionType = (node) => {\n return /Function(?:Expression|Declaration)$|Method$/.test(node.type);\n};\nconst isStaticProperty = (node) => node && (node.type === \"ObjectProperty\" || node.type === \"ObjectMethod\") && !node.computed;\nconst isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;\nfunction isReferenced(node, parent, grandparent) {\n switch (parent.type) {\n // yes: PARENT[NODE]\n // yes: NODE.child\n // no: parent.NODE\n case \"MemberExpression\":\n case \"OptionalMemberExpression\":\n if (parent.property === node) {\n return !!parent.computed;\n }\n return parent.object === node;\n case \"JSXMemberExpression\":\n return parent.object === node;\n // no: let NODE = init;\n // yes: let id = NODE;\n case \"VariableDeclarator\":\n return parent.init === node;\n // yes: () => NODE\n // no: (NODE) => {}\n case \"ArrowFunctionExpression\":\n return parent.body === node;\n // no: class { #NODE; }\n // no: class { get #NODE() {} }\n // no: class { #NODE() {} }\n // no: class { fn() { return this.#NODE; } }\n case \"PrivateName\":\n return false;\n // no: class { NODE() {} }\n // yes: class { [NODE]() {} }\n // no: class { foo(NODE) {} }\n case \"ClassMethod\":\n case \"ClassPrivateMethod\":\n case \"ObjectMethod\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return false;\n // yes: { [NODE]: \"\" }\n // no: { NODE: \"\" }\n // depends: { NODE }\n // depends: { key: NODE }\n case \"ObjectProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return !grandparent || grandparent.type !== \"ObjectPattern\";\n // no: class { NODE = value; }\n // yes: class { [NODE] = value; }\n // yes: class { key = NODE; }\n case \"ClassProperty\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n case \"ClassPrivateProperty\":\n return parent.key !== node;\n // no: class NODE {}\n // yes: class Foo extends NODE {}\n case \"ClassDeclaration\":\n case \"ClassExpression\":\n return parent.superClass === node;\n // yes: left = NODE;\n // no: NODE = right;\n case \"AssignmentExpression\":\n return parent.right === node;\n // no: [NODE = foo] = [];\n // yes: [foo = NODE] = [];\n case \"AssignmentPattern\":\n return parent.right === node;\n // no: NODE: for (;;) {}\n case \"LabeledStatement\":\n return false;\n // no: try {} catch (NODE) {}\n case \"CatchClause\":\n return false;\n // no: function foo(...NODE) {}\n case \"RestElement\":\n return false;\n case \"BreakStatement\":\n case \"ContinueStatement\":\n return false;\n // no: function NODE() {}\n // no: function foo(NODE) {}\n case \"FunctionDeclaration\":\n case \"FunctionExpression\":\n return false;\n // no: export NODE from \"foo\";\n // no: export * as NODE from \"foo\";\n case \"ExportNamespaceSpecifier\":\n case \"ExportDefaultSpecifier\":\n return false;\n // no: export { foo as NODE };\n // yes: export { NODE as foo };\n // no: export { NODE as foo } from \"foo\";\n case \"ExportSpecifier\":\n if (grandparent == null ? void 0 : grandparent.source) {\n return false;\n }\n return parent.local === node;\n // no: import NODE from \"foo\";\n // no: import * as NODE from \"foo\";\n // no: import { NODE as foo } from \"foo\";\n // no: import { foo as NODE } from \"foo\";\n // no: import NODE from \"bar\";\n case \"ImportDefaultSpecifier\":\n case \"ImportNamespaceSpecifier\":\n case \"ImportSpecifier\":\n return false;\n // no: import \"foo\" assert { NODE: \"json\" }\n case \"ImportAttribute\":\n return false;\n // no: <div NODE=\"foo\" />\n case \"JSXAttribute\":\n return false;\n // no: [NODE] = [];\n // no: ({ NODE }) = [];\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n return false;\n // no: new.NODE\n // no: NODE.target\n case \"MetaProperty\":\n return false;\n // yes: type X = { someProperty: NODE }\n // no: type X = { NODE: OtherType }\n case \"ObjectTypeProperty\":\n return parent.key !== node;\n // yes: enum X { Foo = NODE }\n // no: enum X { NODE }\n case \"TSEnumMember\":\n return parent.id !== node;\n // yes: { [NODE]: value }\n // no: { NODE: value }\n case \"TSPropertySignature\":\n if (parent.key === node) {\n return !!parent.computed;\n }\n return true;\n }\n return true;\n}\nconst TS_NODE_TYPES = [\n \"TSAsExpression\",\n // foo as number\n \"TSTypeAssertion\",\n // (<number>foo)\n \"TSNonNullExpression\",\n // foo!\n \"TSInstantiationExpression\",\n // foo<string>\n \"TSSatisfiesExpression\"\n // foo satisfies T\n];\nfunction unwrapTSNode(node) {\n if (TS_NODE_TYPES.includes(node.type)) {\n return unwrapTSNode(node.expression);\n } else {\n return node;\n }\n}\n\nconst isStaticExp = (p) => p.type === 4 && p.isStatic;\nfunction isCoreComponent(tag) {\n switch (tag) {\n case \"Teleport\":\n case \"teleport\":\n return TELEPORT;\n case \"Suspense\":\n case \"suspense\":\n return SUSPENSE;\n case \"KeepAlive\":\n case \"keep-alive\":\n return KEEP_ALIVE;\n case \"BaseTransition\":\n case \"base-transition\":\n return BASE_TRANSITION;\n }\n}\nconst nonIdentifierRE = /^$|^\\d|[^\\$\\w\\xA0-\\uFFFF]/;\nconst isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);\nconst validFirstIdentCharRE = /[A-Za-z_$\\xA0-\\uFFFF]/;\nconst validIdentCharRE = /[\\.\\?\\w$\\xA0-\\uFFFF]/;\nconst whitespaceRE = /\\s+[.[]\\s*|\\s*[.[]\\s+/g;\nconst getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;\nconst isMemberExpressionBrowser = (exp) => {\n const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());\n let state = 0 /* inMemberExp */;\n let stateStack = [];\n let currentOpenBracketCount = 0;\n let currentOpenParensCount = 0;\n let currentStringType = null;\n for (let i = 0; i < path.length; i++) {\n const char = path.charAt(i);\n switch (state) {\n case 0 /* inMemberExp */:\n if (char === \"[\") {\n stateStack.push(state);\n state = 1 /* inBrackets */;\n currentOpenBracketCount++;\n } else if (char === \"(\") {\n stateStack.push(state);\n state = 2 /* inParens */;\n currentOpenParensCount++;\n } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {\n return false;\n }\n break;\n case 1 /* inBrackets */:\n if (char === `'` || char === `\"` || char === \"`\") {\n stateStack.push(state);\n state = 3 /* inString */;\n currentStringType = char;\n } else if (char === `[`) {\n currentOpenBracketCount++;\n } else if (char === `]`) {\n if (!--currentOpenBracketCount) {\n state = stateStack.pop();\n }\n }\n break;\n case 2 /* inParens */:\n if (char === `'` || char === `\"` || char === \"`\") {\n stateStack.push(state);\n state = 3 /* inString */;\n currentStringType = char;\n } else if (char === `(`) {\n currentOpenParensCount++;\n } else if (char === `)`) {\n if (i === path.length - 1) {\n return false;\n }\n if (!--currentOpenParensCount) {\n state = stateStack.pop();\n }\n }\n break;\n case 3 /* inString */:\n if (char === currentStringType) {\n state = stateStack.pop();\n currentStringType = null;\n }\n break;\n }\n }\n return !currentOpenBracketCount && !currentOpenParensCount;\n};\nconst isMemberExpressionNode = (exp, context) => {\n try {\n let ret = exp.ast || parser.parseExpression(getExpSource(exp), {\n plugins: context.expressionPlugins ? [...context.expressionPlugins, \"typescript\"] : [\"typescript\"]\n });\n ret = unwrapTSNode(ret);\n return ret.type === \"MemberExpression\" || ret.type === \"OptionalMemberExpression\" || ret.type === \"Identifier\" && ret.name !== \"undefined\";\n } catch (e) {\n return false;\n }\n};\nconst isMemberExpression = isMemberExpressionNode;\nconst fnExpRE = /^\\s*(?:async\\s*)?(?:\\([^)]*?\\)|[\\w$_]+)\\s*(?::[^=]+)?=>|^\\s*(?:async\\s+)?function(?:\\s+[\\w$]+)?\\s*\\(/;\nconst isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));\nconst isFnExpressionNode = (exp, context) => {\n try {\n let ret = exp.ast || parser.parseExpression(getExpSource(exp), {\n plugins: context.expressionPlugins ? [...context.expressionPlugins, \"typescript\"] : [\"typescript\"]\n });\n if (ret.type === \"Program\") {\n ret = ret.body[0];\n if (ret.type === \"ExpressionStatement\") {\n ret = ret.expression;\n }\n }\n ret = unwrapTSNode(ret);\n return ret.type === \"FunctionExpression\" || ret.type === \"ArrowFunctionExpression\";\n } catch (e) {\n return false;\n }\n};\nconst isFnExpression = isFnExpressionNode;\nfunction advancePositionWithClone(pos, source, numberOfCharacters = source.length) {\n return advancePositionWithMutation(\n {\n offset: pos.offset,\n line: pos.line,\n column: pos.column\n },\n source,\n numberOfCharacters\n );\n}\nfunction advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {\n let linesCount = 0;\n let lastNewLinePos = -1;\n for (let i = 0; i < numberOfCharacters; i++) {\n if (source.charCodeAt(i) === 10) {\n linesCount++;\n lastNewLinePos = i;\n }\n }\n pos.offset += numberOfCharacters;\n pos.line += linesCount;\n pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;\n return pos;\n}\nfunction assert(condition, msg) {\n if (!condition) {\n throw new Error(msg || `unexpected compiler condition`);\n }\n}\nfunction findDir(node, name, allowEmpty = false) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) {\n return p;\n }\n }\n}\nfunction findProp(node, name, dynamicOnly = false, allowEmpty = false) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n if (dynamicOnly) continue;\n if (p.name === name && (p.value || allowEmpty)) {\n return p;\n }\n } else if (p.name === \"bind\" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {\n return p;\n }\n }\n}\nfunction isStaticArgOf(arg, name) {\n return !!(arg && isStaticExp(arg) && arg.content === name);\n}\nfunction hasDynamicKeyVBind(node) {\n return node.props.some(\n (p) => p.type === 7 && p.name === \"bind\" && (!p.arg || // v-bind=\"obj\"\n p.arg.type !== 4 || // v-bind:[_ctx.foo]\n !p.arg.isStatic)\n // v-bind:[foo]\n );\n}\nfunction isText$1(node) {\n return node.type === 5 || node.type === 2;\n}\nfunction isVPre(p) {\n return p.type === 7 && p.name === \"pre\";\n}\nfunction isVSlot(p) {\n return p.type === 7 && p.name === \"slot\";\n}\nfunction isTemplateNode(node) {\n return node.type === 1 && node.tagType === 3;\n}\nfunction isSlotOutlet(node) {\n return node.type === 1 && node.tagType === 2;\n}\nconst propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);\nfunction getUnnormalizedProps(props, callPath = []) {\n if (props && !shared.isString(props) && props.type === 14) {\n const callee = props.callee;\n if (!shared.isString(callee) && propsHelperSet.has(callee)) {\n return getUnnormalizedProps(\n props.arguments[0],\n callPath.concat(props)\n );\n }\n }\n return [props, callPath];\n}\nfunction injectProp(node, prop, context) {\n let propsWithInjection;\n let props = node.type === 13 ? node.props : node.arguments[2];\n let callPath = [];\n let parentCall;\n if (props && !shared.isString(props) && props.type === 14) {\n const ret = getUnnormalizedProps(props);\n props = ret[0];\n callPath = ret[1];\n parentCall = callPath[callPath.length - 1];\n }\n if (props == null || shared.isString(props)) {\n propsWithInjection = createObjectExpression([prop]);\n } else if (props.type === 14) {\n const first = props.arguments[0];\n if (!shared.isString(first) && first.type === 15) {\n if (!hasProp(prop, first)) {\n first.properties.unshift(prop);\n }\n } else {\n if (props.callee === TO_HANDLERS) {\n propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n createObjectExpression([prop]),\n props\n ]);\n } else {\n props.arguments.unshift(createObjectExpression([prop]));\n }\n }\n !propsWithInjection && (propsWithInjection = props);\n } else if (props.type === 15) {\n if (!hasProp(prop, props)) {\n props.properties.unshift(prop);\n }\n propsWithInjection = props;\n } else {\n propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n createObjectExpression([prop]),\n props\n ]);\n if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {\n parentCall = callPath[callPath.length - 2];\n }\n }\n if (node.type === 13) {\n if (parentCall) {\n parentCall.arguments[0] = propsWithInjection;\n } else {\n node.props = propsWithInjection;\n }\n } else {\n if (parentCall) {\n parentCall.arguments[0] = propsWithInjection;\n } else {\n node.arguments[2] = propsWithInjection;\n }\n }\n}\nfunction hasProp(prop, props) {\n let result = false;\n if (prop.key.type === 4) {\n const propKeyName = prop.key.content;\n result = props.properties.some(\n (p) => p.key.type === 4 && p.key.content === propKeyName\n );\n }\n return result;\n}\nfunction toValidAssetId(name, type) {\n return `_${type}_${name.replace(/[^\\w]/g, (searchValue, replaceValue) => {\n return searchValue === \"-\" ? \"_\" : name.charCodeAt(replaceValue).toString();\n })}`;\n}\nfunction hasScopeRef(node, ids) {\n if (!node || Object.keys(ids).length === 0) {\n return false;\n }\n switch (node.type) {\n case 1:\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {\n return true;\n }\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 11:\n if (hasScopeRef(node.source, ids)) {\n return true;\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 9:\n return node.branches.some((b) => hasScopeRef(b, ids));\n case 10:\n if (hasScopeRef(node.condition, ids)) {\n return true;\n }\n return node.children.some((c) => hasScopeRef(c, ids));\n case 4:\n return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];\n case 8:\n return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids));\n case 5:\n case 12:\n return hasScopeRef(node.content, ids);\n case 2:\n case 3:\n case 20:\n return false;\n default:\n return false;\n }\n}\nfunction getMemoedVNodeCall(node) {\n if (node.type === 14 && node.callee === WITH_MEMO) {\n return node.arguments[1].returns;\n } else {\n return node;\n }\n}\nconst forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+(\\S[\\s\\S]*)/;\nfunction isAllWhitespace(str) {\n for (let i = 0; i < str.length; i++) {\n if (!isWhitespace(str.charCodeAt(i))) {\n return false;\n }\n }\n return true;\n}\nfunction isWhitespaceText(node) {\n return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content);\n}\nfunction isCommentOrWhitespace(node) {\n return node.type === 3 || isWhitespaceText(node);\n}\n\nconst defaultParserOptions = {\n parseMode: \"base\",\n ns: 0,\n delimiters: [`{{`, `}}`],\n getNamespace: () => 0,\n isVoidTag: shared.NO,\n isPreTag: shared.NO,\n isIgnoreNewlineTag: shared.NO,\n isCustomElement: shared.NO,\n onError: defaultOnError,\n onWarn: defaultOnWarn,\n comments: true,\n prefixIdentifiers: false\n};\nlet currentOptions = defaultParserOptions;\nlet currentRoot = null;\nlet currentInput = \"\";\nlet currentOpenTag = null;\nlet currentProp = null;\nlet currentAttrValue = \"\";\nlet currentAttrStartIndex = -1;\nlet currentAttrEndIndex = -1;\nlet inPre = 0;\nlet inVPre = false;\nlet currentVPreBoundary = null;\nconst stack = [];\nconst tokenizer = new Tokenizer(stack, {\n onerr: emitError,\n ontext(start, end) {\n onText(getSlice(start, end), start, end);\n },\n ontextentity(char, start, end) {\n onText(char, start, end);\n },\n oninterpolation(start, end) {\n if (inVPre) {\n return onText(getSlice(start, end), start, end);\n }\n let innerStart = start + tokenizer.delimiterOpen.length;\n let innerEnd = end - tokenizer.delimiterClose.length;\n while (isWhitespace(currentInput.charCodeAt(innerStart))) {\n innerStart++;\n }\n while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {\n innerEnd--;\n }\n let exp = getSlice(innerStart, innerEnd);\n if (exp.includes(\"&\")) {\n {\n exp = decode.decodeHTML(exp);\n }\n }\n addNode({\n type: 5,\n content: createExp(exp, false, getLoc(innerStart, innerEnd)),\n loc: getLoc(start, end)\n });\n },\n onopentagname(start, end) {\n const name = getSlice(start, end);\n currentOpenTag = {\n type: 1,\n tag: name,\n ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),\n tagType: 0,\n // will be refined on tag close\n props: [],\n children: [],\n loc: getLoc(start - 1, end),\n codegenNode: void 0\n };\n },\n onopentagend(end) {\n endOpenTag(end);\n },\n onclosetag(start, end) {\n const name = getSlice(start, end);\n if (!currentOptions.isVoidTag(name)) {\n let found = false;\n for (let i = 0; i < stack.length; i++) {\n const e = stack[i];\n if (e.tag.toLowerCase() === name.toLowerCase()) {\n found = true;\n if (i > 0) {\n emitError(24, stack[0].loc.start.offset);\n }\n for (let j = 0; j <= i; j++) {\n const el = stack.shift();\n onCloseTag(el, end, j < i);\n }\n break;\n }\n }\n if (!found) {\n emitError(23, backTrack(start, 60));\n }\n }\n },\n onselfclosingtag(end) {\n const name = currentOpenTag.tag;\n currentOpenTag.isSelfClosing = true;\n endOpenTag(end);\n if (stack[0] && stack[0].tag === name) {\n onCloseTag(stack.shift(), end);\n }\n },\n onattribname(start, end) {\n currentProp = {\n type: 6,\n name: getSlice(start, end),\n nameLoc: getLoc(start, end),\n value: void 0,\n loc: getLoc(start)\n };\n },\n ondirname(start, end) {\n const raw = getSlice(start, end);\n const name = raw === \".\" || raw === \":\" ? \"bind\" : raw === \"@\" ? \"on\" : raw === \"#\" ? \"slot\" : raw.slice(2);\n if (!inVPre && name === \"\") {\n emitError(26, start);\n }\n if (inVPre || name === \"\") {\n currentProp = {\n type: 6,\n name: raw,\n nameLoc: getLoc(start, end),\n value: void 0,\n loc: getLoc(start)\n };\n } else {\n currentProp = {\n type: 7,\n name,\n rawName: raw,\n exp: void 0,\n arg: void 0,\n modifiers: raw === \".\" ? [createSimpleExpression(\"prop\")] : [],\n loc: getLoc(start)\n };\n if (name === \"pre\") {\n inVPre = tokenizer.inVPre = true;\n currentVPreBoundary = currentOpenTag;\n const props = currentOpenTag.props;\n for (let i = 0; i < props.length; i++) {\n if (props[i].type === 7) {\n props[i] = dirToAttr(props[i]);\n }\n }\n }\n }\n },\n ondirarg(start, end) {\n if (start === end) return;\n const arg = getSlice(start, end);\n if (inVPre && !isVPre(currentProp)) {\n currentProp.name += arg;\n setLocEnd(currentProp.nameLoc, end);\n } else {\n const isStatic = arg[0] !== `[`;\n currentProp.arg = createExp(\n isStatic ? arg : arg.slice(1, -1),\n isStatic,\n getLoc(start, end),\n isStatic ? 3 : 0\n );\n }\n },\n ondirmodifier(start, end) {\n const mod = getSlice(start, end);\n if (inVPre && !isVPre(currentProp)) {\n currentProp.name += \".\" + mod;\n setLocEnd(currentProp.nameLoc, end);\n } else if (currentProp.name === \"slot\") {\n const arg = currentProp.arg;\n if (arg) {\n arg.content += \".\" + mod;\n setLocEnd(arg.loc, end);\n }\n } else {\n const exp = createSimpleExpression(mod, true, getLoc(start, end));\n currentProp.modifiers.push(exp);\n }\n },\n onattribdata(start, end) {\n currentAttrValue += getSlice(start, end);\n if (currentAttrStartIndex < 0) currentAttrStartIndex = start;\n currentAttrEndIndex = end;\n },\n onattribentity(char, start, end) {\n currentAttrValue += char;\n if (currentAttrStartIndex < 0) currentAttrStartIndex = start;\n currentAttrEndIndex = end;\n },\n onattribnameend(end) {\n const start = currentProp.loc.start.offset;\n const name = getSlice(start, end);\n if (currentProp.type === 7) {\n currentProp.rawName = name;\n }\n if (currentOpenTag.props.some(\n (p) => (p.type === 7 ? p.rawName : p.name) === name\n )) {\n emitError(2, start);\n }\n },\n onattribend(quote, end) {\n if (currentOpenTag && currentProp) {\n setLocEnd(currentProp.loc, end);\n if (quote !== 0) {\n if (currentProp.type === 6) {\n if (currentProp.name === \"class\") {\n currentAttrValue = condense(currentAttrValue).trim();\n }\n if (quote === 1 && !currentAttrValue) {\n emitError(13, end);\n }\n currentProp.value = {\n type: 2,\n content: currentAttrValue,\n loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)\n };\n if (tokenizer.inSFCRoot && currentOpenTag.tag === \"template\" && currentProp.name === \"lang\" && currentAttrValue && currentAttrValue !== \"html\") {\n tokenizer.enterRCDATA(toCharCodes(`</template`), 0);\n }\n } else {\n let expParseMode = 0 /* Normal */;\n {\n if (currentProp.name === \"for\") {\n expParseMode = 3 /* Skip */;\n } else if (currentProp.name === \"slot\") {\n expParseMode = 1 /* Params */;\n } else if (currentProp.name === \"on\" && currentAttrValue.includes(\";\")) {\n expParseMode = 2 /* Statements */;\n }\n }\n currentProp.exp = createExp(\n currentAttrValue,\n false,\n getLoc(currentAttrStartIndex, currentAttrEndIndex),\n 0,\n expParseMode\n );\n if (currentProp.name === \"for\") {\n currentProp.forParseResult = parseForExpression(currentProp.exp);\n }\n let syncIndex = -1;\n if (currentProp.name === \"bind\" && (syncIndex = currentProp.modifiers.findIndex(\n (mod) => mod.content === \"sync\"\n )) > -1 && checkCompatEnabled(\n \"COMPILER_V_BIND_SYNC\",\n currentOptions,\n currentProp.loc,\n currentProp.arg.loc.source\n )) {\n currentProp.name = \"model\";\n currentProp.modifiers.splice(syncIndex, 1);\n }\n }\n }\n if (currentProp.type !== 7 || currentProp.name !== \"pre\") {\n currentOpenTag.props.push(currentProp);\n }\n }\n currentAttrValue = \"\";\n currentAttrStartIndex = currentAttrEndIndex = -1;\n },\n oncomment(start, end) {\n if (currentOptions.comments) {\n addNode({\n type: 3,\n content: getSlice(start, end),\n loc: getLoc(start - 4, end + 3)\n });\n }\n },\n onend() {\n const end = currentInput.length;\n if (tokenizer.state !== 1) {\n switch (tokenizer.state) {\n case 5:\n case 8:\n emitError(5, end);\n break;\n case 3:\n case 4:\n emitError(\n 25,\n tokenizer.sectionStart\n );\n break;\n case 28:\n if (tokenizer.currentSequence === Sequences.CdataEnd) {\n emitError(6, end);\n } else {\n emitError(7, end);\n }\n break;\n case 6:\n case 7:\n case 9:\n case 11:\n case 12:\n case 13:\n case 14:\n case 15:\n case 16:\n case 17:\n case 18:\n case 19:\n // \"\n case 20:\n // '\n case 21:\n emitError(9, end);\n break;\n }\n }\n for (let index = 0; index < stack.length; index++) {\n onCloseTag(stack[index], end - 1);\n emitError(24, stack[index].loc.start.offset);\n }\n },\n oncdata(start, end) {\n if (stack[0].ns !== 0) {\n onText(getSlice(start, end), start, end);\n } else {\n emitError(1, start - 9);\n }\n },\n onprocessinginstruction(start) {\n if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {\n emitError(\n 21,\n start - 1\n );\n }\n }\n});\nconst forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nconst stripParensRE = /^\\(|\\)$/g;\nfunction parseForExpression(input) {\n const loc = input.loc;\n const exp = input.content;\n const inMatch = exp.match(forAliasRE);\n if (!inMatch) return;\n const [, LHS, RHS] = inMatch;\n const createAliasExpression = (content, offset, asParam = false) => {\n const start = loc.start.offset + offset;\n const end = start + content.length;\n return createExp(\n content,\n false,\n getLoc(start, end),\n 0,\n asParam ? 1 /* Params */ : 0 /* Normal */\n );\n };\n const result = {\n source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),\n value: void 0,\n key: void 0,\n index: void 0,\n finalized: false\n };\n let valueContent = LHS.trim().replace(stripParensRE, \"\").trim();\n const trimmedOffset = LHS.indexOf(valueContent);\n const iteratorMatch = valueContent.match(forIteratorRE);\n if (iteratorMatch) {\n valueContent = valueContent.replace(forIteratorRE, \"\").trim();\n const keyContent = iteratorMatch[1].trim();\n let keyOffset;\n if (keyContent) {\n keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);\n result.key = createAliasExpression(keyContent, keyOffset, true);\n }\n if (iteratorMatch[2]) {\n const indexContent = iteratorMatch[2].trim();\n if (indexContent) {\n result.index = createAliasExpression(\n indexContent,\n exp.indexOf(\n indexContent,\n result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length\n ),\n true\n );\n }\n }\n }\n if (valueContent) {\n result.value = createAliasExpression(valueContent, trimmedOffset, true);\n }\n return result;\n}\nfunction getSlice(start, end) {\n return currentInput.slice(start, end);\n}\nfunction endOpenTag(end) {\n if (tokenizer.inSFCRoot) {\n currentOpenTag.innerLoc = getLoc(end + 1, end + 1);\n }\n addNode(currentOpenTag);\n const { tag, ns } = currentOpenTag;\n if (ns === 0 && currentOptions.isPreTag(tag)) {\n inPre++;\n }\n if (currentOptions.isVoidTag(tag)) {\n onCloseTag(currentOpenTag, end);\n } else {\n stack.unshift(currentOpenTag);\n if (ns === 1 || ns === 2) {\n tokenizer.inXML = true;\n }\n }\n currentOpenTag = null;\n}\nfunction onText(content, start, end) {\n const parent = stack[0] || currentRoot;\n const lastNode = parent.children[parent.children.length - 1];\n if (lastNode && lastNode.type === 2) {\n lastNode.content += content;\n setLocEnd(lastNode.loc, end);\n } else {\n parent.children.push({\n type: 2,\n content,\n loc: getLoc(start, end)\n });\n }\n}\nfunction onCloseTag(el, end, isImplied = false) {\n if (isImplied) {\n setLocEnd(el.loc, backTrack(end, 60));\n } else {\n setLocEnd(el.loc, lookAhead(end, 62) + 1);\n }\n if (tokenizer.inSFCRoot) {\n if (el.children.length) {\n el.innerLoc.end = shared.extend({}, el.children[el.children.length - 1].loc.end);\n } else {\n el.innerLoc.end = shared.extend({}, el.innerLoc.start);\n }\n el.innerLoc.source = getSlice(\n el.innerLoc.start.offset,\n el.innerLoc.end.offset\n );\n }\n const { tag, ns, children } = el;\n if (!inVPre) {\n if (tag === \"slot\") {\n el.tagType = 2;\n } else if (isFragmentTemplate(el)) {\n el.tagType = 3;\n } else if (isComponent(el)) {\n el.tagType = 1;\n }\n }\n if (!tokenizer.inRCDATA) {\n el.children = condenseWhitespace(children);\n }\n if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {\n const first = children[0];\n if (first && first.type === 2) {\n first.content = first.content.replace(/^\\r?\\n/, \"\");\n }\n }\n if (ns === 0 && currentOptions.isPreTag(tag)) {\n inPre--;\n }\n if (currentVPreBoundary === el) {\n inVPre = tokenizer.inVPre = false;\n currentVPreBoundary = null;\n }\n if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {\n tokenizer.inXML = false;\n }\n {\n const props = el.props;\n if (isCompatEnabled(\n \"COMPILER_V_IF_V_FOR_PRECEDENCE\",\n currentOptions\n )) {\n let hasIf = false;\n let hasFor = false;\n for (let i = 0; i < props.length; i++) {\n const p = props[i];\n if (p.type === 7) {\n if (p.name === \"if\") {\n hasIf = true;\n } else if (p.name === \"for\") {\n hasFor = true;\n }\n }\n if (hasIf && hasFor) {\n warnDeprecation(\n \"COMPILER_V_IF_V_FOR_PRECEDENCE\",\n currentOptions,\n el.loc\n );\n break;\n }\n }\n }\n if (!tokenizer.inSFCRoot && isCompatEnabled(\n \"COMPILER_NATIVE_TEMPLATE\",\n currentOptions\n ) && el.tag === \"template\" && !isFragmentTemplate(el)) {\n warnDeprecation(\n \"COMPILER_NATIVE_TEMPLATE\",\n currentOptions,\n el.loc\n );\n const parent = stack[0] || currentRoot;\n const index = parent.children.indexOf(el);\n parent.children.splice(index, 1, ...el.children);\n }\n const inlineTemplateProp = props.find(\n (p) => p.type === 6 && p.name === \"inline-template\"\n );\n if (inlineTemplateProp && checkCompatEnabled(\n \"COMPILER_INLINE_TEMPLATE\",\n currentOptions,\n inlineTemplateProp.loc\n ) && el.children.length) {\n inlineTemplateProp.value = {\n type: 2,\n content: getSlice(\n el.children[0].loc.start.offset,\n el.children[el.children.length - 1].loc.end.offset\n ),\n loc: inlineTemplateProp.loc\n };\n }\n }\n}\nfunction lookAhead(index, c) {\n let i = index;\n while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;\n return i;\n}\nfunction backTrack(index, c) {\n let i = index;\n while (currentInput.charCodeAt(i) !== c && i >= 0) i--;\n return i;\n}\nconst specialTemplateDir = /* @__PURE__ */ new Set([\"if\", \"else\", \"else-if\", \"for\", \"slot\"]);\nfunction isFragmentTemplate({ tag, props }) {\n if (tag === \"template\") {\n for (let i = 0; i < props.length; i++) {\n if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {\n return true;\n }\n }\n }\n return false;\n}\nfunction isComponent({ tag, props }) {\n if (currentOptions.isCustomElement(tag)) {\n return false;\n }\n if (tag === \"component\" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {\n return true;\n }\n for (let i = 0; i < props.length; i++) {\n const p = props[i];\n if (p.type === 6) {\n if (p.name === \"is\" && p.value) {\n if (p.value.content.startsWith(\"vue:\")) {\n return true;\n } else if (checkCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n currentOptions,\n p.loc\n )) {\n return true;\n }\n }\n } else if (// :is on plain element - only treat as component in compat mode\n p.name === \"bind\" && isStaticArgOf(p.arg, \"is\") && checkCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n currentOptions,\n p.loc\n )) {\n return true;\n }\n }\n return false;\n}\nfunction isUpperCase(c) {\n return c > 64 && c < 91;\n}\nconst windowsNewlineRE = /\\r\\n/g;\nfunction condenseWhitespace(nodes) {\n const shouldCondense = currentOptions.whitespace !== \"preserve\";\n let removedWhitespace = false;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (node.type === 2) {\n if (!inPre) {\n if (isAllWhitespace(node.content)) {\n const prev = nodes[i - 1] && nodes[i - 1].type;\n const next = nodes[i + 1] && nodes[i + 1].type;\n if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {\n removedWhitespace = true;\n nodes[i] = null;\n } else {\n node.content = \" \";\n }\n } else if (shouldCondense) {\n node.content = condense(node.content);\n }\n } else {\n node.content = node.content.replace(windowsNewlineRE, \"\\n\");\n }\n }\n }\n return removedWhitespace ? nodes.filter(Boolean) : nodes;\n}\nfunction hasNewlineChar(str) {\n for (let i = 0; i < str.length; i++) {\n const c = str.charCodeAt(i);\n if (c === 10 || c === 13) {\n return true;\n }\n }\n return false;\n}\nfunction condense(str) {\n let ret = \"\";\n let prevCharIsWhitespace = false;\n for (let i = 0; i < str.length; i++) {\n if (isWhitespace(str.charCodeAt(i))) {\n if (!prevCharIsWhitespace) {\n ret += \" \";\n prevCharIsWhitespace = true;\n }\n } else {\n ret += str[i];\n prevCharIsWhitespace = false;\n }\n }\n return ret;\n}\nfunction addNode(node) {\n (stack[0] || currentRoot).children.push(node);\n}\nfunction getLoc(start, end) {\n return {\n start: tokenizer.getPos(start),\n // @ts-expect-error allow late attachment\n end: end == null ? end : tokenizer.getPos(end),\n // @ts-expect-error allow late attachment\n source: end == null ? end : getSlice(start, end)\n };\n}\nfunction cloneLoc(loc) {\n return getLoc(loc.start.offset, loc.end.offset);\n}\nfunction setLocEnd(loc, end) {\n loc.end = tokenizer.getPos(end);\n loc.source = getSlice(loc.start.offset, end);\n}\nfunction dirToAttr(dir) {\n const attr = {\n type: 6,\n name: dir.rawName,\n nameLoc: getLoc(\n dir.loc.start.offset,\n dir.loc.start.offset + dir.rawName.length\n ),\n value: void 0,\n loc: dir.loc\n };\n if (dir.exp) {\n const loc = dir.exp.loc;\n if (loc.end.offset < dir.loc.end.offset) {\n loc.start.offset--;\n loc.start.column--;\n loc.end.offset++;\n loc.end.column++;\n }\n attr.value = {\n type: 2,\n content: dir.exp.content,\n loc\n };\n }\n return attr;\n}\nfunction createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {\n const exp = createSimpleExpression(content, isStatic, loc, constType);\n if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 /* Skip */ && content.trim()) {\n if (isSimpleIdentifier(content)) {\n exp.ast = null;\n return exp;\n }\n try {\n const plugins = currentOptions.expressionPlugins;\n const options = {\n plugins: plugins ? [...plugins, \"typescript\"] : [\"typescript\"]\n };\n if (parseMode === 2 /* Statements */) {\n exp.ast = parser.parse(` ${content} `, options).program;\n } else if (parseMode === 1 /* Params */) {\n exp.ast = parser.parseExpression(`(${content})=>{}`, options);\n } else {\n exp.ast = parser.parseExpression(`(${content})`, options);\n }\n } catch (e) {\n exp.ast = false;\n emitError(46, loc.start.offset, e.message);\n }\n }\n return exp;\n}\nfunction emitError(code, index, message) {\n currentOptions.onError(\n createCompilerError(code, getLoc(index, index), void 0, message)\n );\n}\nfunction reset() {\n tokenizer.reset();\n currentOpenTag = null;\n currentProp = null;\n currentAttrValue = \"\";\n currentAttrStartIndex = -1;\n currentAttrEndIndex = -1;\n stack.length = 0;\n}\nfunction baseParse(input, options) {\n reset();\n currentInput = input;\n currentOptions = shared.extend({}, defaultParserOptions);\n if (options) {\n let key;\n for (key in options) {\n if (options[key] != null) {\n currentOptions[key] = options[key];\n }\n }\n }\n {\n if (currentOptions.decodeEntities) {\n console.warn(\n `[@vue/compiler-core] decodeEntities option is passed but will be ignored in non-browser builds.`\n );\n }\n }\n tokenizer.mode = currentOptions.parseMode === \"html\" ? 1 : currentOptions.parseMode === \"sfc\" ? 2 : 0;\n tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;\n const delimiters = options && options.delimiters;\n if (delimiters) {\n tokenizer.delimiterOpen = toCharCodes(delimiters[0]);\n tokenizer.delimiterClose = toCharCodes(delimiters[1]);\n }\n const root = currentRoot = createRoot([], input);\n tokenizer.parse(currentInput);\n root.loc = getLoc(0, input.length);\n root.children = condenseWhitespace(root.children);\n currentRoot = null;\n return root;\n}\n\nfunction cacheStatic(root, context) {\n walk(\n root,\n void 0,\n context,\n // Root node is unfortunately non-hoistable due to potential parent\n // fallthrough attributes.\n !!getSingleElementRoot(root)\n );\n}\nfunction getSingleElementRoot(root) {\n const children = root.children.filter((x) => x.type !== 3);\n return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;\n}\nfunction walk(node, parent, context, doNotHoistNode = false, inFor = false) {\n const { children } = node;\n const toCache = [];\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (child.type === 1 && child.tagType === 0) {\n const constantType = doNotHoistNode ? 0 : getConstantType(child, context);\n if (constantType > 0) {\n if (constantType >= 2) {\n child.codegenNode.patchFlag = -1;\n toCache.push(child);\n continue;\n }\n } else {\n const codegenNode = child.codegenNode;\n if (codegenNode.type === 13) {\n const flag = codegenNode.patchFlag;\n if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {\n const props = getNodeProps(child);\n if (props) {\n codegenNode.props = context.hoist(props);\n }\n }\n if (codegenNode.dynamicProps) {\n codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);\n }\n }\n }\n } else if (child.type === 12) {\n const constantType = doNotHoistNode ? 0 : getConstantType(child, context);\n if (constantType >= 2) {\n if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) {\n child.codegenNode.arguments.push(\n -1 + (` /* ${shared.PatchFlagNames[-1]} */` )\n );\n }\n toCache.push(child);\n continue;\n }\n }\n if (child.type === 1) {\n const isComponent = child.tagType === 1;\n if (isComponent) {\n context.scopes.vSlot++;\n }\n walk(child, node, context, false, inFor);\n if (isComponent) {\n context.scopes.vSlot--;\n }\n } else if (child.type === 11) {\n walk(child, node, context, child.children.length === 1, true);\n } else if (child.type === 9) {\n for (let i2 = 0; i2 < child.branches.length; i2++) {\n walk(\n child.branches[i2],\n node,\n context,\n child.branches[i2].children.length === 1,\n inFor\n );\n }\n }\n }\n let cachedAsArray = false;\n if (toCache.length === children.length && node.type === 1) {\n if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) {\n node.codegenNode.children = getCacheExpression(\n createArrayExpression(node.codegenNode.children)\n );\n cachedAsArray = true;\n } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared.isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {\n const slot = getSlotNode(node.codegenNode, \"default\");\n if (slot) {\n slot.returns = getCacheExpression(\n createArrayExpression(slot.returns)\n );\n cachedAsArray = true;\n }\n } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {\n const slotName = findDir(node, \"slot\", true);\n const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);\n if (slot) {\n slot.returns = getCacheExpression(\n createArrayExpression(slot.returns)\n );\n cachedAsArray = true;\n }\n }\n }\n if (!cachedAsArray) {\n for (const child of toCache) {\n child.codegenNode = context.cache(child.codegenNode);\n }\n }\n function getCacheExpression(value) {\n const exp = context.cache(value);\n exp.needArraySpread = true;\n return exp;\n }\n function getSlotNode(node2, name) {\n if (node2.children && !shared.isArray(node2.children) && node2.children.type === 15) {\n const slot = node2.children.properties.find(\n (p) => p.key === name || p.key.content === name\n );\n return slot && slot.value;\n }\n }\n if (toCache.length && context.transformHoist) {\n context.transformHoist(children, context, node);\n }\n}\nfunction getConstantType(node, context) {\n const { constantCache } = context;\n switch (node.type) {\n case 1:\n if (node.tagType !== 0) {\n return 0;\n }\n const cached = constantCache.get(node);\n if (cached !== void 0) {\n return cached;\n }\n const codegenNode = node.codegenNode;\n if (codegenNode.type !== 13) {\n return 0;\n }\n if (codegenNode.isBlock && node.tag !== \"svg\" && node.tag !== \"foreignObject\" && node.tag !== \"math\") {\n return 0;\n }\n if (codegenNode.patchFlag === void 0) {\n let returnType2 = 3;\n const generatedPropsType = getGeneratedPropsConstantType(node, context);\n if (generatedPropsType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (generatedPropsType < returnType2) {\n returnType2 = generatedPropsType;\n }\n for (let i = 0; i < node.children.length; i++) {\n const childType = getConstantType(node.children[i], context);\n if (childType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (childType < returnType2) {\n returnType2 = childType;\n }\n }\n if (returnType2 > 1) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7 && p.name === \"bind\" && p.exp) {\n const expType = getConstantType(p.exp, context);\n if (expType === 0) {\n constantCache.set(node, 0);\n return 0;\n }\n if (expType < returnType2) {\n returnType2 = expType;\n }\n }\n }\n }\n if (codegenNode.isBlock) {\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 7) {\n constantCache.set(node, 0);\n return 0;\n }\n }\n context.removeHelper(OPEN_BLOCK);\n context.removeHelper(\n getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)\n );\n codegenNode.isBlock = false;\n context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));\n }\n constantCache.set(node, returnType2);\n return returnType2;\n } else {\n constantCache.set(node, 0);\n return 0;\n }\n case 2:\n case 3:\n return 3;\n case 9:\n case 11:\n case 10:\n return 0;\n case 5:\n case 12:\n return getConstantType(node.content, context);\n case 4:\n return node.constType;\n case 8:\n let returnType = 3;\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (shared.isString(child) || shared.isSymbol(child)) {\n continue;\n }\n const childType = getConstantType(child, context);\n if (childType === 0) {\n return 0;\n } else if (childType < returnType) {\n returnType = childType;\n }\n }\n return returnType;\n case 20:\n return 2;\n default:\n return 0;\n }\n}\nconst allowHoistedHelperSet = /* @__PURE__ */ new Set([\n NORMALIZE_CLASS,\n NORMALIZE_STYLE,\n NORMALIZE_PROPS,\n GUARD_REACTIVE_PROPS\n]);\nfunction getConstantTypeOfHelperCall(value, context) {\n if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {\n const arg = value.arguments[0];\n if (arg.type === 4) {\n return getConstantType(arg, context);\n } else if (arg.type === 14) {\n return getConstantTypeOfHelperCall(arg, context);\n }\n }\n return 0;\n}\nfunction getGeneratedPropsConstantType(node, context) {\n let returnType = 3;\n const props = getNodeProps(node);\n if (props && props.type === 15) {\n const { properties } = props;\n for (let i = 0; i < properties.length; i++) {\n const { key, value } = properties[i];\n const keyType = getConstantType(key, context);\n if (keyType === 0) {\n return keyType;\n }\n if (keyType < returnType) {\n returnType = keyType;\n }\n let valueType;\n if (value.type === 4) {\n valueType = getConstantType(value, context);\n } else if (value.type === 14) {\n valueType = getConstantTypeOfHelperCall(value, context);\n } else {\n valueType = 0;\n }\n if (valueType === 0) {\n return valueType;\n }\n if (valueType < returnType) {\n returnType = valueType;\n }\n }\n }\n return returnType;\n}\nfunction getNodeProps(node) {\n const codegenNode = node.codegenNode;\n if (codegenNode.type === 13) {\n return codegenNode.props;\n }\n}\n\nfunction createTransformContext(root, {\n filename = \"\",\n prefixIdentifiers = false,\n hoistStatic = false,\n hmr = false,\n cacheHandlers = false,\n nodeTransforms = [],\n directiveTransforms = {},\n transformHoist = null,\n isBuiltInComponent = shared.NOOP,\n isCustomElement = shared.NOOP,\n expressionPlugins = [],\n scopeId = null,\n slotted = true,\n ssr = false,\n inSSR = false,\n ssrCssVars = ``,\n bindingMetadata = shared.EMPTY_OBJ,\n inline = false,\n isTS = false,\n onError = defaultOnError,\n onWarn = defaultOnWarn,\n compatConfig\n}) {\n const nameMatch = filename.replace(/\\?.*$/, \"\").match(/([^/\\\\]+)\\.\\w+$/);\n const context = {\n // options\n filename,\n selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),\n prefixIdentifiers,\n hoistStatic,\n hmr,\n cacheHandlers,\n nodeTransforms,\n directiveTransforms,\n transformHoist,\n isBuiltInComponent,\n isCustomElement,\n expressionPlugins,\n scopeId,\n slotted,\n ssr,\n inSSR,\n ssrCssVars,\n bindingMetadata,\n inline,\n isTS,\n onError,\n onWarn,\n compatConfig,\n // state\n root,\n helpers: /* @__PURE__ */ new Map(),\n components: /* @__PURE__ */ new Set(),\n directives: /* @__PURE__ */ new Set(),\n hoists: [],\n imports: [],\n cached: [],\n constantCache: /* @__PURE__ */ new WeakMap(),\n temps: 0,\n identifiers: /* @__PURE__ */ Object.create(null),\n scopes: {\n vFor: 0,\n vSlot: 0,\n vPre: 0,\n vOnce: 0\n },\n parent: null,\n grandParent: null,\n currentNode: root,\n childIndex: 0,\n inVOnce: false,\n // methods\n helper(name) {\n const count = context.helpers.get(name) || 0;\n context.helpers.set(name, count + 1);\n return name;\n },\n removeHelper(name) {\n const count = context.helpers.get(name);\n if (count) {\n const currentCount = count - 1;\n if (!currentCount) {\n context.helpers.delete(name);\n } else {\n context.helpers.set(name, currentCount);\n }\n }\n },\n helperString(name) {\n return `_${helperNameMap[context.helper(name)]}`;\n },\n replaceNode(node) {\n {\n if (!context.currentNode) {\n throw new Error(`Node being replaced is already removed.`);\n }\n if (!context.parent) {\n throw new Error(`Cannot replace root node.`);\n }\n }\n context.parent.children[context.childIndex] = context.currentNode = node;\n },\n removeNode(node) {\n if (!context.parent) {\n throw new Error(`Cannot remove root node.`);\n }\n const list = context.parent.children;\n const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;\n if (removalIndex < 0) {\n throw new Error(`node being removed is not a child of current parent`);\n }\n if (!node || node === context.currentNode) {\n context.currentNode = null;\n context.onNodeRemoved();\n } else {\n if (context.childIndex > removalIndex) {\n context.childIndex--;\n context.onNodeRemoved();\n }\n }\n context.parent.children.splice(removalIndex, 1);\n },\n onNodeRemoved: shared.NOOP,\n addIdentifiers(exp) {\n {\n if (shared.isString(exp)) {\n addId(exp);\n } else if (exp.identifiers) {\n exp.identifiers.forEach(addId);\n } else if (exp.type === 4) {\n addId(exp.content);\n }\n }\n },\n removeIdentifiers(exp) {\n {\n if (shared.isString(exp)) {\n removeId(exp);\n } else if (exp.identifiers) {\n exp.identifiers.forEach(removeId);\n } else if (exp.type === 4) {\n removeId(exp.content);\n }\n }\n },\n hoist(exp) {\n if (shared.isString(exp)) exp = createSimpleExpression(exp);\n context.hoists.push(exp);\n const identifier = createSimpleExpression(\n `_hoisted_${context.hoists.length}`,\n false,\n exp.loc,\n 2\n );\n identifier.hoisted = exp;\n return identifier;\n },\n cache(exp, isVNode = false, inVOnce = false) {\n const cacheExp = createCacheExpression(\n context.cached.length,\n exp,\n isVNode,\n inVOnce\n );\n context.cached.push(cacheExp);\n return cacheExp;\n }\n };\n {\n context.filters = /* @__PURE__ */ new Set();\n }\n function addId(id) {\n const { identifiers } = context;\n if (identifiers[id] === void 0) {\n identifiers[id] = 0;\n }\n identifiers[id]++;\n }\n function removeId(id) {\n context.identifiers[id]--;\n }\n return context;\n}\nfunction transform(root, options) {\n const context = createTransformContext(root, options);\n traverseNode(root, context);\n if (options.hoistStatic) {\n cacheStatic(root, context);\n }\n if (!options.ssr) {\n createRootCodegen(root, context);\n }\n root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);\n root.components = [...context.components];\n root.directives = [...context.directives];\n root.imports = context.imports;\n root.hoists = context.hoists;\n root.temps = context.temps;\n root.cached = context.cached;\n root.transformed = true;\n {\n root.filters = [...context.filters];\n }\n}\nfunction createRootCodegen(root, context) {\n const { helper } = context;\n const { children } = root;\n if (children.length === 1) {\n const singleElementRootChild = getSingleElementRoot(root);\n if (singleElementRootChild && singleElementRootChild.codegenNode) {\n const codegenNode = singleElementRootChild.codegenNode;\n if (codegenNode.type === 13) {\n convertToBlock(codegenNode, context);\n }\n root.codegenNode = codegenNode;\n } else {\n root.codegenNode = children[0];\n }\n } else if (children.length > 1) {\n let patchFlag = 64;\n if (children.filter((c) => c.type !== 3).length === 1) {\n patchFlag |= 2048;\n }\n root.codegenNode = createVNodeCall(\n context,\n helper(FRAGMENT),\n void 0,\n root.children,\n patchFlag,\n void 0,\n void 0,\n true,\n void 0,\n false\n );\n } else ;\n}\nfunction traverseChildren(parent, context) {\n let i = 0;\n const nodeRemoved = () => {\n i--;\n };\n for (; i < parent.children.length; i++) {\n const child = parent.children[i];\n if (shared.isString(child)) continue;\n context.grandParent = context.parent;\n context.parent = parent;\n context.childIndex = i;\n context.onNodeRemoved = nodeRemoved;\n traverseNode(child, context);\n }\n}\nfunction traverseNode(node, context) {\n context.currentNode = node;\n const { nodeTransforms } = context;\n const exitFns = [];\n for (let i2 = 0; i2 < nodeTransforms.length; i2++) {\n const onExit = nodeTransforms[i2](node, context);\n if (onExit) {\n if (shared.isArray(onExit)) {\n exitFns.push(...onExit);\n } else {\n exitFns.push(onExit);\n }\n }\n if (!context.currentNode) {\n return;\n } else {\n node = context.currentNode;\n }\n }\n switch (node.type) {\n case 3:\n if (!context.ssr) {\n context.helper(CREATE_COMMENT);\n }\n break;\n case 5:\n if (!context.ssr) {\n context.helper(TO_DISPLAY_STRING);\n }\n break;\n // for container types, further traverse downwards\n case 9:\n for (let i2 = 0; i2 < node.branches.length; i2++) {\n traverseNode(node.branches[i2], context);\n }\n break;\n case 10:\n case 11:\n case 1:\n case 0:\n traverseChildren(node, context);\n break;\n }\n context.currentNode = node;\n let i = exitFns.length;\n while (i--) {\n exitFns[i]();\n }\n}\nfunction createStructuralDirectiveTransform(name, fn) {\n const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n);\n return (node, context) => {\n if (node.type === 1) {\n const { props } = node;\n if (node.tagType === 3 && props.some(isVSlot)) {\n return;\n }\n const exitFns = [];\n for (let i = 0; i < props.length; i++) {\n const prop = props[i];\n if (prop.type === 7 && matches(prop.name)) {\n props.splice(i, 1);\n i--;\n const onExit = fn(node, prop, context);\n if (onExit) exitFns.push(onExit);\n }\n }\n return exitFns;\n }\n };\n}\n\nconst PURE_ANNOTATION = `/*@__PURE__*/`;\nconst aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;\nfunction createCodegenContext(ast, {\n mode = \"function\",\n prefixIdentifiers = mode === \"module\",\n sourceMap = false,\n filename = `template.vue.html`,\n scopeId = null,\n optimizeImports = false,\n runtimeGlobalName = `Vue`,\n runtimeModuleName = `vue`,\n ssrRuntimeModuleName = \"vue/server-renderer\",\n ssr = false,\n isTS = false,\n inSSR = false\n}) {\n const context = {\n mode,\n prefixIdentifiers,\n sourceMap,\n filename,\n scopeId,\n optimizeImports,\n runtimeGlobalName,\n runtimeModuleName,\n ssrRuntimeModuleName,\n ssr,\n isTS,\n inSSR,\n source: ast.source,\n code: ``,\n column: 1,\n line: 1,\n offset: 0,\n indentLevel: 0,\n pure: false,\n map: void 0,\n helper(key) {\n return `_${helperNameMap[key]}`;\n },\n push(code, newlineIndex = -2 /* None */, node) {\n context.code += code;\n if (context.map) {\n if (node) {\n let name;\n if (node.type === 4 && !node.isStatic) {\n const content = node.content.replace(/^_ctx\\./, \"\");\n if (content !== node.content && isSimpleIdentifier(content)) {\n name = content;\n }\n }\n if (node.loc.source) {\n addMapping(node.loc.start, name);\n }\n }\n if (newlineIndex === -3 /* Unknown */) {\n advancePositionWithMutation(context, code);\n } else {\n context.offset += code.length;\n if (newlineIndex === -2 /* None */) {\n context.column += code.length;\n } else {\n if (newlineIndex === -1 /* End */) {\n newlineIndex = code.length - 1;\n }\n context.line++;\n context.column = code.length - newlineIndex;\n }\n }\n if (node && node.loc !== locStub && node.loc.source) {\n addMapping(node.loc.end);\n }\n }\n },\n indent() {\n newline(++context.indentLevel);\n },\n deindent(withoutNewLine = false) {\n if (withoutNewLine) {\n --context.indentLevel;\n } else {\n newline(--context.indentLevel);\n }\n },\n newline() {\n newline(context.indentLevel);\n }\n };\n function newline(n) {\n context.push(\"\\n\" + ` `.repeat(n), 0 /* Start */);\n }\n function addMapping(loc, name = null) {\n const { _names, _mappings } = context.map;\n if (name !== null && !_names.has(name)) _names.add(name);\n _mappings.add({\n originalLine: loc.line,\n originalColumn: loc.column - 1,\n // source-map column is 0 based\n generatedLine: context.line,\n generatedColumn: context.column - 1,\n source: filename,\n name\n });\n }\n if (sourceMap) {\n context.map = new sourceMapJs.SourceMapGenerator();\n context.map.setSourceContent(filename, context.source);\n context.map._sources.add(filename);\n }\n return context;\n}\nfunction generate(ast, options = {}) {\n const context = createCodegenContext(ast, options);\n if (options.onContextCreated) options.onContextCreated(context);\n const {\n mode,\n push,\n prefixIdentifiers,\n indent,\n deindent,\n newline,\n scopeId,\n ssr\n } = context;\n const helpers = Array.from(ast.helpers);\n const hasHelpers = helpers.length > 0;\n const useWithBlock = !prefixIdentifiers && mode !== \"module\";\n const genScopeId = scopeId != null && mode === \"module\";\n const isSetupInlined = !!options.inline;\n const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;\n if (mode === \"module\") {\n genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);\n } else {\n genFunctionPreamble(ast, preambleContext);\n }\n const functionName = ssr ? `ssrRender` : `render`;\n const args = ssr ? [\"_ctx\", \"_push\", \"_parent\", \"_attrs\"] : [\"_ctx\", \"_cache\"];\n if (options.bindingMetadata && !options.inline) {\n args.push(\"$props\", \"$setup\", \"$data\", \"$options\");\n }\n const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(\",\") : args.join(\", \");\n if (isSetupInlined) {\n push(`(${signature}) => {`);\n } else {\n push(`function ${functionName}(${signature}) {`);\n }\n indent();\n if (useWithBlock) {\n push(`with (_ctx) {`);\n indent();\n if (hasHelpers) {\n push(\n `const { ${helpers.map(aliasHelper).join(\", \")} } = _Vue\n`,\n -1 /* End */\n );\n newline();\n }\n }\n if (ast.components.length) {\n genAssets(ast.components, \"component\", context);\n if (ast.directives.length || ast.temps > 0) {\n newline();\n }\n }\n if (ast.directives.length) {\n genAssets(ast.directives, \"directive\", context);\n if (ast.temps > 0) {\n newline();\n }\n }\n if (ast.filters && ast.filters.length) {\n newline();\n genAssets(ast.filters, \"filter\", context);\n newline();\n }\n if (ast.temps > 0) {\n push(`let `);\n for (let i = 0; i < ast.temps; i++) {\n push(`${i > 0 ? `, ` : ``}_temp${i}`);\n }\n }\n if (ast.components.length || ast.directives.length || ast.temps) {\n push(`\n`, 0 /* Start */);\n newline();\n }\n if (!ssr) {\n push(`return `);\n }\n if (ast.codegenNode) {\n genNode(ast.codegenNode, context);\n } else {\n push(`null`);\n }\n if (useWithBlock) {\n deindent();\n push(`}`);\n }\n deindent();\n push(`}`);\n return {\n ast,\n code: context.code,\n preamble: isSetupInlined ? preambleContext.code : ``,\n map: context.map ? context.map.toJSON() : void 0\n };\n}\nfunction genFunctionPreamble(ast, context) {\n const {\n ssr,\n prefixIdentifiers,\n push,\n newline,\n runtimeModuleName,\n runtimeGlobalName,\n ssrRuntimeModuleName\n } = context;\n const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;\n const helpers = Array.from(ast.helpers);\n if (helpers.length > 0) {\n if (prefixIdentifiers) {\n push(\n `const { ${helpers.map(aliasHelper).join(\", \")} } = ${VueBinding}\n`,\n -1 /* End */\n );\n } else {\n push(`const _Vue = ${VueBinding}\n`, -1 /* End */);\n if (ast.hoists.length) {\n const staticHelpers = [\n CREATE_VNODE,\n CREATE_ELEMENT_VNODE,\n CREATE_COMMENT,\n CREATE_TEXT,\n CREATE_STATIC\n ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(\", \");\n push(`const { ${staticHelpers} } = _Vue\n`, -1 /* End */);\n }\n }\n }\n if (ast.ssrHelpers && ast.ssrHelpers.length) {\n push(\n `const { ${ast.ssrHelpers.map(aliasHelper).join(\", \")} } = require(\"${ssrRuntimeModuleName}\")\n`,\n -1 /* End */\n );\n }\n genHoists(ast.hoists, context);\n newline();\n push(`return `);\n}\nfunction genModulePreamble(ast, context, genScopeId, inline) {\n const {\n push,\n newline,\n optimizeImports,\n runtimeModuleName,\n ssrRuntimeModuleName\n } = context;\n if (ast.helpers.size) {\n const helpers = Array.from(ast.helpers);\n if (optimizeImports) {\n push(\n `import { ${helpers.map((s) => helperNameMap[s]).join(\", \")} } from ${JSON.stringify(runtimeModuleName)}\n`,\n -1 /* End */\n );\n push(\n `\n// Binding optimization for webpack code-split\nconst ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(\", \")}\n`,\n -1 /* End */\n );\n } else {\n push(\n `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(\", \")} } from ${JSON.stringify(runtimeModuleName)}\n`,\n -1 /* End */\n );\n }\n }\n if (ast.ssrHelpers && ast.ssrHelpers.length) {\n push(\n `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(\", \")} } from \"${ssrRuntimeModuleName}\"\n`,\n -1 /* End */\n );\n }\n if (ast.imports.length) {\n genImports(ast.imports, context);\n newline();\n }\n genHoists(ast.hoists, context);\n newline();\n if (!inline) {\n push(`export `);\n }\n}\nfunction genAssets(assets, type, { helper, push, newline, isTS }) {\n const resolver = helper(\n type === \"filter\" ? RESOLVE_FILTER : type === \"component\" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE\n );\n for (let i = 0; i < assets.length; i++) {\n let id = assets[i];\n const maybeSelfReference = id.endsWith(\"__self\");\n if (maybeSelfReference) {\n id = id.slice(0, -6);\n }\n push(\n `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`\n );\n if (i < assets.length - 1) {\n newline();\n }\n }\n}\nfunction genHoists(hoists, context) {\n if (!hoists.length) {\n return;\n }\n context.pure = true;\n const { push, newline } = context;\n newline();\n for (let i = 0; i < hoists.length; i++) {\n const exp = hoists[i];\n if (exp) {\n push(`const _hoisted_${i + 1} = `);\n genNode(exp, context);\n newline();\n }\n }\n context.pure = false;\n}\nfunction genImports(importsOptions, context) {\n if (!importsOptions.length) {\n return;\n }\n importsOptions.forEach((imports) => {\n context.push(`import `);\n genNode(imports.exp, context);\n context.push(` from '${imports.path}'`);\n context.newline();\n });\n}\nfunction isText(n) {\n return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;\n}\nfunction genNodeListAsArray(nodes, context) {\n const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n));\n context.push(`[`);\n multilines && context.indent();\n genNodeList(nodes, context, multilines);\n multilines && context.deindent();\n context.push(`]`);\n}\nfunction genNodeList(nodes, context, multilines = false, comma = true) {\n const { push, newline } = context;\n for (let i = 0; i < nodes.length; i++) {\n const node = nodes[i];\n if (shared.isString(node)) {\n push(node, -3 /* Unknown */);\n } else if (shared.isArray(node)) {\n genNodeListAsArray(node, context);\n } else {\n genNode(node, context);\n }\n if (i < nodes.length - 1) {\n if (multilines) {\n comma && push(\",\");\n newline();\n } else {\n comma && push(\", \");\n }\n }\n }\n}\nfunction genNode(node, context) {\n if (shared.isString(node)) {\n context.push(node, -3 /* Unknown */);\n return;\n }\n if (shared.isSymbol(node)) {\n context.push(context.helper(node));\n return;\n }\n switch (node.type) {\n case 1:\n case 9:\n case 11:\n assert(\n node.codegenNode != null,\n `Codegen node is missing for element/if/for node. Apply appropriate transforms first.`\n );\n genNode(node.codegenNode, context);\n break;\n case 2:\n genText(node, context);\n break;\n case 4:\n genExpression(node, context);\n break;\n case 5:\n genInterpolation(node, context);\n break;\n case 12:\n genNode(node.codegenNode, context);\n break;\n case 8:\n genCompoundExpression(node, context);\n break;\n case 3:\n genComment(node, context);\n break;\n case 13:\n genVNodeCall(node, context);\n break;\n case 14:\n genCallExpression(node, context);\n break;\n case 15:\n genObjectExpression(node, context);\n break;\n case 17:\n genArrayExpression(node, context);\n break;\n case 18:\n genFunctionExpression(node, context);\n break;\n case 19:\n genConditionalExpression(node, context);\n break;\n case 20:\n genCacheExpression(node, context);\n break;\n case 21:\n genNodeList(node.body, context, true, false);\n break;\n // SSR only types\n case 22:\n genTemplateLiteral(node, context);\n break;\n case 23:\n genIfStatement(node, context);\n break;\n case 24:\n genAssignmentExpression(node, context);\n break;\n case 25:\n genSequenceExpression(node, context);\n break;\n case 26:\n genReturnStatement(node, context);\n break;\n /* v8 ignore start */\n case 10:\n break;\n default:\n {\n assert(false, `unhandled codegen node type: ${node.type}`);\n const exhaustiveCheck = node;\n return exhaustiveCheck;\n }\n }\n}\nfunction genText(node, context) {\n context.push(JSON.stringify(node.content), -3 /* Unknown */, node);\n}\nfunction genExpression(node, context) {\n const { content, isStatic } = node;\n context.push(\n isStatic ? JSON.stringify(content) : content,\n -3 /* Unknown */,\n node\n );\n}\nfunction genInterpolation(node, context) {\n const { push, helper, pure } = context;\n if (pure) push(PURE_ANNOTATION);\n push(`${helper(TO_DISPLAY_STRING)}(`);\n genNode(node.content, context);\n push(`)`);\n}\nfunction genCompoundExpression(node, context) {\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (shared.isString(child)) {\n context.push(child, -3 /* Unknown */);\n } else {\n genNode(child, context);\n }\n }\n}\nfunction genExpressionAsPropertyKey(node, context) {\n const { push } = context;\n if (node.type === 8) {\n push(`[`);\n genCompoundExpression(node, context);\n push(`]`);\n } else if (node.isStatic) {\n const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);\n push(text, -2 /* None */, node);\n } else {\n push(`[${node.content}]`, -3 /* Unknown */, node);\n }\n}\nfunction genComment(node, context) {\n const { push, helper, pure } = context;\n if (pure) {\n push(PURE_ANNOTATION);\n }\n push(\n `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,\n -3 /* Unknown */,\n node\n );\n}\nfunction genVNodeCall(node, context) {\n const { push, helper, pure } = context;\n const {\n tag,\n props,\n children,\n patchFlag,\n dynamicProps,\n directives,\n isBlock,\n disableTracking,\n isComponent\n } = node;\n let patchFlagString;\n if (patchFlag) {\n {\n if (patchFlag < 0) {\n patchFlagString = patchFlag + ` /* ${shared.PatchFlagNames[patchFlag]} */`;\n } else {\n const flagNames = Object.keys(shared.PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => shared.PatchFlagNames[n]).join(`, `);\n patchFlagString = patchFlag + ` /* ${flagNames} */`;\n }\n }\n }\n if (directives) {\n push(helper(WITH_DIRECTIVES) + `(`);\n }\n if (isBlock) {\n push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);\n }\n if (pure) {\n push(PURE_ANNOTATION);\n }\n const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);\n push(helper(callHelper) + `(`, -2 /* None */, node);\n genNodeList(\n genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),\n context\n );\n push(`)`);\n if (isBlock) {\n push(`)`);\n }\n if (directives) {\n push(`, `);\n genNode(directives, context);\n push(`)`);\n }\n}\nfunction genNullableArgs(args) {\n let i = args.length;\n while (i--) {\n if (args[i] != null) break;\n }\n return args.slice(0, i + 1).map((arg) => arg || `null`);\n}\nfunction genCallExpression(node, context) {\n const { push, helper, pure } = context;\n const callee = shared.isString(node.callee) ? node.callee : helper(node.callee);\n if (pure) {\n push(PURE_ANNOTATION);\n }\n push(callee + `(`, -2 /* None */, node);\n genNodeList(node.arguments, context);\n push(`)`);\n}\nfunction genObjectExpression(node, context) {\n const { push, indent, deindent, newline } = context;\n const { properties } = node;\n if (!properties.length) {\n push(`{}`, -2 /* None */, node);\n return;\n }\n const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);\n push(multilines ? `{` : `{ `);\n multilines && indent();\n for (let i = 0; i < properties.length; i++) {\n const { key, value } = properties[i];\n genExpressionAsPropertyKey(key, context);\n push(`: `);\n genNode(value, context);\n if (i < properties.length - 1) {\n push(`,`);\n newline();\n }\n }\n multilines && deindent();\n push(multilines ? `}` : ` }`);\n}\nfunction genArrayExpression(node, context) {\n genNodeListAsArray(node.elements, context);\n}\nfunction genFunctionExpression(node, context) {\n const { push, indent, deindent } = context;\n const { params, returns, body, newline, isSlot } = node;\n if (isSlot) {\n push(`_${helperNameMap[WITH_CTX]}(`);\n }\n push(`(`, -2 /* None */, node);\n if (shared.isArray(params)) {\n genNodeList(params, context);\n } else if (params) {\n genNode(params, context);\n }\n push(`) => `);\n if (newline || body) {\n push(`{`);\n indent();\n }\n if (returns) {\n if (newline) {\n push(`return `);\n }\n if (shared.isArray(returns)) {\n genNodeListAsArray(returns, context);\n } else {\n genNode(returns, context);\n }\n } else if (body) {\n genNode(body, context);\n }\n if (newline || body) {\n deindent();\n push(`}`);\n }\n if (isSlot) {\n if (node.isNonScopedSlot) {\n push(`, undefined, true`);\n }\n push(`)`);\n }\n}\nfunction genConditionalExpression(node, context) {\n const { test, consequent, alternate, newline: needNewline } = node;\n const { push, indent, deindent, newline } = context;\n if (test.type === 4) {\n const needsParens = !isSimpleIdentifier(test.content);\n needsParens && push(`(`);\n genExpression(test, context);\n needsParens && push(`)`);\n } else {\n push(`(`);\n genNode(test, context);\n push(`)`);\n }\n needNewline && indent();\n context.indentLevel++;\n needNewline || push(` `);\n push(`? `);\n genNode(consequent, context);\n context.indentLevel--;\n needNewline && newline();\n needNewline || push(` `);\n push(`: `);\n const isNested = alternate.type === 19;\n if (!isNested) {\n context.indentLevel++;\n }\n genNode(alternate, context);\n if (!isNested) {\n context.indentLevel--;\n }\n needNewline && deindent(\n true\n /* without newline */\n );\n}\nfunction genCacheExpression(node, context) {\n const { push, helper, indent, deindent, newline } = context;\n const { needPauseTracking, needArraySpread } = node;\n if (needArraySpread) {\n push(`[...(`);\n }\n push(`_cache[${node.index}] || (`);\n if (needPauseTracking) {\n indent();\n push(`${helper(SET_BLOCK_TRACKING)}(-1`);\n if (node.inVOnce) push(`, true`);\n push(`),`);\n newline();\n push(`(`);\n }\n push(`_cache[${node.index}] = `);\n genNode(node.value, context);\n if (needPauseTracking) {\n push(`).cacheIndex = ${node.index},`);\n newline();\n push(`${helper(SET_BLOCK_TRACKING)}(1),`);\n newline();\n push(`_cache[${node.index}]`);\n deindent();\n }\n push(`)`);\n if (needArraySpread) {\n push(`)]`);\n }\n}\nfunction genTemplateLiteral(node, context) {\n const { push, indent, deindent } = context;\n push(\"`\");\n const l = node.elements.length;\n const multilines = l > 3;\n for (let i = 0; i < l; i++) {\n const e = node.elements[i];\n if (shared.isString(e)) {\n push(e.replace(/(`|\\$|\\\\)/g, \"\\\\$1\"), -3 /* Unknown */);\n } else {\n push(\"${\");\n if (multilines) indent();\n genNode(e, context);\n if (multilines) deindent();\n push(\"}\");\n }\n }\n push(\"`\");\n}\nfunction genIfStatement(node, context) {\n const { push, indent, deindent } = context;\n const { test, consequent, alternate } = node;\n push(`if (`);\n genNode(test, context);\n push(`) {`);\n indent();\n genNode(consequent, context);\n deindent();\n push(`}`);\n if (alternate) {\n push(` else `);\n if (alternate.type === 23) {\n genIfStatement(alternate, context);\n } else {\n push(`{`);\n indent();\n genNode(alternate, context);\n deindent();\n push(`}`);\n }\n }\n}\nfunction genAssignmentExpression(node, context) {\n genNode(node.left, context);\n context.push(` = `);\n genNode(node.right, context);\n}\nfunction genSequenceExpression(node, context) {\n context.push(`(`);\n genNodeList(node.expressions, context);\n context.push(`)`);\n}\nfunction genReturnStatement({ returns }, context) {\n context.push(`return `);\n if (shared.isArray(returns)) {\n genNodeListAsArray(returns, context);\n } else {\n genNode(returns, context);\n }\n}\n\nconst isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap(\"true,false,null,this\");\nconst transformExpression = (node, context) => {\n if (node.type === 5) {\n node.content = processExpression(\n node.content,\n context\n );\n } else if (node.type === 1) {\n const memo = findDir(node, \"memo\");\n for (let i = 0; i < node.props.length; i++) {\n const dir = node.props[i];\n if (dir.type === 7 && dir.name !== \"for\") {\n const exp = dir.exp;\n const arg = dir.arg;\n if (exp && exp.type === 4 && !(dir.name === \"on\" && arg) && // key has been processed in transformFor(vMemo + vFor)\n !(memo && arg && arg.type === 4 && arg.content === \"key\")) {\n dir.exp = processExpression(\n exp,\n context,\n // slot args must be processed as function params\n dir.name === \"slot\"\n );\n }\n if (arg && arg.type === 4 && !arg.isStatic) {\n dir.arg = processExpression(arg, context);\n }\n }\n }\n }\n};\nfunction processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {\n if (!context.prefixIdentifiers || !node.content.trim()) {\n return node;\n }\n const { inline, bindingMetadata } = context;\n const rewriteIdentifier = (raw, parent, id) => {\n const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw];\n if (inline) {\n const isAssignmentLVal = parent && parent.type === \"AssignmentExpression\" && parent.left === id;\n const isUpdateArg = parent && parent.type === \"UpdateExpression\" && parent.argument === id;\n const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);\n const isNewExpression = parent && isInNewExpression(parentStack);\n const wrapWithUnref = (raw2) => {\n const wrapped = `${context.helperString(UNREF)}(${raw2})`;\n return isNewExpression ? `(${wrapped})` : wrapped;\n };\n if (isConst(type) || type === \"setup-reactive-const\" || localVars[raw]) {\n return raw;\n } else if (type === \"setup-ref\") {\n return `${raw}.value`;\n } else if (type === \"setup-maybe-ref\") {\n return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw);\n } else if (type === \"setup-let\") {\n if (isAssignmentLVal) {\n const { right: rVal, operator } = parent;\n const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);\n const rExpString = stringifyExpression(\n processExpression(\n createSimpleExpression(rExp, false),\n context,\n false,\n false,\n knownIds\n )\n );\n return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;\n } else if (isUpdateArg) {\n id.start = parent.start;\n id.end = parent.end;\n const { prefix: isPrefix, operator } = parent;\n const prefix = isPrefix ? operator : ``;\n const postfix = isPrefix ? `` : operator;\n return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;\n } else if (isDestructureAssignment) {\n return raw;\n } else {\n return wrapWithUnref(raw);\n }\n } else if (type === \"props\") {\n return shared.genPropsAccessExp(raw);\n } else if (type === \"props-aliased\") {\n return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);\n }\n } else {\n if (type && type.startsWith(\"setup\") || type === \"literal-const\") {\n return `$setup.${raw}`;\n } else if (type === \"props-aliased\") {\n return `$props['${bindingMetadata.__propsAliases[raw]}']`;\n } else if (type) {\n return `$${type}.${raw}`;\n }\n }\n return `_ctx.${raw}`;\n };\n const rawExp = node.content;\n let ast = node.ast;\n if (ast === false) {\n return node;\n }\n if (ast === null || !ast && isSimpleIdentifier(rawExp)) {\n const isScopeVarReference = context.identifiers[rawExp];\n const isAllowedGlobal = shared.isGloballyAllowed(rawExp);\n const isLiteral = isLiteralWhitelisted(rawExp);\n if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {\n if (isConst(bindingMetadata[rawExp])) {\n node.constType = 1;\n }\n node.content = rewriteIdentifier(rawExp);\n } else if (!isScopeVarReference) {\n if (isLiteral) {\n node.constType = 3;\n } else {\n node.constType = 2;\n }\n }\n return node;\n }\n if (!ast) {\n const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;\n try {\n ast = parser.parseExpression(source, {\n sourceType: \"module\",\n plugins: context.expressionPlugins\n });\n } catch (e) {\n context.onError(\n createCompilerError(\n 46,\n node.loc,\n void 0,\n e.message\n )\n );\n return node;\n }\n }\n const ids = [];\n const parentStack = [];\n const knownIds = Object.create(context.identifiers);\n walkIdentifiers(\n ast,\n (node2, parent, _, isReferenced, isLocal) => {\n if (isStaticPropertyKey(node2, parent)) {\n return;\n }\n if (node2.name.startsWith(\"_filter_\")) {\n return;\n }\n const needPrefix = isReferenced && canPrefix(node2);\n if (needPrefix && !isLocal) {\n if (isStaticProperty(parent) && parent.shorthand) {\n node2.prefix = `${node2.name}: `;\n }\n node2.name = rewriteIdentifier(node2.name, parent, node2);\n ids.push(node2);\n } else {\n if (!(needPrefix && isLocal) && (!parent || parent.type !== \"CallExpression\" && parent.type !== \"NewExpression\" && parent.type !== \"MemberExpression\")) {\n node2.isConstant = true;\n }\n ids.push(node2);\n }\n },\n true,\n // invoke on ALL identifiers\n parentStack,\n knownIds\n );\n const children = [];\n ids.sort((a, b) => a.start - b.start);\n ids.forEach((id, i) => {\n const start = id.start - 1;\n const end = id.end - 1;\n const last = ids[i - 1];\n const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);\n if (leadingText.length || id.prefix) {\n children.push(leadingText + (id.prefix || ``));\n }\n const source = rawExp.slice(start, end);\n children.push(\n createSimpleExpression(\n id.name,\n false,\n {\n start: advancePositionWithClone(node.loc.start, source, start),\n end: advancePositionWithClone(node.loc.start, source, end),\n source\n },\n id.isConstant ? 3 : 0\n )\n );\n if (i === ids.length - 1 && end < rawExp.length) {\n children.push(rawExp.slice(end));\n }\n });\n let ret;\n if (children.length) {\n ret = createCompoundExpression(children, node.loc);\n ret.ast = ast;\n } else {\n ret = node;\n ret.constType = 3;\n }\n ret.identifiers = Object.keys(knownIds);\n return ret;\n}\nfunction canPrefix(id) {\n if (shared.isGloballyAllowed(id.name)) {\n return false;\n }\n if (id.name === \"require\") {\n return false;\n }\n return true;\n}\nfunction stringifyExpression(exp) {\n if (shared.isString(exp)) {\n return exp;\n } else if (exp.type === 4) {\n return exp.content;\n } else {\n return exp.children.map(stringifyExpression).join(\"\");\n }\n}\nfunction isConst(type) {\n return type === \"setup-const\" || type === \"literal-const\";\n}\n\nconst transformIf = createStructuralDirectiveTransform(\n /^(?:if|else|else-if)$/,\n (node, dir, context) => {\n return processIf(node, dir, context, (ifNode, branch, isRoot) => {\n const siblings = context.parent.children;\n let i = siblings.indexOf(ifNode);\n let key = 0;\n while (i-- >= 0) {\n const sibling = siblings[i];\n if (sibling && sibling.type === 9) {\n key += sibling.branches.length;\n }\n }\n return () => {\n if (isRoot) {\n ifNode.codegenNode = createCodegenNodeForBranch(\n branch,\n key,\n context\n );\n } else {\n const parentCondition = getParentCondition(ifNode.codegenNode);\n parentCondition.alternate = createCodegenNodeForBranch(\n branch,\n key + ifNode.branches.length - 1,\n context\n );\n }\n };\n });\n }\n);\nfunction processIf(node, dir, context, processCodegen) {\n if (dir.name !== \"else\" && (!dir.exp || !dir.exp.content.trim())) {\n const loc = dir.exp ? dir.exp.loc : node.loc;\n context.onError(\n createCompilerError(28, dir.loc)\n );\n dir.exp = createSimpleExpression(`true`, false, loc);\n }\n if (context.prefixIdentifiers && dir.exp) {\n dir.exp = processExpression(dir.exp, context);\n }\n if (dir.name === \"if\") {\n const branch = createIfBranch(node, dir);\n const ifNode = {\n type: 9,\n loc: cloneLoc(node.loc),\n branches: [branch]\n };\n context.replaceNode(ifNode);\n if (processCodegen) {\n return processCodegen(ifNode, branch, true);\n }\n } else {\n const siblings = context.parent.children;\n const comments = [];\n let i = siblings.indexOf(node);\n while (i-- >= -1) {\n const sibling = siblings[i];\n if (sibling && isCommentOrWhitespace(sibling)) {\n context.removeNode(sibling);\n if (sibling.type === 3) {\n comments.unshift(sibling);\n }\n continue;\n }\n if (sibling && sibling.type === 9) {\n if ((dir.name === \"else-if\" || dir.name === \"else\") && sibling.branches[sibling.branches.length - 1].condition === void 0) {\n context.onError(\n createCompilerError(30, node.loc)\n );\n }\n context.removeNode();\n const branch = createIfBranch(node, dir);\n if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition>\n !(context.parent && context.parent.type === 1 && (context.parent.tag === \"transition\" || context.parent.tag === \"Transition\"))) {\n branch.children = [...comments, ...branch.children];\n }\n {\n const key = branch.userKey;\n if (key) {\n sibling.branches.forEach(({ userKey }) => {\n if (isSameKey(userKey, key)) {\n context.onError(\n createCompilerError(\n 29,\n branch.userKey.loc\n )\n );\n }\n });\n }\n }\n sibling.branches.push(branch);\n const onExit = processCodegen && processCodegen(sibling, branch, false);\n traverseNode(branch, context);\n if (onExit) onExit();\n context.currentNode = null;\n } else {\n context.onError(\n createCompilerError(30, node.loc)\n );\n }\n break;\n }\n }\n}\nfunction createIfBranch(node, dir) {\n const isTemplateIf = node.tagType === 3;\n return {\n type: 10,\n loc: node.loc,\n condition: dir.name === \"else\" ? void 0 : dir.exp,\n children: isTemplateIf && !findDir(node, \"for\") ? node.children : [node],\n userKey: findProp(node, `key`),\n isTemplateIf\n };\n}\nfunction createCodegenNodeForBranch(branch, keyIndex, context) {\n if (branch.condition) {\n return createConditionalExpression(\n branch.condition,\n createChildrenCodegenNode(branch, keyIndex, context),\n // make sure to pass in asBlock: true so that the comment node call\n // closes the current block.\n createCallExpression(context.helper(CREATE_COMMENT), [\n '\"v-if\"' ,\n \"true\"\n ])\n );\n } else {\n return createChildrenCodegenNode(branch, keyIndex, context);\n }\n}\nfunction createChildrenCodegenNode(branch, keyIndex, context) {\n const { helper } = context;\n const keyProperty = createObjectProperty(\n `key`,\n createSimpleExpression(\n `${keyIndex}`,\n false,\n locStub,\n 2\n )\n );\n const { children } = branch;\n const firstChild = children[0];\n const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;\n if (needFragmentWrapper) {\n if (children.length === 1 && firstChild.type === 11) {\n const vnodeCall = firstChild.codegenNode;\n injectProp(vnodeCall, keyProperty, context);\n return vnodeCall;\n } else {\n let patchFlag = 64;\n if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {\n patchFlag |= 2048;\n }\n return createVNodeCall(\n context,\n helper(FRAGMENT),\n createObjectExpression([keyProperty]),\n children,\n patchFlag,\n void 0,\n void 0,\n true,\n false,\n false,\n branch.loc\n );\n }\n } else {\n const ret = firstChild.codegenNode;\n const vnodeCall = getMemoedVNodeCall(ret);\n if (vnodeCall.type === 13) {\n convertToBlock(vnodeCall, context);\n }\n injectProp(vnodeCall, keyProperty, context);\n return ret;\n }\n}\nfunction isSameKey(a, b) {\n if (!a || a.type !== b.type) {\n return false;\n }\n if (a.type === 6) {\n if (a.value.content !== b.value.content) {\n return false;\n }\n } else {\n const exp = a.exp;\n const branchExp = b.exp;\n if (exp.type !== branchExp.type) {\n return false;\n }\n if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {\n return false;\n }\n }\n return true;\n}\nfunction getParentCondition(node) {\n while (true) {\n if (node.type === 19) {\n if (node.alternate.type === 19) {\n node = node.alternate;\n } else {\n return node;\n }\n } else if (node.type === 20) {\n node = node.value;\n }\n }\n}\n\nconst transformFor = createStructuralDirectiveTransform(\n \"for\",\n (node, dir, context) => {\n const { helper, removeHelper } = context;\n return processFor(node, dir, context, (forNode) => {\n const renderExp = createCallExpression(helper(RENDER_LIST), [\n forNode.source\n ]);\n const isTemplate = isTemplateNode(node);\n const memo = findDir(node, \"memo\");\n const keyProp = findProp(node, `key`, false, true);\n const isDirKey = keyProp && keyProp.type === 7;\n let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);\n if (memo && keyExp && isDirKey) {\n {\n keyProp.exp = keyExp = processExpression(\n keyExp,\n context\n );\n }\n }\n const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;\n if (isTemplate) {\n if (memo) {\n memo.exp = processExpression(\n memo.exp,\n context\n );\n }\n if (keyProperty && keyProp.type !== 6) {\n keyProperty.value = processExpression(\n keyProperty.value,\n context\n );\n }\n }\n const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;\n const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;\n forNode.codegenNode = createVNodeCall(\n context,\n helper(FRAGMENT),\n void 0,\n renderExp,\n fragmentFlag,\n void 0,\n void 0,\n true,\n !isStableFragment,\n false,\n node.loc\n );\n return () => {\n let childBlock;\n const { children } = forNode;\n if (isTemplate) {\n node.children.some((c) => {\n if (c.type === 1) {\n const key = findProp(c, \"key\");\n if (key) {\n context.onError(\n createCompilerError(\n 33,\n key.loc\n )\n );\n return true;\n }\n }\n });\n }\n const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;\n const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;\n if (slotOutlet) {\n childBlock = slotOutlet.codegenNode;\n if (isTemplate && keyProperty) {\n injectProp(childBlock, keyProperty, context);\n }\n } else if (needFragmentWrapper) {\n childBlock = createVNodeCall(\n context,\n helper(FRAGMENT),\n keyProperty ? createObjectExpression([keyProperty]) : void 0,\n node.children,\n 64,\n void 0,\n void 0,\n true,\n void 0,\n false\n );\n } else {\n childBlock = children[0].codegenNode;\n if (isTemplate && keyProperty) {\n injectProp(childBlock, keyProperty, context);\n }\n if (childBlock.isBlock !== !isStableFragment) {\n if (childBlock.isBlock) {\n removeHelper(OPEN_BLOCK);\n removeHelper(\n getVNodeBlockHelper(context.inSSR, childBlock.isComponent)\n );\n } else {\n removeHelper(\n getVNodeHelper(context.inSSR, childBlock.isComponent)\n );\n }\n }\n childBlock.isBlock = !isStableFragment;\n if (childBlock.isBlock) {\n helper(OPEN_BLOCK);\n helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));\n } else {\n helper(getVNodeHelper(context.inSSR, childBlock.isComponent));\n }\n }\n if (memo) {\n const loop = createFunctionExpression(\n createForLoopParams(forNode.parseResult, [\n createSimpleExpression(`_cached`)\n ])\n );\n loop.body = createBlockStatement([\n createCompoundExpression([`const _memo = (`, memo.exp, `)`]),\n createCompoundExpression([\n `if (_cached`,\n ...keyExp ? [` && _cached.key === `, keyExp] : [],\n ` && ${context.helperString(\n IS_MEMO_SAME\n )}(_cached, _memo)) return _cached`\n ]),\n createCompoundExpression([`const _item = `, childBlock]),\n createSimpleExpression(`_item.memo = _memo`),\n createSimpleExpression(`return _item`)\n ]);\n renderExp.arguments.push(\n loop,\n createSimpleExpression(`_cache`),\n createSimpleExpression(String(context.cached.length))\n );\n context.cached.push(null);\n } else {\n renderExp.arguments.push(\n createFunctionExpression(\n createForLoopParams(forNode.parseResult),\n childBlock,\n true\n )\n );\n }\n };\n });\n }\n);\nfunction processFor(node, dir, context, processCodegen) {\n if (!dir.exp) {\n context.onError(\n createCompilerError(31, dir.loc)\n );\n return;\n }\n const parseResult = dir.forParseResult;\n if (!parseResult) {\n context.onError(\n createCompilerError(32, dir.loc)\n );\n return;\n }\n finalizeForParseResult(parseResult, context);\n const { addIdentifiers, removeIdentifiers, scopes } = context;\n const { source, value, key, index } = parseResult;\n const forNode = {\n type: 11,\n loc: dir.loc,\n source,\n valueAlias: value,\n keyAlias: key,\n objectIndexAlias: index,\n parseResult,\n children: isTemplateNode(node) ? node.children : [node]\n };\n context.replaceNode(forNode);\n scopes.vFor++;\n if (context.prefixIdentifiers) {\n value && addIdentifiers(value);\n key && addIdentifiers(key);\n index && addIdentifiers(index);\n }\n const onExit = processCodegen && processCodegen(forNode);\n return () => {\n scopes.vFor--;\n if (context.prefixIdentifiers) {\n value && removeIdentifiers(value);\n key && removeIdentifiers(key);\n index && removeIdentifiers(index);\n }\n if (onExit) onExit();\n };\n}\nfunction finalizeForParseResult(result, context) {\n if (result.finalized) return;\n if (context.prefixIdentifiers) {\n result.source = processExpression(\n result.source,\n context\n );\n if (result.key) {\n result.key = processExpression(\n result.key,\n context,\n true\n );\n }\n if (result.index) {\n result.index = processExpression(\n result.index,\n context,\n true\n );\n }\n if (result.value) {\n result.value = processExpression(\n result.value,\n context,\n true\n );\n }\n }\n result.finalized = true;\n}\nfunction createForLoopParams({ value, key, index }, memoArgs = []) {\n return createParamsList([value, key, index, ...memoArgs]);\n}\nfunction createParamsList(args) {\n let i = args.length;\n while (i--) {\n if (args[i]) break;\n }\n return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));\n}\n\nconst defaultFallback = createSimpleExpression(`undefined`, false);\nconst trackSlotScopes = (node, context) => {\n if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {\n const vSlot = findDir(node, \"slot\");\n if (vSlot) {\n const slotProps = vSlot.exp;\n if (context.prefixIdentifiers) {\n slotProps && context.addIdentifiers(slotProps);\n }\n context.scopes.vSlot++;\n return () => {\n if (context.prefixIdentifiers) {\n slotProps && context.removeIdentifiers(slotProps);\n }\n context.scopes.vSlot--;\n };\n }\n }\n};\nconst trackVForSlotScopes = (node, context) => {\n let vFor;\n if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, \"for\"))) {\n const result = vFor.forParseResult;\n if (result) {\n finalizeForParseResult(result, context);\n const { value, key, index } = result;\n const { addIdentifiers, removeIdentifiers } = context;\n value && addIdentifiers(value);\n key && addIdentifiers(key);\n index && addIdentifiers(index);\n return () => {\n value && removeIdentifiers(value);\n key && removeIdentifiers(key);\n index && removeIdentifiers(index);\n };\n }\n }\n};\nconst buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(\n props,\n children,\n false,\n true,\n children.length ? children[0].loc : loc\n);\nfunction buildSlots(node, context, buildSlotFn = buildClientSlotFn) {\n context.helper(WITH_CTX);\n const { children, loc } = node;\n const slotsProperties = [];\n const dynamicSlots = [];\n let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;\n if (!context.ssr && context.prefixIdentifiers) {\n hasDynamicSlots = node.props.some(\n (prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers))\n ) || children.some((child) => hasScopeRef(child, context.identifiers));\n }\n const onComponentSlot = findDir(node, \"slot\", true);\n if (onComponentSlot) {\n const { arg, exp } = onComponentSlot;\n if (arg && !isStaticExp(arg)) {\n hasDynamicSlots = true;\n }\n slotsProperties.push(\n createObjectProperty(\n arg || createSimpleExpression(\"default\", true),\n buildSlotFn(exp, void 0, children, loc)\n )\n );\n }\n let hasTemplateSlots = false;\n let hasNamedDefaultSlot = false;\n const implicitDefaultChildren = [];\n const seenSlotNames = /* @__PURE__ */ new Set();\n let conditionalBranchIndex = 0;\n for (let i = 0; i < children.length; i++) {\n const slotElement = children[i];\n let slotDir;\n if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, \"slot\", true))) {\n if (slotElement.type !== 3) {\n implicitDefaultChildren.push(slotElement);\n }\n continue;\n }\n if (onComponentSlot) {\n context.onError(\n createCompilerError(37, slotDir.loc)\n );\n break;\n }\n hasTemplateSlots = true;\n const { children: slotChildren, loc: slotLoc } = slotElement;\n const {\n arg: slotName = createSimpleExpression(`default`, true),\n exp: slotProps,\n loc: dirLoc\n } = slotDir;\n let staticSlotName;\n if (isStaticExp(slotName)) {\n staticSlotName = slotName ? slotName.content : `default`;\n } else {\n hasDynamicSlots = true;\n }\n const vFor = findDir(slotElement, \"for\");\n const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);\n let vIf;\n let vElse;\n if (vIf = findDir(slotElement, \"if\")) {\n hasDynamicSlots = true;\n dynamicSlots.push(\n createConditionalExpression(\n vIf.exp,\n buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),\n defaultFallback\n )\n );\n } else if (vElse = findDir(\n slotElement,\n /^else(?:-if)?$/,\n true\n /* allowEmpty */\n )) {\n let j = i;\n let prev;\n while (j--) {\n prev = children[j];\n if (!isCommentOrWhitespace(prev)) {\n break;\n }\n }\n if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) {\n let conditional = dynamicSlots[dynamicSlots.length - 1];\n while (conditional.alternate.type === 19) {\n conditional = conditional.alternate;\n }\n conditional.alternate = vElse.exp ? createConditionalExpression(\n vElse.exp,\n buildDynamicSlot(\n slotName,\n slotFunction,\n conditionalBranchIndex++\n ),\n defaultFallback\n ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);\n } else {\n context.onError(\n createCompilerError(30, vElse.loc)\n );\n }\n } else if (vFor) {\n hasDynamicSlots = true;\n const parseResult = vFor.forParseResult;\n if (parseResult) {\n finalizeForParseResult(parseResult, context);\n dynamicSlots.push(\n createCallExpression(context.helper(RENDER_LIST), [\n parseResult.source,\n createFunctionExpression(\n createForLoopParams(parseResult),\n buildDynamicSlot(slotName, slotFunction),\n true\n )\n ])\n );\n } else {\n context.onError(\n createCompilerError(\n 32,\n vFor.loc\n )\n );\n }\n } else {\n if (staticSlotName) {\n if (seenSlotNames.has(staticSlotName)) {\n context.onError(\n createCompilerError(\n 38,\n dirLoc\n )\n );\n continue;\n }\n seenSlotNames.add(staticSlotName);\n if (staticSlotName === \"default\") {\n hasNamedDefaultSlot = true;\n }\n }\n slotsProperties.push(createObjectProperty(slotName, slotFunction));\n }\n }\n if (!onComponentSlot) {\n const buildDefaultSlotProperty = (props, children2) => {\n const fn = buildSlotFn(props, void 0, children2, loc);\n if (context.compatConfig) {\n fn.isNonScopedSlot = true;\n }\n return createObjectProperty(`default`, fn);\n };\n if (!hasTemplateSlots) {\n slotsProperties.push(buildDefaultSlotProperty(void 0, children));\n } else if (implicitDefaultChildren.length && // #3766\n // with whitespace: 'preserve', whitespaces between slots will end up in\n // implicitDefaultChildren. Ignore if all implicit children are whitespaces.\n !implicitDefaultChildren.every(isWhitespaceText)) {\n if (hasNamedDefaultSlot) {\n context.onError(\n createCompilerError(\n 39,\n implicitDefaultChildren[0].loc\n )\n );\n } else {\n slotsProperties.push(\n buildDefaultSlotProperty(void 0, implicitDefaultChildren)\n );\n }\n }\n }\n const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;\n let slots = createObjectExpression(\n slotsProperties.concat(\n createObjectProperty(\n `_`,\n // 2 = compiled but dynamic = can skip normalization, but must run diff\n // 1 = compiled and static = can skip normalization AND diff as optimized\n createSimpleExpression(\n slotFlag + (` /* ${shared.slotFlagsText[slotFlag]} */` ),\n false\n )\n )\n ),\n loc\n );\n if (dynamicSlots.length) {\n slots = createCallExpression(context.helper(CREATE_SLOTS), [\n slots,\n createArrayExpression(dynamicSlots)\n ]);\n }\n return {\n slots,\n hasDynamicSlots\n };\n}\nfunction buildDynamicSlot(name, fn, index) {\n const props = [\n createObjectProperty(`name`, name),\n createObjectProperty(`fn`, fn)\n ];\n if (index != null) {\n props.push(\n createObjectProperty(`key`, createSimpleExpression(String(index), true))\n );\n }\n return createObjectExpression(props);\n}\nfunction hasForwardedSlots(children) {\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n switch (child.type) {\n case 1:\n if (child.tagType === 2 || hasForwardedSlots(child.children)) {\n return true;\n }\n break;\n case 9:\n if (hasForwardedSlots(child.branches)) return true;\n break;\n case 10:\n case 11:\n if (hasForwardedSlots(child.children)) return true;\n break;\n }\n }\n return false;\n}\n\nconst directiveImportMap = /* @__PURE__ */ new WeakMap();\nconst transformElement = (node, context) => {\n return function postTransformElement() {\n node = context.currentNode;\n if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {\n return;\n }\n const { tag, props } = node;\n const isComponent = node.tagType === 1;\n let vnodeTag = isComponent ? resolveComponentType(node, context) : `\"${tag}\"`;\n const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;\n let vnodeProps;\n let vnodeChildren;\n let patchFlag = 0;\n let vnodeDynamicProps;\n let dynamicPropNames;\n let vnodeDirectives;\n let shouldUseBlock = (\n // dynamic component may resolve to plain elements\n isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block\n // updates inside get proper isSVG flag at runtime. (#639, #643)\n // This is technically web-specific, but splitting the logic out of core\n // leads to too much unnecessary complexity.\n (tag === \"svg\" || tag === \"foreignObject\" || tag === \"math\")\n );\n if (props.length > 0) {\n const propsBuildResult = buildProps(\n node,\n context,\n void 0,\n isComponent,\n isDynamicComponent\n );\n vnodeProps = propsBuildResult.props;\n patchFlag = propsBuildResult.patchFlag;\n dynamicPropNames = propsBuildResult.dynamicPropNames;\n const directives = propsBuildResult.directives;\n vnodeDirectives = directives && directives.length ? createArrayExpression(\n directives.map((dir) => buildDirectiveArgs(dir, context))\n ) : void 0;\n if (propsBuildResult.shouldUseBlock) {\n shouldUseBlock = true;\n }\n }\n if (node.children.length > 0) {\n if (vnodeTag === KEEP_ALIVE) {\n shouldUseBlock = true;\n patchFlag |= 1024;\n if (node.children.length > 1) {\n context.onError(\n createCompilerError(47, {\n start: node.children[0].loc.start,\n end: node.children[node.children.length - 1].loc.end,\n source: \"\"\n })\n );\n }\n }\n const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling\n vnodeTag !== TELEPORT && // explained above.\n vnodeTag !== KEEP_ALIVE;\n if (shouldBuildAsSlots) {\n const { slots, hasDynamicSlots } = buildSlots(node, context);\n vnodeChildren = slots;\n if (hasDynamicSlots) {\n patchFlag |= 1024;\n }\n } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {\n const child = node.children[0];\n const type = child.type;\n const hasDynamicTextChild = type === 5 || type === 8;\n if (hasDynamicTextChild && getConstantType(child, context) === 0) {\n patchFlag |= 1;\n }\n if (hasDynamicTextChild || type === 2) {\n vnodeChildren = child;\n } else {\n vnodeChildren = node.children;\n }\n } else {\n vnodeChildren = node.children;\n }\n }\n if (dynamicPropNames && dynamicPropNames.length) {\n vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);\n }\n node.codegenNode = createVNodeCall(\n context,\n vnodeTag,\n vnodeProps,\n vnodeChildren,\n patchFlag === 0 ? void 0 : patchFlag,\n vnodeDynamicProps,\n vnodeDirectives,\n !!shouldUseBlock,\n false,\n isComponent,\n node.loc\n );\n };\n};\nfunction resolveComponentType(node, context, ssr = false) {\n let { tag } = node;\n const isExplicitDynamic = isComponentTag(tag);\n const isProp = findProp(\n node,\n \"is\",\n false,\n true\n /* allow empty */\n );\n if (isProp) {\n if (isExplicitDynamic || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n )) {\n let exp;\n if (isProp.type === 6) {\n exp = isProp.value && createSimpleExpression(isProp.value.content, true);\n } else {\n exp = isProp.exp;\n if (!exp) {\n exp = createSimpleExpression(`is`, false, isProp.arg.loc);\n {\n exp = isProp.exp = processExpression(exp, context);\n }\n }\n }\n if (exp) {\n return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [\n exp\n ]);\n }\n } else if (isProp.type === 6 && isProp.value.content.startsWith(\"vue:\")) {\n tag = isProp.value.content.slice(4);\n }\n }\n const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);\n if (builtIn) {\n if (!ssr) context.helper(builtIn);\n return builtIn;\n }\n {\n const fromSetup = resolveSetupReference(tag, context);\n if (fromSetup) {\n return fromSetup;\n }\n const dotIndex = tag.indexOf(\".\");\n if (dotIndex > 0) {\n const ns = resolveSetupReference(tag.slice(0, dotIndex), context);\n if (ns) {\n return ns + tag.slice(dotIndex);\n }\n }\n }\n if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) {\n context.helper(RESOLVE_COMPONENT);\n context.components.add(tag + `__self`);\n return toValidAssetId(tag, `component`);\n }\n context.helper(RESOLVE_COMPONENT);\n context.components.add(tag);\n return toValidAssetId(tag, `component`);\n}\nfunction resolveSetupReference(name, context) {\n const bindings = context.bindingMetadata;\n if (!bindings || bindings.__isScriptSetup === false) {\n return;\n }\n const camelName = shared.camelize(name);\n const PascalName = shared.capitalize(camelName);\n const checkType = (type) => {\n if (bindings[name] === type) {\n return name;\n }\n if (bindings[camelName] === type) {\n return camelName;\n }\n if (bindings[PascalName] === type) {\n return PascalName;\n }\n };\n const fromConst = checkType(\"setup-const\") || checkType(\"setup-reactive-const\") || checkType(\"literal-const\");\n if (fromConst) {\n return context.inline ? (\n // in inline mode, const setup bindings (e.g. imports) can be used as-is\n fromConst\n ) : `$setup[${JSON.stringify(fromConst)}]`;\n }\n const fromMaybeRef = checkType(\"setup-let\") || checkType(\"setup-ref\") || checkType(\"setup-maybe-ref\");\n if (fromMaybeRef) {\n return context.inline ? (\n // setup scope bindings that may be refs need to be unrefed\n `${context.helperString(UNREF)}(${fromMaybeRef})`\n ) : `$setup[${JSON.stringify(fromMaybeRef)}]`;\n }\n const fromProps = checkType(\"props\");\n if (fromProps) {\n return `${context.helperString(UNREF)}(${context.inline ? \"__props\" : \"$props\"}[${JSON.stringify(fromProps)}])`;\n }\n}\nfunction buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {\n const { tag, loc: elementLoc, children } = node;\n let properties = [];\n const mergeArgs = [];\n const runtimeDirectives = [];\n const hasChildren = children.length > 0;\n let shouldUseBlock = false;\n let patchFlag = 0;\n let hasRef = false;\n let hasClassBinding = false;\n let hasStyleBinding = false;\n let hasHydrationEventBinding = false;\n let hasDynamicKeys = false;\n let hasVnodeHook = false;\n const dynamicPropNames = [];\n const pushMergeArg = (arg) => {\n if (properties.length) {\n mergeArgs.push(\n createObjectExpression(dedupeProperties(properties), elementLoc)\n );\n properties = [];\n }\n if (arg) mergeArgs.push(arg);\n };\n const pushRefVForMarker = () => {\n if (context.scopes.vFor > 0) {\n properties.push(\n createObjectProperty(\n createSimpleExpression(\"ref_for\", true),\n createSimpleExpression(\"true\")\n )\n );\n }\n };\n const analyzePatchFlag = ({ key, value }) => {\n if (isStaticExp(key)) {\n const name = key.content;\n const isEventHandler = shared.isOn(name);\n if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click\n // dedicated fast path.\n name.toLowerCase() !== \"onclick\" && // omit v-model handlers\n name !== \"onUpdate:modelValue\" && // omit onVnodeXXX hooks\n !shared.isReservedProp(name)) {\n hasHydrationEventBinding = true;\n }\n if (isEventHandler && shared.isReservedProp(name)) {\n hasVnodeHook = true;\n }\n if (isEventHandler && value.type === 14) {\n value = value.arguments[0];\n }\n if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {\n return;\n }\n if (name === \"ref\") {\n hasRef = true;\n } else if (name === \"class\") {\n hasClassBinding = true;\n } else if (name === \"style\") {\n hasStyleBinding = true;\n } else if (name !== \"key\" && !dynamicPropNames.includes(name)) {\n dynamicPropNames.push(name);\n }\n if (isComponent && (name === \"class\" || name === \"style\") && !dynamicPropNames.includes(name)) {\n dynamicPropNames.push(name);\n }\n } else {\n hasDynamicKeys = true;\n }\n };\n for (let i = 0; i < props.length; i++) {\n const prop = props[i];\n if (prop.type === 6) {\n const { loc, name, nameLoc, value } = prop;\n let isStatic = true;\n if (name === \"ref\") {\n hasRef = true;\n pushRefVForMarker();\n if (value && context.inline) {\n const binding = context.bindingMetadata[value.content];\n if (binding === \"setup-let\" || binding === \"setup-ref\" || binding === \"setup-maybe-ref\") {\n isStatic = false;\n properties.push(\n createObjectProperty(\n createSimpleExpression(\"ref_key\", true),\n createSimpleExpression(value.content, true, value.loc)\n )\n );\n }\n }\n }\n if (name === \"is\" && (isComponentTag(tag) || value && value.content.startsWith(\"vue:\") || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n ))) {\n continue;\n }\n properties.push(\n createObjectProperty(\n createSimpleExpression(name, true, nameLoc),\n createSimpleExpression(\n value ? value.content : \"\",\n isStatic,\n value ? value.loc : loc\n )\n )\n );\n } else {\n const { name, arg, exp, loc, modifiers } = prop;\n const isVBind = name === \"bind\";\n const isVOn = name === \"on\";\n if (name === \"slot\") {\n if (!isComponent) {\n context.onError(\n createCompilerError(40, loc)\n );\n }\n continue;\n }\n if (name === \"once\" || name === \"memo\") {\n continue;\n }\n if (name === \"is\" || isVBind && isStaticArgOf(arg, \"is\") && (isComponentTag(tag) || isCompatEnabled(\n \"COMPILER_IS_ON_ELEMENT\",\n context\n ))) {\n continue;\n }\n if (isVOn && ssr) {\n continue;\n }\n if (\n // #938: elements with dynamic keys should be forced into blocks\n isVBind && isStaticArgOf(arg, \"key\") || // inline before-update hooks need to force block so that it is invoked\n // before children\n isVOn && hasChildren && isStaticArgOf(arg, \"vue:before-update\")\n ) {\n shouldUseBlock = true;\n }\n if (isVBind && isStaticArgOf(arg, \"ref\")) {\n pushRefVForMarker();\n }\n if (!arg && (isVBind || isVOn)) {\n hasDynamicKeys = true;\n if (exp) {\n if (isVBind) {\n {\n pushMergeArg();\n {\n const hasOverridableKeys = mergeArgs.some((arg2) => {\n if (arg2.type === 15) {\n return arg2.properties.some(({ key }) => {\n if (key.type !== 4 || !key.isStatic) {\n return true;\n }\n return key.content !== \"class\" && key.content !== \"style\" && !shared.isOn(key.content);\n });\n } else {\n return true;\n }\n });\n if (hasOverridableKeys) {\n checkCompatEnabled(\n \"COMPILER_V_BIND_OBJECT_ORDER\",\n context,\n loc\n );\n }\n }\n if (isCompatEnabled(\n \"COMPILER_V_BIND_OBJECT_ORDER\",\n context\n )) {\n mergeArgs.unshift(exp);\n continue;\n }\n }\n pushRefVForMarker();\n pushMergeArg();\n mergeArgs.push(exp);\n } else {\n pushMergeArg({\n type: 14,\n loc,\n callee: context.helper(TO_HANDLERS),\n arguments: isComponent ? [exp] : [exp, `true`]\n });\n }\n } else {\n context.onError(\n createCompilerError(\n isVBind ? 34 : 35,\n loc\n )\n );\n }\n continue;\n }\n if (isVBind && modifiers.some((mod) => mod.content === \"prop\")) {\n patchFlag |= 32;\n }\n const directiveTransform = context.directiveTransforms[name];\n if (directiveTransform) {\n const { props: props2, needRuntime } = directiveTransform(prop, node, context);\n !ssr && props2.forEach(analyzePatchFlag);\n if (isVOn && arg && !isStaticExp(arg)) {\n pushMergeArg(createObjectExpression(props2, elementLoc));\n } else {\n properties.push(...props2);\n }\n if (needRuntime) {\n runtimeDirectives.push(prop);\n if (shared.isSymbol(needRuntime)) {\n directiveImportMap.set(prop, needRuntime);\n }\n }\n } else if (!shared.isBuiltInDirective(name)) {\n runtimeDirectives.push(prop);\n if (hasChildren) {\n shouldUseBlock = true;\n }\n }\n }\n }\n let propsExpression = void 0;\n if (mergeArgs.length) {\n pushMergeArg();\n if (mergeArgs.length > 1) {\n propsExpression = createCallExpression(\n context.helper(MERGE_PROPS),\n mergeArgs,\n elementLoc\n );\n } else {\n propsExpression = mergeArgs[0];\n }\n } else if (properties.length) {\n propsExpression = createObjectExpression(\n dedupeProperties(properties),\n elementLoc\n );\n }\n if (hasDynamicKeys) {\n patchFlag |= 16;\n } else {\n if (hasClassBinding && !isComponent) {\n patchFlag |= 2;\n }\n if (hasStyleBinding && !isComponent) {\n patchFlag |= 4;\n }\n if (dynamicPropNames.length) {\n patchFlag |= 8;\n }\n if (hasHydrationEventBinding) {\n patchFlag |= 32;\n }\n }\n if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {\n patchFlag |= 512;\n }\n if (!context.inSSR && propsExpression) {\n switch (propsExpression.type) {\n case 15:\n let classKeyIndex = -1;\n let styleKeyIndex = -1;\n let hasDynamicKey = false;\n for (let i = 0; i < propsExpression.properties.length; i++) {\n const key = propsExpression.properties[i].key;\n if (isStaticExp(key)) {\n if (key.content === \"class\") {\n classKeyIndex = i;\n } else if (key.content === \"style\") {\n styleKeyIndex = i;\n }\n } else if (!key.isHandlerKey) {\n hasDynamicKey = true;\n }\n }\n const classProp = propsExpression.properties[classKeyIndex];\n const styleProp = propsExpression.properties[styleKeyIndex];\n if (!hasDynamicKey) {\n if (classProp && !isStaticExp(classProp.value)) {\n classProp.value = createCallExpression(\n context.helper(NORMALIZE_CLASS),\n [classProp.value]\n );\n }\n if (styleProp && // the static style is compiled into an object,\n // so use `hasStyleBinding` to ensure that it is a dynamic style binding\n (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,\n // v-bind:style with static literal object\n styleProp.value.type === 17)) {\n styleProp.value = createCallExpression(\n context.helper(NORMALIZE_STYLE),\n [styleProp.value]\n );\n }\n } else {\n propsExpression = createCallExpression(\n context.helper(NORMALIZE_PROPS),\n [propsExpression]\n );\n }\n break;\n case 14:\n break;\n default:\n propsExpression = createCallExpression(\n context.helper(NORMALIZE_PROPS),\n [\n createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [\n propsExpression\n ])\n ]\n );\n break;\n }\n }\n return {\n props: propsExpression,\n directives: runtimeDirectives,\n patchFlag,\n dynamicPropNames,\n shouldUseBlock\n };\n}\nfunction dedupeProperties(properties) {\n const knownProps = /* @__PURE__ */ new Map();\n const deduped = [];\n for (let i = 0; i < properties.length; i++) {\n const prop = properties[i];\n if (prop.key.type === 8 || !prop.key.isStatic) {\n deduped.push(prop);\n continue;\n }\n const name = prop.key.content;\n const existing = knownProps.get(name);\n if (existing) {\n if (name === \"style\" || name === \"class\" || shared.isOn(name)) {\n mergeAsArray(existing, prop);\n }\n } else {\n knownProps.set(name, prop);\n deduped.push(prop);\n }\n }\n return deduped;\n}\nfunction mergeAsArray(existing, incoming) {\n if (existing.value.type === 17) {\n existing.value.elements.push(incoming.value);\n } else {\n existing.value = createArrayExpression(\n [existing.value, incoming.value],\n existing.loc\n );\n }\n}\nfunction buildDirectiveArgs(dir, context) {\n const dirArgs = [];\n const runtime = directiveImportMap.get(dir);\n if (runtime) {\n dirArgs.push(context.helperString(runtime));\n } else {\n const fromSetup = resolveSetupReference(\"v-\" + dir.name, context);\n if (fromSetup) {\n dirArgs.push(fromSetup);\n } else {\n context.helper(RESOLVE_DIRECTIVE);\n context.directives.add(dir.name);\n dirArgs.push(toValidAssetId(dir.name, `directive`));\n }\n }\n const { loc } = dir;\n if (dir.exp) dirArgs.push(dir.exp);\n if (dir.arg) {\n if (!dir.exp) {\n dirArgs.push(`void 0`);\n }\n dirArgs.push(dir.arg);\n }\n if (Object.keys(dir.modifiers).length) {\n if (!dir.arg) {\n if (!dir.exp) {\n dirArgs.push(`void 0`);\n }\n dirArgs.push(`void 0`);\n }\n const trueExpression = createSimpleExpression(`true`, false, loc);\n dirArgs.push(\n createObjectExpression(\n dir.modifiers.map(\n (modifier) => createObjectProperty(modifier, trueExpression)\n ),\n loc\n )\n );\n }\n return createArrayExpression(dirArgs, dir.loc);\n}\nfunction stringifyDynamicPropNames(props) {\n let propsNamesString = `[`;\n for (let i = 0, l = props.length; i < l; i++) {\n propsNamesString += JSON.stringify(props[i]);\n if (i < l - 1) propsNamesString += \", \";\n }\n return propsNamesString + `]`;\n}\nfunction isComponentTag(tag) {\n return tag === \"component\" || tag === \"Component\";\n}\n\nconst transformSlotOutlet = (node, context) => {\n if (isSlotOutlet(node)) {\n const { children, loc } = node;\n const { slotName, slotProps } = processSlotOutlet(node, context);\n const slotArgs = [\n context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,\n slotName,\n \"{}\",\n \"undefined\",\n \"true\"\n ];\n let expectedLen = 2;\n if (slotProps) {\n slotArgs[2] = slotProps;\n expectedLen = 3;\n }\n if (children.length) {\n slotArgs[3] = createFunctionExpression([], children, false, false, loc);\n expectedLen = 4;\n }\n if (context.scopeId && !context.slotted) {\n expectedLen = 5;\n }\n slotArgs.splice(expectedLen);\n node.codegenNode = createCallExpression(\n context.helper(RENDER_SLOT),\n slotArgs,\n loc\n );\n }\n};\nfunction processSlotOutlet(node, context) {\n let slotName = `\"default\"`;\n let slotProps = void 0;\n const nonNameProps = [];\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n if (p.value) {\n if (p.name === \"name\") {\n slotName = JSON.stringify(p.value.content);\n } else {\n p.name = shared.camelize(p.name);\n nonNameProps.push(p);\n }\n }\n } else {\n if (p.name === \"bind\" && isStaticArgOf(p.arg, \"name\")) {\n if (p.exp) {\n slotName = p.exp;\n } else if (p.arg && p.arg.type === 4) {\n const name = shared.camelize(p.arg.content);\n slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);\n {\n slotName = p.exp = processExpression(p.exp, context);\n }\n }\n } else {\n if (p.name === \"bind\" && p.arg && isStaticExp(p.arg)) {\n p.arg.content = shared.camelize(p.arg.content);\n }\n nonNameProps.push(p);\n }\n }\n }\n if (nonNameProps.length > 0) {\n const { props, directives } = buildProps(\n node,\n context,\n nonNameProps,\n false,\n false\n );\n slotProps = props;\n if (directives.length) {\n context.onError(\n createCompilerError(\n 36,\n directives[0].loc\n )\n );\n }\n }\n return {\n slotName,\n slotProps\n };\n}\n\nconst transformOn = (dir, node, context, augmentor) => {\n const { loc, modifiers, arg } = dir;\n if (!dir.exp && !modifiers.length) {\n context.onError(createCompilerError(35, loc));\n }\n let eventName;\n if (arg.type === 4) {\n if (arg.isStatic) {\n let rawName = arg.content;\n if (rawName.startsWith(\"vnode\")) {\n context.onError(createCompilerError(52, arg.loc));\n }\n if (rawName.startsWith(\"vue:\")) {\n rawName = `vnode-${rawName.slice(4)}`;\n }\n const eventString = node.tagType !== 0 || rawName.startsWith(\"vnode\") || !/[A-Z]/.test(rawName) ? (\n // for non-element and vnode lifecycle event listeners, auto convert\n // it to camelCase. See issue #2249\n shared.toHandlerKey(shared.camelize(rawName))\n ) : (\n // preserve case for plain element listeners that have uppercase\n // letters, as these may be custom elements' custom events\n `on:${rawName}`\n );\n eventName = createSimpleExpression(eventString, true, arg.loc);\n } else {\n eventName = createCompoundExpression([\n `${context.helperString(TO_HANDLER_KEY)}(`,\n arg,\n `)`\n ]);\n }\n } else {\n eventName = arg;\n eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);\n eventName.children.push(`)`);\n }\n let exp = dir.exp;\n if (exp && !exp.content.trim()) {\n exp = void 0;\n }\n let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;\n if (exp) {\n const isMemberExp = isMemberExpression(exp, context);\n const isInlineStatement = !(isMemberExp || isFnExpression(exp, context));\n const hasMultipleStatements = exp.content.includes(`;`);\n if (context.prefixIdentifiers) {\n isInlineStatement && context.addIdentifiers(`$event`);\n exp = dir.exp = processExpression(\n exp,\n context,\n false,\n hasMultipleStatements\n );\n isInlineStatement && context.removeIdentifiers(`$event`);\n shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once\n !context.inVOnce && // runtime constants don't need to be cached\n // (this is analyzed by compileScript in SFC <script setup>)\n !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -\n // we need to use the original function to preserve arity,\n // e.g. <transition> relies on checking cb.length to determine\n // transition end handling. Inline function is ok since its arity\n // is preserved even when cached.\n !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)\n // it must be passed fresh to avoid stale values.\n !hasScopeRef(exp, context.identifiers);\n if (shouldCache && isMemberExp) {\n if (exp.type === 4) {\n exp.content = `${exp.content} && ${exp.content}(...args)`;\n } else {\n exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];\n }\n }\n }\n if (isInlineStatement || shouldCache && isMemberExp) {\n exp = createCompoundExpression([\n `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `\n//@ts-ignore\n` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,\n exp,\n hasMultipleStatements ? `}` : `)`\n ]);\n }\n }\n let ret = {\n props: [\n createObjectProperty(\n eventName,\n exp || createSimpleExpression(`() => {}`, false, loc)\n )\n ]\n };\n if (augmentor) {\n ret = augmentor(ret);\n }\n if (shouldCache) {\n ret.props[0].value = context.cache(ret.props[0].value);\n }\n ret.props.forEach((p) => p.key.isHandlerKey = true);\n return ret;\n};\n\nconst transformBind = (dir, _node, context) => {\n const { modifiers, loc } = dir;\n const arg = dir.arg;\n let { exp } = dir;\n if (exp && exp.type === 4 && !exp.content.trim()) {\n {\n context.onError(\n createCompilerError(34, loc)\n );\n return {\n props: [\n createObjectProperty(arg, createSimpleExpression(\"\", true, loc))\n ]\n };\n }\n }\n if (arg.type !== 4) {\n arg.children.unshift(`(`);\n arg.children.push(`) || \"\"`);\n } else if (!arg.isStatic) {\n arg.content = arg.content ? `${arg.content} || \"\"` : `\"\"`;\n }\n if (modifiers.some((mod) => mod.content === \"camel\")) {\n if (arg.type === 4) {\n if (arg.isStatic) {\n arg.content = shared.camelize(arg.content);\n } else {\n arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;\n }\n } else {\n arg.children.unshift(`${context.helperString(CAMELIZE)}(`);\n arg.children.push(`)`);\n }\n }\n if (!context.inSSR) {\n if (modifiers.some((mod) => mod.content === \"prop\")) {\n injectPrefix(arg, \".\");\n }\n if (modifiers.some((mod) => mod.content === \"attr\")) {\n injectPrefix(arg, \"^\");\n }\n }\n return {\n props: [createObjectProperty(arg, exp)]\n };\n};\nconst injectPrefix = (arg, prefix) => {\n if (arg.type === 4) {\n if (arg.isStatic) {\n arg.content = prefix + arg.content;\n } else {\n arg.content = `\\`${prefix}\\${${arg.content}}\\``;\n }\n } else {\n arg.children.unshift(`'${prefix}' + (`);\n arg.children.push(`)`);\n }\n};\n\nconst transformText = (node, context) => {\n if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {\n return () => {\n const children = node.children;\n let currentContainer = void 0;\n let hasText = false;\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (isText$1(child)) {\n hasText = true;\n for (let j = i + 1; j < children.length; j++) {\n const next = children[j];\n if (isText$1(next)) {\n if (!currentContainer) {\n currentContainer = children[i] = createCompoundExpression(\n [child],\n child.loc\n );\n }\n currentContainer.children.push(` + `, next);\n children.splice(j, 1);\n j--;\n } else {\n currentContainer = void 0;\n break;\n }\n }\n }\n }\n if (!hasText || // if this is a plain element with a single text child, leave it\n // as-is since the runtime has dedicated fast path for this by directly\n // setting textContent of the element.\n // for component root it's always normalized anyway.\n children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756\n // custom directives can potentially add DOM elements arbitrarily,\n // we need to avoid setting textContent of the element at runtime\n // to avoid accidentally overwriting the DOM elements added\n // by the user through custom directives.\n !node.props.find(\n (p) => p.type === 7 && !context.directiveTransforms[p.name]\n ) && // in compat mode, <template> tags with no special directives\n // will be rendered as a fragment so its children must be\n // converted into vnodes.\n !(node.tag === \"template\"))) {\n return;\n }\n for (let i = 0; i < children.length; i++) {\n const child = children[i];\n if (isText$1(child) || child.type === 8) {\n const callArgs = [];\n if (child.type !== 2 || child.content !== \" \") {\n callArgs.push(child);\n }\n if (!context.ssr && getConstantType(child, context) === 0) {\n callArgs.push(\n 1 + (` /* ${shared.PatchFlagNames[1]} */` )\n );\n }\n children[i] = {\n type: 12,\n content: child,\n loc: child.loc,\n codegenNode: createCallExpression(\n context.helper(CREATE_TEXT),\n callArgs\n )\n };\n }\n }\n };\n }\n};\n\nconst seen$1 = /* @__PURE__ */ new WeakSet();\nconst transformOnce = (node, context) => {\n if (node.type === 1 && findDir(node, \"once\", true)) {\n if (seen$1.has(node) || context.inVOnce || context.inSSR) {\n return;\n }\n seen$1.add(node);\n context.inVOnce = true;\n context.helper(SET_BLOCK_TRACKING);\n return () => {\n context.inVOnce = false;\n const cur = context.currentNode;\n if (cur.codegenNode) {\n cur.codegenNode = context.cache(\n cur.codegenNode,\n true,\n true\n );\n }\n };\n }\n};\n\nconst transformModel = (dir, node, context) => {\n const { exp, arg } = dir;\n if (!exp) {\n context.onError(\n createCompilerError(41, dir.loc)\n );\n return createTransformProps();\n }\n const rawExp = exp.loc.source.trim();\n const expString = exp.type === 4 ? exp.content : rawExp;\n const bindingType = context.bindingMetadata[rawExp];\n if (bindingType === \"props\" || bindingType === \"props-aliased\") {\n context.onError(createCompilerError(44, exp.loc));\n return createTransformProps();\n }\n if (bindingType === \"literal-const\" || bindingType === \"setup-const\") {\n context.onError(createCompilerError(45, exp.loc));\n return createTransformProps();\n }\n const maybeRef = context.inline && (bindingType === \"setup-let\" || bindingType === \"setup-ref\" || bindingType === \"setup-maybe-ref\");\n if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) {\n context.onError(\n createCompilerError(42, exp.loc)\n );\n return createTransformProps();\n }\n if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {\n context.onError(\n createCompilerError(43, exp.loc)\n );\n return createTransformProps();\n }\n const propName = arg ? arg : createSimpleExpression(\"modelValue\", true);\n const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['\"onUpdate:\" + ', arg]) : `onUpdate:modelValue`;\n let assignmentExp;\n const eventArg = context.isTS ? `($event: any)` : `$event`;\n if (maybeRef) {\n if (bindingType === \"setup-ref\") {\n assignmentExp = createCompoundExpression([\n `${eventArg} => ((`,\n createSimpleExpression(rawExp, false, exp.loc),\n `).value = $event)`\n ]);\n } else {\n const altAssignment = bindingType === \"setup-let\" ? `${rawExp} = $event` : `null`;\n assignmentExp = createCompoundExpression([\n `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,\n createSimpleExpression(rawExp, false, exp.loc),\n `).value = $event : ${altAssignment})`\n ]);\n }\n } else {\n assignmentExp = createCompoundExpression([\n `${eventArg} => ((`,\n exp,\n `) = $event)`\n ]);\n }\n const props = [\n // modelValue: foo\n createObjectProperty(propName, dir.exp),\n // \"onUpdate:modelValue\": $event => (foo = $event)\n createObjectProperty(eventName, assignmentExp)\n ];\n if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {\n props[1].value = context.cache(props[1].value);\n }\n if (dir.modifiers.length && node.tagType === 1) {\n const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);\n const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + \"Modifiers\"']) : `modelModifiers`;\n props.push(\n createObjectProperty(\n modifiersKey,\n createSimpleExpression(\n `{ ${modifiers} }`,\n false,\n dir.loc,\n 2\n )\n )\n );\n }\n return createTransformProps(props);\n};\nfunction createTransformProps(props = []) {\n return { props };\n}\n\nconst validDivisionCharRE = /[\\w).+\\-_$\\]]/;\nconst transformFilter = (node, context) => {\n if (!isCompatEnabled(\"COMPILER_FILTERS\", context)) {\n return;\n }\n if (node.type === 5) {\n rewriteFilter(node.content, context);\n } else if (node.type === 1) {\n node.props.forEach((prop) => {\n if (prop.type === 7 && prop.name !== \"for\" && prop.exp) {\n rewriteFilter(prop.exp, context);\n }\n });\n }\n};\nfunction rewriteFilter(node, context) {\n if (node.type === 4) {\n parseFilter(node, context);\n } else {\n for (let i = 0; i < node.children.length; i++) {\n const child = node.children[i];\n if (typeof child !== \"object\") continue;\n if (child.type === 4) {\n parseFilter(child, context);\n } else if (child.type === 8) {\n rewriteFilter(node, context);\n } else if (child.type === 5) {\n rewriteFilter(child.content, context);\n }\n }\n }\n}\nfunction parseFilter(node, context) {\n const exp = node.content;\n let inSingle = false;\n let inDouble = false;\n let inTemplateString = false;\n let inRegex = false;\n let curly = 0;\n let square = 0;\n let paren = 0;\n let lastFilterIndex = 0;\n let c, prev, i, expression, filters = [];\n for (i = 0; i < exp.length; i++) {\n prev = c;\n c = exp.charCodeAt(i);\n if (inSingle) {\n if (c === 39 && prev !== 92) inSingle = false;\n } else if (inDouble) {\n if (c === 34 && prev !== 92) inDouble = false;\n } else if (inTemplateString) {\n if (c === 96 && prev !== 92) inTemplateString = false;\n } else if (inRegex) {\n if (c === 47 && prev !== 92) inRegex = false;\n } else if (c === 124 && // pipe\n exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {\n if (expression === void 0) {\n lastFilterIndex = i + 1;\n expression = exp.slice(0, i).trim();\n } else {\n pushFilter();\n }\n } else {\n switch (c) {\n case 34:\n inDouble = true;\n break;\n // \"\n case 39:\n inSingle = true;\n break;\n // '\n case 96:\n inTemplateString = true;\n break;\n // `\n case 40:\n paren++;\n break;\n // (\n case 41:\n paren--;\n break;\n // )\n case 91:\n square++;\n break;\n // [\n case 93:\n square--;\n break;\n // ]\n case 123:\n curly++;\n break;\n // {\n case 125:\n curly--;\n break;\n }\n if (c === 47) {\n let j = i - 1;\n let p;\n for (; j >= 0; j--) {\n p = exp.charAt(j);\n if (p !== \" \") break;\n }\n if (!p || !validDivisionCharRE.test(p)) {\n inRegex = true;\n }\n }\n }\n }\n if (expression === void 0) {\n expression = exp.slice(0, i).trim();\n } else if (lastFilterIndex !== 0) {\n pushFilter();\n }\n function pushFilter() {\n filters.push(exp.slice(lastFilterIndex, i).trim());\n lastFilterIndex = i + 1;\n }\n if (filters.length) {\n warnDeprecation(\n \"COMPILER_FILTERS\",\n context,\n node.loc\n );\n for (i = 0; i < filters.length; i++) {\n expression = wrapFilter(expression, filters[i], context);\n }\n node.content = expression;\n node.ast = void 0;\n }\n}\nfunction wrapFilter(exp, filter, context) {\n context.helper(RESOLVE_FILTER);\n const i = filter.indexOf(\"(\");\n if (i < 0) {\n context.filters.add(filter);\n return `${toValidAssetId(filter, \"filter\")}(${exp})`;\n } else {\n const name = filter.slice(0, i);\n const args = filter.slice(i + 1);\n context.filters.add(name);\n return `${toValidAssetId(name, \"filter\")}(${exp}${args !== \")\" ? \",\" + args : args}`;\n }\n}\n\nconst seen = /* @__PURE__ */ new WeakSet();\nconst transformMemo = (node, context) => {\n if (node.type === 1) {\n const dir = findDir(node, \"memo\");\n if (!dir || seen.has(node) || context.inSSR) {\n return;\n }\n seen.add(node);\n return () => {\n const codegenNode = node.codegenNode || context.currentNode.codegenNode;\n if (codegenNode && codegenNode.type === 13) {\n if (node.tagType !== 1) {\n convertToBlock(codegenNode, context);\n }\n node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [\n dir.exp,\n createFunctionExpression(void 0, codegenNode),\n `_cache`,\n String(context.cached.length)\n ]);\n context.cached.push(null);\n }\n };\n }\n};\n\nconst transformVBindShorthand = (node, context) => {\n if (node.type === 1) {\n for (const prop of node.props) {\n if (prop.type === 7 && prop.name === \"bind\" && (!prop.exp || // #13930 :foo in in-DOM templates will be parsed into :foo=\"\" by browser\n false) && prop.arg) {\n const arg = prop.arg;\n if (arg.type !== 4 || !arg.isStatic) {\n context.onError(\n createCompilerError(\n 53,\n arg.loc\n )\n );\n prop.exp = createSimpleExpression(\"\", true, arg.loc);\n } else {\n const propName = shared.camelize(arg.content);\n if (validFirstIdentCharRE.test(propName[0]) || // allow hyphen first char for https://github.com/vuejs/language-tools/pull/3424\n propName[0] === \"-\") {\n prop.exp = createSimpleExpression(propName, false, arg.loc);\n }\n }\n }\n }\n }\n};\n\nfunction getBaseTransformPreset(prefixIdentifiers) {\n return [\n [\n transformVBindShorthand,\n transformOnce,\n transformIf,\n transformMemo,\n transformFor,\n ...[transformFilter] ,\n ...prefixIdentifiers ? [\n // order is important\n trackVForSlotScopes,\n transformExpression\n ] : [],\n transformSlotOutlet,\n transformElement,\n trackSlotScopes,\n transformText\n ],\n {\n on: transformOn,\n bind: transformBind,\n model: transformModel\n }\n ];\n}\nfunction baseCompile(source, options = {}) {\n const onError = options.onError || defaultOnError;\n const isModuleMode = options.mode === \"module\";\n const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;\n if (!prefixIdentifiers && options.cacheHandlers) {\n onError(createCompilerError(50));\n }\n if (options.scopeId && !isModuleMode) {\n onError(createCompilerError(51));\n }\n const resolvedOptions = shared.extend({}, options, {\n prefixIdentifiers\n });\n const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source;\n const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);\n if (options.isTS) {\n const { expressionPlugins } = options;\n if (!expressionPlugins || !expressionPlugins.includes(\"typescript\")) {\n options.expressionPlugins = [...expressionPlugins || [], \"typescript\"];\n }\n }\n transform(\n ast,\n shared.extend({}, resolvedOptions, {\n nodeTransforms: [\n ...nodeTransforms,\n ...options.nodeTransforms || []\n // user transforms\n ],\n directiveTransforms: shared.extend(\n {},\n directiveTransforms,\n options.directiveTransforms || {}\n // user transforms\n )\n })\n );\n return generate(ast, resolvedOptions);\n}\n\nconst BindingTypes = {\n \"DATA\": \"data\",\n \"PROPS\": \"props\",\n \"PROPS_ALIASED\": \"props-aliased\",\n \"SETUP_LET\": \"setup-let\",\n \"SETUP_CONST\": \"setup-const\",\n \"SETUP_REACTIVE_CONST\": \"setup-reactive-const\",\n \"SETUP_MAYBE_REF\": \"setup-maybe-ref\",\n \"SETUP_REF\": \"setup-ref\",\n \"OPTIONS\": \"options\",\n \"LITERAL_CONST\": \"literal-const\"\n};\n\nconst noopDirectiveTransform = () => ({ props: [] });\n\nexports.generateCodeFrame = shared.generateCodeFrame;\nexports.BASE_TRANSITION = BASE_TRANSITION;\nexports.BindingTypes = BindingTypes;\nexports.CAMELIZE = CAMELIZE;\nexports.CAPITALIZE = CAPITALIZE;\nexports.CREATE_BLOCK = CREATE_BLOCK;\nexports.CREATE_COMMENT = CREATE_COMMENT;\nexports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK;\nexports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE;\nexports.CREATE_SLOTS = CREATE_SLOTS;\nexports.CREATE_STATIC = CREATE_STATIC;\nexports.CREATE_TEXT = CREATE_TEXT;\nexports.CREATE_VNODE = CREATE_VNODE;\nexports.CompilerDeprecationTypes = CompilerDeprecationTypes;\nexports.ConstantTypes = ConstantTypes;\nexports.ElementTypes = ElementTypes;\nexports.ErrorCodes = ErrorCodes;\nexports.FRAGMENT = FRAGMENT;\nexports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS;\nexports.IS_MEMO_SAME = IS_MEMO_SAME;\nexports.IS_REF = IS_REF;\nexports.KEEP_ALIVE = KEEP_ALIVE;\nexports.MERGE_PROPS = MERGE_PROPS;\nexports.NORMALIZE_CLASS = NORMALIZE_CLASS;\nexports.NORMALIZE_PROPS = NORMALIZE_PROPS;\nexports.NORMALIZE_STYLE = NORMALIZE_STYLE;\nexports.Namespaces = Namespaces;\nexports.NodeTypes = NodeTypes;\nexports.OPEN_BLOCK = OPEN_BLOCK;\nexports.POP_SCOPE_ID = POP_SCOPE_ID;\nexports.PUSH_SCOPE_ID = PUSH_SCOPE_ID;\nexports.RENDER_LIST = RENDER_LIST;\nexports.RENDER_SLOT = RENDER_SLOT;\nexports.RESOLVE_COMPONENT = RESOLVE_COMPONENT;\nexports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE;\nexports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT;\nexports.RESOLVE_FILTER = RESOLVE_FILTER;\nexports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING;\nexports.SUSPENSE = SUSPENSE;\nexports.TELEPORT = TELEPORT;\nexports.TO_DISPLAY_STRING = TO_DISPLAY_STRING;\nexports.TO_HANDLERS = TO_HANDLERS;\nexports.TO_HANDLER_KEY = TO_HANDLER_KEY;\nexports.TS_NODE_TYPES = TS_NODE_TYPES;\nexports.UNREF = UNREF;\nexports.WITH_CTX = WITH_CTX;\nexports.WITH_DIRECTIVES = WITH_DIRECTIVES;\nexports.WITH_MEMO = WITH_MEMO;\nexports.advancePositionWithClone = advancePositionWithClone;\nexports.advancePositionWithMutation = advancePositionWithMutation;\nexports.assert = assert;\nexports.baseCompile = baseCompile;\nexports.baseParse = baseParse;\nexports.buildDirectiveArgs = buildDirectiveArgs;\nexports.buildProps = buildProps;\nexports.buildSlots = buildSlots;\nexports.checkCompatEnabled = checkCompatEnabled;\nexports.convertToBlock = convertToBlock;\nexports.createArrayExpression = createArrayExpression;\nexports.createAssignmentExpression = createAssignmentExpression;\nexports.createBlockStatement = createBlockStatement;\nexports.createCacheExpression = createCacheExpression;\nexports.createCallExpression = createCallExpression;\nexports.createCompilerError = createCompilerError;\nexports.createCompoundExpression = createCompoundExpression;\nexports.createConditionalExpression = createConditionalExpression;\nexports.createForLoopParams = createForLoopParams;\nexports.createFunctionExpression = createFunctionExpression;\nexports.createIfStatement = createIfStatement;\nexports.createInterpolation = createInterpolation;\nexports.createObjectExpression = createObjectExpression;\nexports.createObjectProperty = createObjectProperty;\nexports.createReturnStatement = createReturnStatement;\nexports.createRoot = createRoot;\nexports.createSequenceExpression = createSequenceExpression;\nexports.createSimpleExpression = createSimpleExpression;\nexports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;\nexports.createTemplateLiteral = createTemplateLiteral;\nexports.createTransformContext = createTransformContext;\nexports.createVNodeCall = createVNodeCall;\nexports.errorMessages = errorMessages;\nexports.extractIdentifiers = extractIdentifiers;\nexports.findDir = findDir;\nexports.findProp = findProp;\nexports.forAliasRE = forAliasRE;\nexports.generate = generate;\nexports.getBaseTransformPreset = getBaseTransformPreset;\nexports.getConstantType = getConstantType;\nexports.getMemoedVNodeCall = getMemoedVNodeCall;\nexports.getVNodeBlockHelper = getVNodeBlockHelper;\nexports.getVNodeHelper = getVNodeHelper;\nexports.hasDynamicKeyVBind = hasDynamicKeyVBind;\nexports.hasScopeRef = hasScopeRef;\nexports.helperNameMap = helperNameMap;\nexports.injectProp = injectProp;\nexports.isAllWhitespace = isAllWhitespace;\nexports.isCommentOrWhitespace = isCommentOrWhitespace;\nexports.isCoreComponent = isCoreComponent;\nexports.isFnExpression = isFnExpression;\nexports.isFnExpressionBrowser = isFnExpressionBrowser;\nexports.isFnExpressionNode = isFnExpressionNode;\nexports.isFunctionType = isFunctionType;\nexports.isInDestructureAssignment = isInDestructureAssignment;\nexports.isInNewExpression = isInNewExpression;\nexports.isMemberExpression = isMemberExpression;\nexports.isMemberExpressionBrowser = isMemberExpressionBrowser;\nexports.isMemberExpressionNode = isMemberExpressionNode;\nexports.isReferencedIdentifier = isReferencedIdentifier;\nexports.isSimpleIdentifier = isSimpleIdentifier;\nexports.isSlotOutlet = isSlotOutlet;\nexports.isStaticArgOf = isStaticArgOf;\nexports.isStaticExp = isStaticExp;\nexports.isStaticProperty = isStaticProperty;\nexports.isStaticPropertyKey = isStaticPropertyKey;\nexports.isTemplateNode = isTemplateNode;\nexports.isText = isText$1;\nexports.isVPre = isVPre;\nexports.isVSlot = isVSlot;\nexports.isWhitespaceText = isWhitespaceText;\nexports.locStub = locStub;\nexports.noopDirectiveTransform = noopDirectiveTransform;\nexports.processExpression = processExpression;\nexports.processFor = processFor;\nexports.processIf = processIf;\nexports.processSlotOutlet = processSlotOutlet;\nexports.registerRuntimeHelpers = registerRuntimeHelpers;\nexports.resolveComponentType = resolveComponentType;\nexports.stringifyExpression = stringifyExpression;\nexports.toValidAssetId = toValidAssetId;\nexports.trackSlotScopes = trackSlotScopes;\nexports.trackVForSlotScopes = trackVForSlotScopes;\nexports.transform = transform;\nexports.transformBind = transformBind;\nexports.transformElement = transformElement;\nexports.transformExpression = transformExpression;\nexports.transformModel = transformModel;\nexports.transformOn = transformOn;\nexports.transformVBindShorthand = transformVBindShorthand;\nexports.traverseNode = traverseNode;\nexports.unwrapTSNode = unwrapTSNode;\nexports.validFirstIdentCharRE = validFirstIdentCharRE;\nexports.walkBlockDeclarations = walkBlockDeclarations;\nexports.walkFunctionParams = walkFunctionParams;\nexports.walkIdentifiers = walkIdentifiers;\nexports.warnDeprecation = warnDeprecation;\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-dom/index.js b/miniapp/miniprogram_npm/@vue/compiler-dom/index.js new file mode 100644 index 0000000..49ce12c --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-dom/index.js @@ -0,0 +1,1649 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509108, function(require, module, exports) { + + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./dist/compiler-dom.cjs.prod.js') +} else { + module.exports = require('./dist/compiler-dom.cjs.js') +} + +}, function(modId) {var map = {"./dist/compiler-dom.cjs.prod.js":1771034509109,"./dist/compiler-dom.cjs.js":1771034509110}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509109, function(require, module, exports) { +/** +* @vue/compiler-dom v3.5.28 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var compilerCore = require('@vue/compiler-core'); +var shared = require('@vue/shared'); + +const V_MODEL_RADIO = /* @__PURE__ */ Symbol(``); +const V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol( + `` +); +const V_MODEL_TEXT = /* @__PURE__ */ Symbol(``); +const V_MODEL_SELECT = /* @__PURE__ */ Symbol( + `` +); +const V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol( + `` +); +const V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol( + `` +); +const V_ON_WITH_KEYS = /* @__PURE__ */ Symbol( + `` +); +const V_SHOW = /* @__PURE__ */ Symbol(``); +const TRANSITION = /* @__PURE__ */ Symbol(``); +const TRANSITION_GROUP = /* @__PURE__ */ Symbol( + `` +); +compilerCore.registerRuntimeHelpers({ + [V_MODEL_RADIO]: `vModelRadio`, + [V_MODEL_CHECKBOX]: `vModelCheckbox`, + [V_MODEL_TEXT]: `vModelText`, + [V_MODEL_SELECT]: `vModelSelect`, + [V_MODEL_DYNAMIC]: `vModelDynamic`, + [V_ON_WITH_MODIFIERS]: `withModifiers`, + [V_ON_WITH_KEYS]: `withKeys`, + [V_SHOW]: `vShow`, + [TRANSITION]: `Transition`, + [TRANSITION_GROUP]: `TransitionGroup` +}); + +const parserOptions = { + parseMode: "html", + isVoidTag: shared.isVoidTag, + isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag), + isPreTag: (tag) => tag === "pre", + isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea", + decodeEntities: void 0, + isBuiltInComponent: (tag) => { + if (tag === "Transition" || tag === "transition") { + return TRANSITION; + } else if (tag === "TransitionGroup" || tag === "transition-group") { + return TRANSITION_GROUP; + } + }, + // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher + getNamespace(tag, parent, rootNamespace) { + let ns = parent ? parent.ns : rootNamespace; + if (parent && ns === 2) { + if (parent.tag === "annotation-xml") { + if (tag === "svg") { + return 1; + } + if (parent.props.some( + (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml") + )) { + ns = 0; + } + } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") { + ns = 0; + } + } else if (parent && ns === 1) { + if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") { + ns = 0; + } + } + if (ns === 0) { + if (tag === "svg") { + return 1; + } + if (tag === "math") { + return 2; + } + } + return ns; + } +}; + +const transformStyle = (node) => { + if (node.type === 1) { + node.props.forEach((p, i) => { + if (p.type === 6 && p.name === "style" && p.value) { + node.props[i] = { + type: 7, + name: `bind`, + arg: compilerCore.createSimpleExpression(`style`, true, p.loc), + exp: parseInlineCSS(p.value.content, p.loc), + modifiers: [], + loc: p.loc + }; + } + }); + } +}; +const parseInlineCSS = (cssText, loc) => { + const normalized = shared.parseStringStyle(cssText); + return compilerCore.createSimpleExpression( + JSON.stringify(normalized), + false, + loc, + 3 + ); +}; + +function createDOMCompilerError(code, loc) { + return compilerCore.createCompilerError( + code, + loc, + DOMErrorMessages + ); +} +const DOMErrorCodes = { + "X_V_HTML_NO_EXPRESSION": 54, + "54": "X_V_HTML_NO_EXPRESSION", + "X_V_HTML_WITH_CHILDREN": 55, + "55": "X_V_HTML_WITH_CHILDREN", + "X_V_TEXT_NO_EXPRESSION": 56, + "56": "X_V_TEXT_NO_EXPRESSION", + "X_V_TEXT_WITH_CHILDREN": 57, + "57": "X_V_TEXT_WITH_CHILDREN", + "X_V_MODEL_ON_INVALID_ELEMENT": 58, + "58": "X_V_MODEL_ON_INVALID_ELEMENT", + "X_V_MODEL_ARG_ON_ELEMENT": 59, + "59": "X_V_MODEL_ARG_ON_ELEMENT", + "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60, + "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT", + "X_V_MODEL_UNNECESSARY_VALUE": 61, + "61": "X_V_MODEL_UNNECESSARY_VALUE", + "X_V_SHOW_NO_EXPRESSION": 62, + "62": "X_V_SHOW_NO_EXPRESSION", + "X_TRANSITION_INVALID_CHILDREN": 63, + "63": "X_TRANSITION_INVALID_CHILDREN", + "X_IGNORED_SIDE_EFFECT_TAG": 64, + "64": "X_IGNORED_SIDE_EFFECT_TAG", + "__EXTEND_POINT__": 65, + "65": "__EXTEND_POINT__" +}; +const DOMErrorMessages = { + [54]: `v-html is missing expression.`, + [55]: `v-html will override element children.`, + [56]: `v-text is missing expression.`, + [57]: `v-text will override element children.`, + [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`, + [59]: `v-model argument is not supported on plain elements.`, + [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`, + [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`, + [62]: `v-show is missing expression.`, + [63]: `<Transition> expects exactly one child element or component.`, + [64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.` +}; + +const transformVHtml = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(54, loc) + ); + } + if (node.children.length) { + context.onError( + createDOMCompilerError(55, loc) + ); + node.children.length = 0; + } + return { + props: [ + compilerCore.createObjectProperty( + compilerCore.createSimpleExpression(`innerHTML`, true, loc), + exp || compilerCore.createSimpleExpression("", true) + ) + ] + }; +}; + +const transformVText = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(56, loc) + ); + } + if (node.children.length) { + context.onError( + createDOMCompilerError(57, loc) + ); + node.children.length = 0; + } + return { + props: [ + compilerCore.createObjectProperty( + compilerCore.createSimpleExpression(`textContent`, true), + exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression( + context.helperString(compilerCore.TO_DISPLAY_STRING), + [exp], + loc + ) : compilerCore.createSimpleExpression("", true) + ) + ] + }; +}; + +const transformModel = (dir, node, context) => { + const baseResult = compilerCore.transformModel(dir, node, context); + if (!baseResult.props.length || node.tagType === 1) { + return baseResult; + } + if (dir.arg) { + context.onError( + createDOMCompilerError( + 59, + dir.arg.loc + ) + ); + } + const { tag } = node; + const isCustomElement = context.isCustomElement(tag); + if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) { + let directiveToUse = V_MODEL_TEXT; + let isInvalidType = false; + if (tag === "input" || isCustomElement) { + const type = compilerCore.findProp(node, `type`); + if (type) { + if (type.type === 7) { + directiveToUse = V_MODEL_DYNAMIC; + } else if (type.value) { + switch (type.value.content) { + case "radio": + directiveToUse = V_MODEL_RADIO; + break; + case "checkbox": + directiveToUse = V_MODEL_CHECKBOX; + break; + case "file": + isInvalidType = true; + context.onError( + createDOMCompilerError( + 60, + dir.loc + ) + ); + break; + } + } + } else if (compilerCore.hasDynamicKeyVBind(node)) { + directiveToUse = V_MODEL_DYNAMIC; + } else ; + } else if (tag === "select") { + directiveToUse = V_MODEL_SELECT; + } else ; + if (!isInvalidType) { + baseResult.needRuntime = context.helper(directiveToUse); + } + } else { + context.onError( + createDOMCompilerError( + 58, + dir.loc + ) + ); + } + baseResult.props = baseResult.props.filter( + (p) => !(p.key.type === 4 && p.key.content === "modelValue") + ); + return baseResult; +}; + +const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`); +const isNonKeyModifier = /* @__PURE__ */ shared.makeMap( + // event propagation management + `stop,prevent,self,ctrl,shift,alt,meta,exact,middle` +); +const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right"); +const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`); +const resolveModifiers = (key, modifiers, context, loc) => { + const keyModifiers = []; + const nonKeyModifiers = []; + const eventOptionModifiers = []; + for (let i = 0; i < modifiers.length; i++) { + const modifier = modifiers[i].content; + if (modifier === "native" && compilerCore.checkCompatEnabled( + "COMPILER_V_ON_NATIVE", + context, + loc + )) { + eventOptionModifiers.push(modifier); + } else if (isEventOptionModifier(modifier)) { + eventOptionModifiers.push(modifier); + } else { + if (maybeKeyModifier(modifier)) { + if (compilerCore.isStaticExp(key)) { + if (isKeyboardEvent(key.content.toLowerCase())) { + keyModifiers.push(modifier); + } else { + nonKeyModifiers.push(modifier); + } + } else { + keyModifiers.push(modifier); + nonKeyModifiers.push(modifier); + } + } else { + if (isNonKeyModifier(modifier)) { + nonKeyModifiers.push(modifier); + } else { + keyModifiers.push(modifier); + } + } + } + } + return { + keyModifiers, + nonKeyModifiers, + eventOptionModifiers + }; +}; +const transformClick = (key, event) => { + const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick"; + return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([ + `(`, + key, + `) === "onClick" ? "${event}" : (`, + key, + `)` + ]) : key; +}; +const transformOn = (dir, node, context) => { + return compilerCore.transformOn(dir, node, context, (baseResult) => { + const { modifiers } = dir; + if (!modifiers.length) return baseResult; + let { key, value: handlerExp } = baseResult.props[0]; + const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc); + if (nonKeyModifiers.includes("right")) { + key = transformClick(key, `onContextmenu`); + } + if (nonKeyModifiers.includes("middle")) { + key = transformClick(key, `onMouseup`); + } + if (nonKeyModifiers.length) { + handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [ + handlerExp, + JSON.stringify(nonKeyModifiers) + ]); + } + if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard + (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) { + handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [ + handlerExp, + JSON.stringify(keyModifiers) + ]); + } + if (eventOptionModifiers.length) { + const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join(""); + key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]); + } + return { + props: [compilerCore.createObjectProperty(key, handlerExp)] + }; + }); +}; + +const transformShow = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(62, loc) + ); + } + return { + props: [], + needRuntime: context.helper(V_SHOW) + }; +}; + +const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g; +const stringifyStatic = (children, context, parent) => { + if (context.scopes.vSlot > 0) { + return; + } + const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20; + let nc = 0; + let ec = 0; + const currentChunk = []; + const stringifyCurrentChunk = (currentIndex) => { + if (nc >= 20 || ec >= 5) { + const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [ + JSON.stringify( + currentChunk.map((node) => stringifyNode(node, context)).join("") + ).replace(expReplaceRE, `" + $1 + "`), + // the 2nd argument indicates the number of DOM nodes this static vnode + // will insert / hydrate + String(currentChunk.length) + ]); + const deleteCount = currentChunk.length - 1; + if (isParentCached) { + children.splice( + currentIndex - currentChunk.length, + currentChunk.length, + // @ts-expect-error + staticCall + ); + } else { + currentChunk[0].codegenNode.value = staticCall; + if (currentChunk.length > 1) { + children.splice(currentIndex - currentChunk.length + 1, deleteCount); + const cacheIndex = context.cached.indexOf( + currentChunk[currentChunk.length - 1].codegenNode + ); + if (cacheIndex > -1) { + for (let i2 = cacheIndex; i2 < context.cached.length; i2++) { + const c = context.cached[i2]; + if (c) c.index -= deleteCount; + } + context.cached.splice(cacheIndex - deleteCount + 1, deleteCount); + } + } + } + return deleteCount; + } + return 0; + }; + let i = 0; + for (; i < children.length; i++) { + const child = children[i]; + const isCached = isParentCached || getCachedNode(child); + if (isCached) { + const result = analyzeNode(child); + if (result) { + nc += result[0]; + ec += result[1]; + currentChunk.push(child); + continue; + } + } + i -= stringifyCurrentChunk(i); + nc = 0; + ec = 0; + currentChunk.length = 0; + } + stringifyCurrentChunk(i); +}; +const getCachedNode = (node) => { + if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) { + return node.codegenNode; + } +}; +const dataAriaRE = /^(?:data|aria)-/; +const isStringifiableAttr = (name, ns) => { + return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name); +}; +const isNonStringifiable = /* @__PURE__ */ shared.makeMap( + `caption,thead,tr,th,tbody,td,tfoot,colgroup,col` +); +function analyzeNode(node) { + if (node.type === 1 && isNonStringifiable(node.tag)) { + return false; + } + if (node.type === 1 && compilerCore.findDir(node, "once", true)) { + return false; + } + if (node.type === 12) { + return [1, 0]; + } + let nc = 1; + let ec = node.props.length > 0 ? 1 : 0; + let bailed = false; + const bail = () => { + bailed = true; + return false; + }; + function walk(node2) { + const isOptionTag = node2.tag === "option" && node2.ns === 0; + for (let i = 0; i < node2.props.length; i++) { + const p = node2.props[i]; + if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) { + return bail(); + } + if (p.type === 7 && p.name === "bind") { + if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) { + return bail(); + } + if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) { + return bail(); + } + if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) { + return bail(); + } + } + } + for (let i = 0; i < node2.children.length; i++) { + nc++; + const child = node2.children[i]; + if (child.type === 1) { + if (child.props.length > 0) { + ec++; + } + walk(child); + if (bailed) { + return false; + } + } + } + return true; + } + return walk(node) ? [nc, ec] : false; +} +function stringifyNode(node, context) { + if (shared.isString(node)) { + return node; + } + if (shared.isSymbol(node)) { + return ``; + } + switch (node.type) { + case 1: + return stringifyElement(node, context); + case 2: + return shared.escapeHtml(node.content); + case 3: + return `<!--${shared.escapeHtml(node.content)}-->`; + case 5: + return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content))); + case 8: + return shared.escapeHtml(evaluateConstant(node)); + case 12: + return stringifyNode(node.content, context); + default: + return ""; + } +} +function stringifyElement(node, context) { + let res = `<${node.tag}`; + let innerHTML = ""; + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + res += ` ${p.name}`; + if (p.value) { + res += `="${shared.escapeHtml(p.value.content)}"`; + } + } else if (p.type === 7) { + if (p.name === "bind") { + const exp = p.exp; + if (exp.content[0] === "_") { + res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`; + continue; + } + if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") { + continue; + } + let evaluated = evaluateConstant(exp); + if (evaluated != null) { + const arg = p.arg && p.arg.content; + if (arg === "class") { + evaluated = shared.normalizeClass(evaluated); + } else if (arg === "style") { + evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated)); + } + res += ` ${p.arg.content}="${shared.escapeHtml( + evaluated + )}"`; + } + } else if (p.name === "html") { + innerHTML = evaluateConstant(p.exp); + } else if (p.name === "text") { + innerHTML = shared.escapeHtml( + shared.toDisplayString(evaluateConstant(p.exp)) + ); + } + } + } + if (context.scopeId) { + res += ` ${context.scopeId}`; + } + res += `>`; + if (innerHTML) { + res += innerHTML; + } else { + for (let i = 0; i < node.children.length; i++) { + res += stringifyNode(node.children[i], context); + } + } + if (!shared.isVoidTag(node.tag)) { + res += `</${node.tag}>`; + } + return res; +} +function evaluateConstant(exp) { + if (exp.type === 4) { + return new Function(`return (${exp.content})`)(); + } else { + let res = ``; + exp.children.forEach((c) => { + if (shared.isString(c) || shared.isSymbol(c)) { + return; + } + if (c.type === 2) { + res += c.content; + } else if (c.type === 5) { + res += shared.toDisplayString(evaluateConstant(c.content)); + } else { + res += evaluateConstant(c); + } + }); + return res; + } +} + +const ignoreSideEffectTags = (node, context) => { + if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) { + context.removeNode(); + } +}; + +const DOMNodeTransforms = [ + transformStyle, + ...[] +]; +const DOMDirectiveTransforms = { + cloak: compilerCore.noopDirectiveTransform, + html: transformVHtml, + text: transformVText, + model: transformModel, + // override compiler-core + on: transformOn, + // override compiler-core + show: transformShow +}; +function compile(src, options = {}) { + return compilerCore.baseCompile( + src, + shared.extend({}, parserOptions, options, { + nodeTransforms: [ + // ignore <script> and <tag> + // this is not put inside DOMNodeTransforms because that list is used + // by compiler-ssr to generate vnode fallback branches + ignoreSideEffectTags, + ...DOMNodeTransforms, + ...options.nodeTransforms || [] + ], + directiveTransforms: shared.extend( + {}, + DOMDirectiveTransforms, + options.directiveTransforms || {} + ), + transformHoist: stringifyStatic + }) + ); +} +function parse(template, options = {}) { + return compilerCore.baseParse(template, shared.extend({}, parserOptions, options)); +} + +exports.DOMDirectiveTransforms = DOMDirectiveTransforms; +exports.DOMErrorCodes = DOMErrorCodes; +exports.DOMErrorMessages = DOMErrorMessages; +exports.DOMNodeTransforms = DOMNodeTransforms; +exports.TRANSITION = TRANSITION; +exports.TRANSITION_GROUP = TRANSITION_GROUP; +exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX; +exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC; +exports.V_MODEL_RADIO = V_MODEL_RADIO; +exports.V_MODEL_SELECT = V_MODEL_SELECT; +exports.V_MODEL_TEXT = V_MODEL_TEXT; +exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS; +exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS; +exports.V_SHOW = V_SHOW; +exports.compile = compile; +exports.createDOMCompilerError = createDOMCompilerError; +exports.parse = parse; +exports.parserOptions = parserOptions; +exports.transformStyle = transformStyle; +Object.keys(compilerCore).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k]; +}); + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +__DEFINE__(1771034509110, function(require, module, exports) { +/** +* @vue/compiler-dom v3.5.28 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var compilerCore = require('@vue/compiler-core'); +var shared = require('@vue/shared'); + +const V_MODEL_RADIO = /* @__PURE__ */ Symbol(`vModelRadio` ); +const V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol( + `vModelCheckbox` +); +const V_MODEL_TEXT = /* @__PURE__ */ Symbol(`vModelText` ); +const V_MODEL_SELECT = /* @__PURE__ */ Symbol( + `vModelSelect` +); +const V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol( + `vModelDynamic` +); +const V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol( + `vOnModifiersGuard` +); +const V_ON_WITH_KEYS = /* @__PURE__ */ Symbol( + `vOnKeysGuard` +); +const V_SHOW = /* @__PURE__ */ Symbol(`vShow` ); +const TRANSITION = /* @__PURE__ */ Symbol(`Transition` ); +const TRANSITION_GROUP = /* @__PURE__ */ Symbol( + `TransitionGroup` +); +compilerCore.registerRuntimeHelpers({ + [V_MODEL_RADIO]: `vModelRadio`, + [V_MODEL_CHECKBOX]: `vModelCheckbox`, + [V_MODEL_TEXT]: `vModelText`, + [V_MODEL_SELECT]: `vModelSelect`, + [V_MODEL_DYNAMIC]: `vModelDynamic`, + [V_ON_WITH_MODIFIERS]: `withModifiers`, + [V_ON_WITH_KEYS]: `withKeys`, + [V_SHOW]: `vShow`, + [TRANSITION]: `Transition`, + [TRANSITION_GROUP]: `TransitionGroup` +}); + +const parserOptions = { + parseMode: "html", + isVoidTag: shared.isVoidTag, + isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag), + isPreTag: (tag) => tag === "pre", + isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea", + decodeEntities: void 0, + isBuiltInComponent: (tag) => { + if (tag === "Transition" || tag === "transition") { + return TRANSITION; + } else if (tag === "TransitionGroup" || tag === "transition-group") { + return TRANSITION_GROUP; + } + }, + // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher + getNamespace(tag, parent, rootNamespace) { + let ns = parent ? parent.ns : rootNamespace; + if (parent && ns === 2) { + if (parent.tag === "annotation-xml") { + if (tag === "svg") { + return 1; + } + if (parent.props.some( + (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml") + )) { + ns = 0; + } + } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") { + ns = 0; + } + } else if (parent && ns === 1) { + if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") { + ns = 0; + } + } + if (ns === 0) { + if (tag === "svg") { + return 1; + } + if (tag === "math") { + return 2; + } + } + return ns; + } +}; + +const transformStyle = (node) => { + if (node.type === 1) { + node.props.forEach((p, i) => { + if (p.type === 6 && p.name === "style" && p.value) { + node.props[i] = { + type: 7, + name: `bind`, + arg: compilerCore.createSimpleExpression(`style`, true, p.loc), + exp: parseInlineCSS(p.value.content, p.loc), + modifiers: [], + loc: p.loc + }; + } + }); + } +}; +const parseInlineCSS = (cssText, loc) => { + const normalized = shared.parseStringStyle(cssText); + return compilerCore.createSimpleExpression( + JSON.stringify(normalized), + false, + loc, + 3 + ); +}; + +function createDOMCompilerError(code, loc) { + return compilerCore.createCompilerError( + code, + loc, + DOMErrorMessages + ); +} +const DOMErrorCodes = { + "X_V_HTML_NO_EXPRESSION": 54, + "54": "X_V_HTML_NO_EXPRESSION", + "X_V_HTML_WITH_CHILDREN": 55, + "55": "X_V_HTML_WITH_CHILDREN", + "X_V_TEXT_NO_EXPRESSION": 56, + "56": "X_V_TEXT_NO_EXPRESSION", + "X_V_TEXT_WITH_CHILDREN": 57, + "57": "X_V_TEXT_WITH_CHILDREN", + "X_V_MODEL_ON_INVALID_ELEMENT": 58, + "58": "X_V_MODEL_ON_INVALID_ELEMENT", + "X_V_MODEL_ARG_ON_ELEMENT": 59, + "59": "X_V_MODEL_ARG_ON_ELEMENT", + "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60, + "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT", + "X_V_MODEL_UNNECESSARY_VALUE": 61, + "61": "X_V_MODEL_UNNECESSARY_VALUE", + "X_V_SHOW_NO_EXPRESSION": 62, + "62": "X_V_SHOW_NO_EXPRESSION", + "X_TRANSITION_INVALID_CHILDREN": 63, + "63": "X_TRANSITION_INVALID_CHILDREN", + "X_IGNORED_SIDE_EFFECT_TAG": 64, + "64": "X_IGNORED_SIDE_EFFECT_TAG", + "__EXTEND_POINT__": 65, + "65": "__EXTEND_POINT__" +}; +const DOMErrorMessages = { + [54]: `v-html is missing expression.`, + [55]: `v-html will override element children.`, + [56]: `v-text is missing expression.`, + [57]: `v-text will override element children.`, + [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`, + [59]: `v-model argument is not supported on plain elements.`, + [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`, + [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`, + [62]: `v-show is missing expression.`, + [63]: `<Transition> expects exactly one child element or component.`, + [64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.` +}; + +const transformVHtml = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(54, loc) + ); + } + if (node.children.length) { + context.onError( + createDOMCompilerError(55, loc) + ); + node.children.length = 0; + } + return { + props: [ + compilerCore.createObjectProperty( + compilerCore.createSimpleExpression(`innerHTML`, true, loc), + exp || compilerCore.createSimpleExpression("", true) + ) + ] + }; +}; + +const transformVText = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(56, loc) + ); + } + if (node.children.length) { + context.onError( + createDOMCompilerError(57, loc) + ); + node.children.length = 0; + } + return { + props: [ + compilerCore.createObjectProperty( + compilerCore.createSimpleExpression(`textContent`, true), + exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression( + context.helperString(compilerCore.TO_DISPLAY_STRING), + [exp], + loc + ) : compilerCore.createSimpleExpression("", true) + ) + ] + }; +}; + +const transformModel = (dir, node, context) => { + const baseResult = compilerCore.transformModel(dir, node, context); + if (!baseResult.props.length || node.tagType === 1) { + return baseResult; + } + if (dir.arg) { + context.onError( + createDOMCompilerError( + 59, + dir.arg.loc + ) + ); + } + function checkDuplicatedValue() { + const value = compilerCore.findDir(node, "bind"); + if (value && compilerCore.isStaticArgOf(value.arg, "value")) { + context.onError( + createDOMCompilerError( + 61, + value.loc + ) + ); + } + } + const { tag } = node; + const isCustomElement = context.isCustomElement(tag); + if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) { + let directiveToUse = V_MODEL_TEXT; + let isInvalidType = false; + if (tag === "input" || isCustomElement) { + const type = compilerCore.findProp(node, `type`); + if (type) { + if (type.type === 7) { + directiveToUse = V_MODEL_DYNAMIC; + } else if (type.value) { + switch (type.value.content) { + case "radio": + directiveToUse = V_MODEL_RADIO; + break; + case "checkbox": + directiveToUse = V_MODEL_CHECKBOX; + break; + case "file": + isInvalidType = true; + context.onError( + createDOMCompilerError( + 60, + dir.loc + ) + ); + break; + default: + checkDuplicatedValue(); + break; + } + } + } else if (compilerCore.hasDynamicKeyVBind(node)) { + directiveToUse = V_MODEL_DYNAMIC; + } else { + checkDuplicatedValue(); + } + } else if (tag === "select") { + directiveToUse = V_MODEL_SELECT; + } else { + checkDuplicatedValue(); + } + if (!isInvalidType) { + baseResult.needRuntime = context.helper(directiveToUse); + } + } else { + context.onError( + createDOMCompilerError( + 58, + dir.loc + ) + ); + } + baseResult.props = baseResult.props.filter( + (p) => !(p.key.type === 4 && p.key.content === "modelValue") + ); + return baseResult; +}; + +const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`); +const isNonKeyModifier = /* @__PURE__ */ shared.makeMap( + // event propagation management + `stop,prevent,self,ctrl,shift,alt,meta,exact,middle` +); +const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right"); +const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`); +const resolveModifiers = (key, modifiers, context, loc) => { + const keyModifiers = []; + const nonKeyModifiers = []; + const eventOptionModifiers = []; + for (let i = 0; i < modifiers.length; i++) { + const modifier = modifiers[i].content; + if (modifier === "native" && compilerCore.checkCompatEnabled( + "COMPILER_V_ON_NATIVE", + context, + loc + )) { + eventOptionModifiers.push(modifier); + } else if (isEventOptionModifier(modifier)) { + eventOptionModifiers.push(modifier); + } else { + if (maybeKeyModifier(modifier)) { + if (compilerCore.isStaticExp(key)) { + if (isKeyboardEvent(key.content.toLowerCase())) { + keyModifiers.push(modifier); + } else { + nonKeyModifiers.push(modifier); + } + } else { + keyModifiers.push(modifier); + nonKeyModifiers.push(modifier); + } + } else { + if (isNonKeyModifier(modifier)) { + nonKeyModifiers.push(modifier); + } else { + keyModifiers.push(modifier); + } + } + } + } + return { + keyModifiers, + nonKeyModifiers, + eventOptionModifiers + }; +}; +const transformClick = (key, event) => { + const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick"; + return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([ + `(`, + key, + `) === "onClick" ? "${event}" : (`, + key, + `)` + ]) : key; +}; +const transformOn = (dir, node, context) => { + return compilerCore.transformOn(dir, node, context, (baseResult) => { + const { modifiers } = dir; + if (!modifiers.length) return baseResult; + let { key, value: handlerExp } = baseResult.props[0]; + const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc); + if (nonKeyModifiers.includes("right")) { + key = transformClick(key, `onContextmenu`); + } + if (nonKeyModifiers.includes("middle")) { + key = transformClick(key, `onMouseup`); + } + if (nonKeyModifiers.length) { + handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [ + handlerExp, + JSON.stringify(nonKeyModifiers) + ]); + } + if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard + (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) { + handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [ + handlerExp, + JSON.stringify(keyModifiers) + ]); + } + if (eventOptionModifiers.length) { + const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join(""); + key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]); + } + return { + props: [compilerCore.createObjectProperty(key, handlerExp)] + }; + }); +}; + +const transformShow = (dir, node, context) => { + const { exp, loc } = dir; + if (!exp) { + context.onError( + createDOMCompilerError(62, loc) + ); + } + return { + props: [], + needRuntime: context.helper(V_SHOW) + }; +}; + +const transformTransition = (node, context) => { + if (node.type === 1 && node.tagType === 1) { + const component = context.isBuiltInComponent(node.tag); + if (component === TRANSITION) { + return () => { + if (!node.children.length) { + return; + } + if (hasMultipleChildren(node)) { + context.onError( + createDOMCompilerError( + 63, + { + start: node.children[0].loc.start, + end: node.children[node.children.length - 1].loc.end, + source: "" + } + ) + ); + } + const child = node.children[0]; + if (child.type === 1) { + for (const p of child.props) { + if (p.type === 7 && p.name === "show") { + node.props.push({ + type: 6, + name: "persisted", + nameLoc: node.loc, + value: void 0, + loc: node.loc + }); + } + } + } + }; + } + } +}; +function hasMultipleChildren(node) { + const children = node.children = node.children.filter( + (c) => !compilerCore.isCommentOrWhitespace(c) + ); + const child = children[0]; + return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren); +} + +const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g; +const stringifyStatic = (children, context, parent) => { + if (context.scopes.vSlot > 0) { + return; + } + const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20; + let nc = 0; + let ec = 0; + const currentChunk = []; + const stringifyCurrentChunk = (currentIndex) => { + if (nc >= 20 || ec >= 5) { + const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [ + JSON.stringify( + currentChunk.map((node) => stringifyNode(node, context)).join("") + ).replace(expReplaceRE, `" + $1 + "`), + // the 2nd argument indicates the number of DOM nodes this static vnode + // will insert / hydrate + String(currentChunk.length) + ]); + const deleteCount = currentChunk.length - 1; + if (isParentCached) { + children.splice( + currentIndex - currentChunk.length, + currentChunk.length, + // @ts-expect-error + staticCall + ); + } else { + currentChunk[0].codegenNode.value = staticCall; + if (currentChunk.length > 1) { + children.splice(currentIndex - currentChunk.length + 1, deleteCount); + const cacheIndex = context.cached.indexOf( + currentChunk[currentChunk.length - 1].codegenNode + ); + if (cacheIndex > -1) { + for (let i2 = cacheIndex; i2 < context.cached.length; i2++) { + const c = context.cached[i2]; + if (c) c.index -= deleteCount; + } + context.cached.splice(cacheIndex - deleteCount + 1, deleteCount); + } + } + } + return deleteCount; + } + return 0; + }; + let i = 0; + for (; i < children.length; i++) { + const child = children[i]; + const isCached = isParentCached || getCachedNode(child); + if (isCached) { + const result = analyzeNode(child); + if (result) { + nc += result[0]; + ec += result[1]; + currentChunk.push(child); + continue; + } + } + i -= stringifyCurrentChunk(i); + nc = 0; + ec = 0; + currentChunk.length = 0; + } + stringifyCurrentChunk(i); +}; +const getCachedNode = (node) => { + if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) { + return node.codegenNode; + } +}; +const dataAriaRE = /^(?:data|aria)-/; +const isStringifiableAttr = (name, ns) => { + return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name); +}; +const isNonStringifiable = /* @__PURE__ */ shared.makeMap( + `caption,thead,tr,th,tbody,td,tfoot,colgroup,col` +); +function analyzeNode(node) { + if (node.type === 1 && isNonStringifiable(node.tag)) { + return false; + } + if (node.type === 1 && compilerCore.findDir(node, "once", true)) { + return false; + } + if (node.type === 12) { + return [1, 0]; + } + let nc = 1; + let ec = node.props.length > 0 ? 1 : 0; + let bailed = false; + const bail = () => { + bailed = true; + return false; + }; + function walk(node2) { + const isOptionTag = node2.tag === "option" && node2.ns === 0; + for (let i = 0; i < node2.props.length; i++) { + const p = node2.props[i]; + if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) { + return bail(); + } + if (p.type === 7 && p.name === "bind") { + if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) { + return bail(); + } + if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) { + return bail(); + } + if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) { + return bail(); + } + } + } + for (let i = 0; i < node2.children.length; i++) { + nc++; + const child = node2.children[i]; + if (child.type === 1) { + if (child.props.length > 0) { + ec++; + } + walk(child); + if (bailed) { + return false; + } + } + } + return true; + } + return walk(node) ? [nc, ec] : false; +} +function stringifyNode(node, context) { + if (shared.isString(node)) { + return node; + } + if (shared.isSymbol(node)) { + return ``; + } + switch (node.type) { + case 1: + return stringifyElement(node, context); + case 2: + return shared.escapeHtml(node.content); + case 3: + return `<!--${shared.escapeHtml(node.content)}-->`; + case 5: + return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content))); + case 8: + return shared.escapeHtml(evaluateConstant(node)); + case 12: + return stringifyNode(node.content, context); + default: + return ""; + } +} +function stringifyElement(node, context) { + let res = `<${node.tag}`; + let innerHTML = ""; + for (let i = 0; i < node.props.length; i++) { + const p = node.props[i]; + if (p.type === 6) { + res += ` ${p.name}`; + if (p.value) { + res += `="${shared.escapeHtml(p.value.content)}"`; + } + } else if (p.type === 7) { + if (p.name === "bind") { + const exp = p.exp; + if (exp.content[0] === "_") { + res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`; + continue; + } + if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") { + continue; + } + let evaluated = evaluateConstant(exp); + if (evaluated != null) { + const arg = p.arg && p.arg.content; + if (arg === "class") { + evaluated = shared.normalizeClass(evaluated); + } else if (arg === "style") { + evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated)); + } + res += ` ${p.arg.content}="${shared.escapeHtml( + evaluated + )}"`; + } + } else if (p.name === "html") { + innerHTML = evaluateConstant(p.exp); + } else if (p.name === "text") { + innerHTML = shared.escapeHtml( + shared.toDisplayString(evaluateConstant(p.exp)) + ); + } + } + } + if (context.scopeId) { + res += ` ${context.scopeId}`; + } + res += `>`; + if (innerHTML) { + res += innerHTML; + } else { + for (let i = 0; i < node.children.length; i++) { + res += stringifyNode(node.children[i], context); + } + } + if (!shared.isVoidTag(node.tag)) { + res += `</${node.tag}>`; + } + return res; +} +function evaluateConstant(exp) { + if (exp.type === 4) { + return new Function(`return (${exp.content})`)(); + } else { + let res = ``; + exp.children.forEach((c) => { + if (shared.isString(c) || shared.isSymbol(c)) { + return; + } + if (c.type === 2) { + res += c.content; + } else if (c.type === 5) { + res += shared.toDisplayString(evaluateConstant(c.content)); + } else { + res += evaluateConstant(c); + } + }); + return res; + } +} + +const ignoreSideEffectTags = (node, context) => { + if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) { + context.onError( + createDOMCompilerError( + 64, + node.loc + ) + ); + context.removeNode(); + } +}; + +function isValidHTMLNesting(parent, child) { + if (parent === "template") { + return true; + } + if (parent in onlyValidChildren) { + return onlyValidChildren[parent].has(child); + } + if (child in onlyValidParents) { + return onlyValidParents[child].has(parent); + } + if (parent in knownInvalidChildren) { + if (knownInvalidChildren[parent].has(child)) return false; + } + if (child in knownInvalidParents) { + if (knownInvalidParents[child].has(parent)) return false; + } + return true; +} +const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]); +const emptySet = /* @__PURE__ */ new Set([]); +const onlyValidChildren = { + head: /* @__PURE__ */ new Set([ + "base", + "basefront", + "bgsound", + "link", + "meta", + "title", + "noscript", + "noframes", + "style", + "script", + "template" + ]), + optgroup: /* @__PURE__ */ new Set(["option"]), + select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]), + // table + table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]), + tr: /* @__PURE__ */ new Set(["td", "th"]), + colgroup: /* @__PURE__ */ new Set(["col"]), + tbody: /* @__PURE__ */ new Set(["tr"]), + thead: /* @__PURE__ */ new Set(["tr"]), + tfoot: /* @__PURE__ */ new Set(["tr"]), + // these elements can not have any children elements + script: emptySet, + iframe: emptySet, + option: emptySet, + textarea: emptySet, + style: emptySet, + title: emptySet +}; +const onlyValidParents = { + // sections + html: emptySet, + body: /* @__PURE__ */ new Set(["html"]), + head: /* @__PURE__ */ new Set(["html"]), + // table + td: /* @__PURE__ */ new Set(["tr"]), + colgroup: /* @__PURE__ */ new Set(["table"]), + caption: /* @__PURE__ */ new Set(["table"]), + tbody: /* @__PURE__ */ new Set(["table"]), + tfoot: /* @__PURE__ */ new Set(["table"]), + col: /* @__PURE__ */ new Set(["colgroup"]), + th: /* @__PURE__ */ new Set(["tr"]), + thead: /* @__PURE__ */ new Set(["table"]), + tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]), + // data list + dd: /* @__PURE__ */ new Set(["dl", "div"]), + dt: /* @__PURE__ */ new Set(["dl", "div"]), + // other + figcaption: /* @__PURE__ */ new Set(["figure"]), + // li: new Set(["ul", "ol"]), + summary: /* @__PURE__ */ new Set(["details"]), + area: /* @__PURE__ */ new Set(["map"]) +}; +const knownInvalidChildren = { + p: /* @__PURE__ */ new Set([ + "address", + "article", + "aside", + "blockquote", + "center", + "details", + "dialog", + "dir", + "div", + "dl", + "fieldset", + "figure", + "footer", + "form", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "header", + "hgroup", + "hr", + "li", + "main", + "nav", + "menu", + "ol", + "p", + "pre", + "section", + "table", + "ul" + ]), + svg: /* @__PURE__ */ new Set([ + "b", + "blockquote", + "br", + "code", + "dd", + "div", + "dl", + "dt", + "em", + "embed", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "hr", + "i", + "img", + "li", + "menu", + "meta", + "ol", + "p", + "pre", + "ruby", + "s", + "small", + "span", + "strong", + "sub", + "sup", + "table", + "u", + "ul", + "var" + ]) +}; +const knownInvalidParents = { + a: /* @__PURE__ */ new Set(["a"]), + button: /* @__PURE__ */ new Set(["button"]), + dd: /* @__PURE__ */ new Set(["dd", "dt"]), + dt: /* @__PURE__ */ new Set(["dd", "dt"]), + form: /* @__PURE__ */ new Set(["form"]), + li: /* @__PURE__ */ new Set(["li"]), + h1: headings, + h2: headings, + h3: headings, + h4: headings, + h5: headings, + h6: headings +}; + +const validateHtmlNesting = (node, context) => { + if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) { + const error = new SyntaxError( + `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.` + ); + error.loc = node.loc; + context.onWarn(error); + } +}; + +const DOMNodeTransforms = [ + transformStyle, + ...[transformTransition, validateHtmlNesting] +]; +const DOMDirectiveTransforms = { + cloak: compilerCore.noopDirectiveTransform, + html: transformVHtml, + text: transformVText, + model: transformModel, + // override compiler-core + on: transformOn, + // override compiler-core + show: transformShow +}; +function compile(src, options = {}) { + return compilerCore.baseCompile( + src, + shared.extend({}, parserOptions, options, { + nodeTransforms: [ + // ignore <script> and <tag> + // this is not put inside DOMNodeTransforms because that list is used + // by compiler-ssr to generate vnode fallback branches + ignoreSideEffectTags, + ...DOMNodeTransforms, + ...options.nodeTransforms || [] + ], + directiveTransforms: shared.extend( + {}, + DOMDirectiveTransforms, + options.directiveTransforms || {} + ), + transformHoist: stringifyStatic + }) + ); +} +function parse(template, options = {}) { + return compilerCore.baseParse(template, shared.extend({}, parserOptions, options)); +} + +exports.DOMDirectiveTransforms = DOMDirectiveTransforms; +exports.DOMErrorCodes = DOMErrorCodes; +exports.DOMErrorMessages = DOMErrorMessages; +exports.DOMNodeTransforms = DOMNodeTransforms; +exports.TRANSITION = TRANSITION; +exports.TRANSITION_GROUP = TRANSITION_GROUP; +exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX; +exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC; +exports.V_MODEL_RADIO = V_MODEL_RADIO; +exports.V_MODEL_SELECT = V_MODEL_SELECT; +exports.V_MODEL_TEXT = V_MODEL_TEXT; +exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS; +exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS; +exports.V_SHOW = V_SHOW; +exports.compile = compile; +exports.createDOMCompilerError = createDOMCompilerError; +exports.parse = parse; +exports.parserOptions = parserOptions; +exports.transformStyle = transformStyle; +Object.keys(compilerCore).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k]; +}); + +}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509108); +})() +//miniprogram-npm-outsideDeps=["@vue/compiler-core","@vue/shared"] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-dom/index.js.map b/miniapp/miniprogram_npm/@vue/compiler-dom/index.js.map new file mode 100644 index 0000000..d0de8e3 --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-dom/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["index.js","dist/compiler-dom.cjs.prod.js","dist/compiler-dom.cjs.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;AELA,ADGA,ADGA;AELA,ADGA,ADGA;AELA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA,ADGA;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./dist/compiler-dom.cjs.prod.js')\n} else {\n module.exports = require('./dist/compiler-dom.cjs.js')\n}\n","/**\n* @vue/compiler-dom v3.5.28\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\n* @license MIT\n**/\n\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar compilerCore = require('@vue/compiler-core');\nvar shared = require('@vue/shared');\n\nconst V_MODEL_RADIO = /* @__PURE__ */ Symbol(``);\nconst V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol(\n ``\n);\nconst V_MODEL_TEXT = /* @__PURE__ */ Symbol(``);\nconst V_MODEL_SELECT = /* @__PURE__ */ Symbol(\n ``\n);\nconst V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol(\n ``\n);\nconst V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol(\n ``\n);\nconst V_ON_WITH_KEYS = /* @__PURE__ */ Symbol(\n ``\n);\nconst V_SHOW = /* @__PURE__ */ Symbol(``);\nconst TRANSITION = /* @__PURE__ */ Symbol(``);\nconst TRANSITION_GROUP = /* @__PURE__ */ Symbol(\n ``\n);\ncompilerCore.registerRuntimeHelpers({\n [V_MODEL_RADIO]: `vModelRadio`,\n [V_MODEL_CHECKBOX]: `vModelCheckbox`,\n [V_MODEL_TEXT]: `vModelText`,\n [V_MODEL_SELECT]: `vModelSelect`,\n [V_MODEL_DYNAMIC]: `vModelDynamic`,\n [V_ON_WITH_MODIFIERS]: `withModifiers`,\n [V_ON_WITH_KEYS]: `withKeys`,\n [V_SHOW]: `vShow`,\n [TRANSITION]: `Transition`,\n [TRANSITION_GROUP]: `TransitionGroup`\n});\n\nconst parserOptions = {\n parseMode: \"html\",\n isVoidTag: shared.isVoidTag,\n isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),\n isPreTag: (tag) => tag === \"pre\",\n isIgnoreNewlineTag: (tag) => tag === \"pre\" || tag === \"textarea\",\n decodeEntities: void 0,\n isBuiltInComponent: (tag) => {\n if (tag === \"Transition\" || tag === \"transition\") {\n return TRANSITION;\n } else if (tag === \"TransitionGroup\" || tag === \"transition-group\") {\n return TRANSITION_GROUP;\n }\n },\n // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher\n getNamespace(tag, parent, rootNamespace) {\n let ns = parent ? parent.ns : rootNamespace;\n if (parent && ns === 2) {\n if (parent.tag === \"annotation-xml\") {\n if (tag === \"svg\") {\n return 1;\n }\n if (parent.props.some(\n (a) => a.type === 6 && a.name === \"encoding\" && a.value != null && (a.value.content === \"text/html\" || a.value.content === \"application/xhtml+xml\")\n )) {\n ns = 0;\n }\n } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== \"mglyph\" && tag !== \"malignmark\") {\n ns = 0;\n }\n } else if (parent && ns === 1) {\n if (parent.tag === \"foreignObject\" || parent.tag === \"desc\" || parent.tag === \"title\") {\n ns = 0;\n }\n }\n if (ns === 0) {\n if (tag === \"svg\") {\n return 1;\n }\n if (tag === \"math\") {\n return 2;\n }\n }\n return ns;\n }\n};\n\nconst transformStyle = (node) => {\n if (node.type === 1) {\n node.props.forEach((p, i) => {\n if (p.type === 6 && p.name === \"style\" && p.value) {\n node.props[i] = {\n type: 7,\n name: `bind`,\n arg: compilerCore.createSimpleExpression(`style`, true, p.loc),\n exp: parseInlineCSS(p.value.content, p.loc),\n modifiers: [],\n loc: p.loc\n };\n }\n });\n }\n};\nconst parseInlineCSS = (cssText, loc) => {\n const normalized = shared.parseStringStyle(cssText);\n return compilerCore.createSimpleExpression(\n JSON.stringify(normalized),\n false,\n loc,\n 3\n );\n};\n\nfunction createDOMCompilerError(code, loc) {\n return compilerCore.createCompilerError(\n code,\n loc,\n DOMErrorMessages \n );\n}\nconst DOMErrorCodes = {\n \"X_V_HTML_NO_EXPRESSION\": 54,\n \"54\": \"X_V_HTML_NO_EXPRESSION\",\n \"X_V_HTML_WITH_CHILDREN\": 55,\n \"55\": \"X_V_HTML_WITH_CHILDREN\",\n \"X_V_TEXT_NO_EXPRESSION\": 56,\n \"56\": \"X_V_TEXT_NO_EXPRESSION\",\n \"X_V_TEXT_WITH_CHILDREN\": 57,\n \"57\": \"X_V_TEXT_WITH_CHILDREN\",\n \"X_V_MODEL_ON_INVALID_ELEMENT\": 58,\n \"58\": \"X_V_MODEL_ON_INVALID_ELEMENT\",\n \"X_V_MODEL_ARG_ON_ELEMENT\": 59,\n \"59\": \"X_V_MODEL_ARG_ON_ELEMENT\",\n \"X_V_MODEL_ON_FILE_INPUT_ELEMENT\": 60,\n \"60\": \"X_V_MODEL_ON_FILE_INPUT_ELEMENT\",\n \"X_V_MODEL_UNNECESSARY_VALUE\": 61,\n \"61\": \"X_V_MODEL_UNNECESSARY_VALUE\",\n \"X_V_SHOW_NO_EXPRESSION\": 62,\n \"62\": \"X_V_SHOW_NO_EXPRESSION\",\n \"X_TRANSITION_INVALID_CHILDREN\": 63,\n \"63\": \"X_TRANSITION_INVALID_CHILDREN\",\n \"X_IGNORED_SIDE_EFFECT_TAG\": 64,\n \"64\": \"X_IGNORED_SIDE_EFFECT_TAG\",\n \"__EXTEND_POINT__\": 65,\n \"65\": \"__EXTEND_POINT__\"\n};\nconst DOMErrorMessages = {\n [54]: `v-html is missing expression.`,\n [55]: `v-html will override element children.`,\n [56]: `v-text is missing expression.`,\n [57]: `v-text will override element children.`,\n [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,\n [59]: `v-model argument is not supported on plain elements.`,\n [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,\n [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,\n [62]: `v-show is missing expression.`,\n [63]: `<Transition> expects exactly one child element or component.`,\n [64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`\n};\n\nconst transformVHtml = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(54, loc)\n );\n }\n if (node.children.length) {\n context.onError(\n createDOMCompilerError(55, loc)\n );\n node.children.length = 0;\n }\n return {\n props: [\n compilerCore.createObjectProperty(\n compilerCore.createSimpleExpression(`innerHTML`, true, loc),\n exp || compilerCore.createSimpleExpression(\"\", true)\n )\n ]\n };\n};\n\nconst transformVText = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(56, loc)\n );\n }\n if (node.children.length) {\n context.onError(\n createDOMCompilerError(57, loc)\n );\n node.children.length = 0;\n }\n return {\n props: [\n compilerCore.createObjectProperty(\n compilerCore.createSimpleExpression(`textContent`, true),\n exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(\n context.helperString(compilerCore.TO_DISPLAY_STRING),\n [exp],\n loc\n ) : compilerCore.createSimpleExpression(\"\", true)\n )\n ]\n };\n};\n\nconst transformModel = (dir, node, context) => {\n const baseResult = compilerCore.transformModel(dir, node, context);\n if (!baseResult.props.length || node.tagType === 1) {\n return baseResult;\n }\n if (dir.arg) {\n context.onError(\n createDOMCompilerError(\n 59,\n dir.arg.loc\n )\n );\n }\n const { tag } = node;\n const isCustomElement = context.isCustomElement(tag);\n if (tag === \"input\" || tag === \"textarea\" || tag === \"select\" || isCustomElement) {\n let directiveToUse = V_MODEL_TEXT;\n let isInvalidType = false;\n if (tag === \"input\" || isCustomElement) {\n const type = compilerCore.findProp(node, `type`);\n if (type) {\n if (type.type === 7) {\n directiveToUse = V_MODEL_DYNAMIC;\n } else if (type.value) {\n switch (type.value.content) {\n case \"radio\":\n directiveToUse = V_MODEL_RADIO;\n break;\n case \"checkbox\":\n directiveToUse = V_MODEL_CHECKBOX;\n break;\n case \"file\":\n isInvalidType = true;\n context.onError(\n createDOMCompilerError(\n 60,\n dir.loc\n )\n );\n break;\n }\n }\n } else if (compilerCore.hasDynamicKeyVBind(node)) {\n directiveToUse = V_MODEL_DYNAMIC;\n } else ;\n } else if (tag === \"select\") {\n directiveToUse = V_MODEL_SELECT;\n } else ;\n if (!isInvalidType) {\n baseResult.needRuntime = context.helper(directiveToUse);\n }\n } else {\n context.onError(\n createDOMCompilerError(\n 58,\n dir.loc\n )\n );\n }\n baseResult.props = baseResult.props.filter(\n (p) => !(p.key.type === 4 && p.key.content === \"modelValue\")\n );\n return baseResult;\n};\n\nconst isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);\nconst isNonKeyModifier = /* @__PURE__ */ shared.makeMap(\n // event propagation management\n `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`\n);\nconst maybeKeyModifier = /* @__PURE__ */ shared.makeMap(\"left,right\");\nconst isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);\nconst resolveModifiers = (key, modifiers, context, loc) => {\n const keyModifiers = [];\n const nonKeyModifiers = [];\n const eventOptionModifiers = [];\n for (let i = 0; i < modifiers.length; i++) {\n const modifier = modifiers[i].content;\n if (modifier === \"native\" && compilerCore.checkCompatEnabled(\n \"COMPILER_V_ON_NATIVE\",\n context,\n loc\n )) {\n eventOptionModifiers.push(modifier);\n } else if (isEventOptionModifier(modifier)) {\n eventOptionModifiers.push(modifier);\n } else {\n if (maybeKeyModifier(modifier)) {\n if (compilerCore.isStaticExp(key)) {\n if (isKeyboardEvent(key.content.toLowerCase())) {\n keyModifiers.push(modifier);\n } else {\n nonKeyModifiers.push(modifier);\n }\n } else {\n keyModifiers.push(modifier);\n nonKeyModifiers.push(modifier);\n }\n } else {\n if (isNonKeyModifier(modifier)) {\n nonKeyModifiers.push(modifier);\n } else {\n keyModifiers.push(modifier);\n }\n }\n }\n }\n return {\n keyModifiers,\n nonKeyModifiers,\n eventOptionModifiers\n };\n};\nconst transformClick = (key, event) => {\n const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === \"onclick\";\n return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([\n `(`,\n key,\n `) === \"onClick\" ? \"${event}\" : (`,\n key,\n `)`\n ]) : key;\n};\nconst transformOn = (dir, node, context) => {\n return compilerCore.transformOn(dir, node, context, (baseResult) => {\n const { modifiers } = dir;\n if (!modifiers.length) return baseResult;\n let { key, value: handlerExp } = baseResult.props[0];\n const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);\n if (nonKeyModifiers.includes(\"right\")) {\n key = transformClick(key, `onContextmenu`);\n }\n if (nonKeyModifiers.includes(\"middle\")) {\n key = transformClick(key, `onMouseup`);\n }\n if (nonKeyModifiers.length) {\n handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [\n handlerExp,\n JSON.stringify(nonKeyModifiers)\n ]);\n }\n if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard\n (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {\n handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [\n handlerExp,\n JSON.stringify(keyModifiers)\n ]);\n }\n if (eventOptionModifiers.length) {\n const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join(\"\");\n key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + \"${modifierPostfix}\"`]);\n }\n return {\n props: [compilerCore.createObjectProperty(key, handlerExp)]\n };\n });\n};\n\nconst transformShow = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(62, loc)\n );\n }\n return {\n props: [],\n needRuntime: context.helper(V_SHOW)\n };\n};\n\nconst expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;\nconst stringifyStatic = (children, context, parent) => {\n if (context.scopes.vSlot > 0) {\n return;\n }\n const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;\n let nc = 0;\n let ec = 0;\n const currentChunk = [];\n const stringifyCurrentChunk = (currentIndex) => {\n if (nc >= 20 || ec >= 5) {\n const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [\n JSON.stringify(\n currentChunk.map((node) => stringifyNode(node, context)).join(\"\")\n ).replace(expReplaceRE, `\" + $1 + \"`),\n // the 2nd argument indicates the number of DOM nodes this static vnode\n // will insert / hydrate\n String(currentChunk.length)\n ]);\n const deleteCount = currentChunk.length - 1;\n if (isParentCached) {\n children.splice(\n currentIndex - currentChunk.length,\n currentChunk.length,\n // @ts-expect-error\n staticCall\n );\n } else {\n currentChunk[0].codegenNode.value = staticCall;\n if (currentChunk.length > 1) {\n children.splice(currentIndex - currentChunk.length + 1, deleteCount);\n const cacheIndex = context.cached.indexOf(\n currentChunk[currentChunk.length - 1].codegenNode\n );\n if (cacheIndex > -1) {\n for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {\n const c = context.cached[i2];\n if (c) c.index -= deleteCount;\n }\n context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);\n }\n }\n }\n return deleteCount;\n }\n return 0;\n };\n let i = 0;\n for (; i < children.length; i++) {\n const child = children[i];\n const isCached = isParentCached || getCachedNode(child);\n if (isCached) {\n const result = analyzeNode(child);\n if (result) {\n nc += result[0];\n ec += result[1];\n currentChunk.push(child);\n continue;\n }\n }\n i -= stringifyCurrentChunk(i);\n nc = 0;\n ec = 0;\n currentChunk.length = 0;\n }\n stringifyCurrentChunk(i);\n};\nconst getCachedNode = (node) => {\n if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {\n return node.codegenNode;\n }\n};\nconst dataAriaRE = /^(?:data|aria)-/;\nconst isStringifiableAttr = (name, ns) => {\n return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);\n};\nconst isNonStringifiable = /* @__PURE__ */ shared.makeMap(\n `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`\n);\nfunction analyzeNode(node) {\n if (node.type === 1 && isNonStringifiable(node.tag)) {\n return false;\n }\n if (node.type === 1 && compilerCore.findDir(node, \"once\", true)) {\n return false;\n }\n if (node.type === 12) {\n return [1, 0];\n }\n let nc = 1;\n let ec = node.props.length > 0 ? 1 : 0;\n let bailed = false;\n const bail = () => {\n bailed = true;\n return false;\n };\n function walk(node2) {\n const isOptionTag = node2.tag === \"option\" && node2.ns === 0;\n for (let i = 0; i < node2.props.length; i++) {\n const p = node2.props[i];\n if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {\n return bail();\n }\n if (p.type === 7 && p.name === \"bind\") {\n if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {\n return bail();\n }\n if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {\n return bail();\n }\n if (isOptionTag && compilerCore.isStaticArgOf(p.arg, \"value\") && p.exp && !p.exp.isStatic) {\n return bail();\n }\n }\n }\n for (let i = 0; i < node2.children.length; i++) {\n nc++;\n const child = node2.children[i];\n if (child.type === 1) {\n if (child.props.length > 0) {\n ec++;\n }\n walk(child);\n if (bailed) {\n return false;\n }\n }\n }\n return true;\n }\n return walk(node) ? [nc, ec] : false;\n}\nfunction stringifyNode(node, context) {\n if (shared.isString(node)) {\n return node;\n }\n if (shared.isSymbol(node)) {\n return ``;\n }\n switch (node.type) {\n case 1:\n return stringifyElement(node, context);\n case 2:\n return shared.escapeHtml(node.content);\n case 3:\n return `<!--${shared.escapeHtml(node.content)}-->`;\n case 5:\n return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));\n case 8:\n return shared.escapeHtml(evaluateConstant(node));\n case 12:\n return stringifyNode(node.content, context);\n default:\n return \"\";\n }\n}\nfunction stringifyElement(node, context) {\n let res = `<${node.tag}`;\n let innerHTML = \"\";\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n res += ` ${p.name}`;\n if (p.value) {\n res += `=\"${shared.escapeHtml(p.value.content)}\"`;\n }\n } else if (p.type === 7) {\n if (p.name === \"bind\") {\n const exp = p.exp;\n if (exp.content[0] === \"_\") {\n res += ` ${p.arg.content}=\"__VUE_EXP_START__${exp.content}__VUE_EXP_END__\"`;\n continue;\n }\n if (shared.isBooleanAttr(p.arg.content) && exp.content === \"false\") {\n continue;\n }\n let evaluated = evaluateConstant(exp);\n if (evaluated != null) {\n const arg = p.arg && p.arg.content;\n if (arg === \"class\") {\n evaluated = shared.normalizeClass(evaluated);\n } else if (arg === \"style\") {\n evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));\n }\n res += ` ${p.arg.content}=\"${shared.escapeHtml(\n evaluated\n )}\"`;\n }\n } else if (p.name === \"html\") {\n innerHTML = evaluateConstant(p.exp);\n } else if (p.name === \"text\") {\n innerHTML = shared.escapeHtml(\n shared.toDisplayString(evaluateConstant(p.exp))\n );\n }\n }\n }\n if (context.scopeId) {\n res += ` ${context.scopeId}`;\n }\n res += `>`;\n if (innerHTML) {\n res += innerHTML;\n } else {\n for (let i = 0; i < node.children.length; i++) {\n res += stringifyNode(node.children[i], context);\n }\n }\n if (!shared.isVoidTag(node.tag)) {\n res += `</${node.tag}>`;\n }\n return res;\n}\nfunction evaluateConstant(exp) {\n if (exp.type === 4) {\n return new Function(`return (${exp.content})`)();\n } else {\n let res = ``;\n exp.children.forEach((c) => {\n if (shared.isString(c) || shared.isSymbol(c)) {\n return;\n }\n if (c.type === 2) {\n res += c.content;\n } else if (c.type === 5) {\n res += shared.toDisplayString(evaluateConstant(c.content));\n } else {\n res += evaluateConstant(c);\n }\n });\n return res;\n }\n}\n\nconst ignoreSideEffectTags = (node, context) => {\n if (node.type === 1 && node.tagType === 0 && (node.tag === \"script\" || node.tag === \"style\")) {\n context.removeNode();\n }\n};\n\nconst DOMNodeTransforms = [\n transformStyle,\n ...[]\n];\nconst DOMDirectiveTransforms = {\n cloak: compilerCore.noopDirectiveTransform,\n html: transformVHtml,\n text: transformVText,\n model: transformModel,\n // override compiler-core\n on: transformOn,\n // override compiler-core\n show: transformShow\n};\nfunction compile(src, options = {}) {\n return compilerCore.baseCompile(\n src,\n shared.extend({}, parserOptions, options, {\n nodeTransforms: [\n // ignore <script> and <tag>\n // this is not put inside DOMNodeTransforms because that list is used\n // by compiler-ssr to generate vnode fallback branches\n ignoreSideEffectTags,\n ...DOMNodeTransforms,\n ...options.nodeTransforms || []\n ],\n directiveTransforms: shared.extend(\n {},\n DOMDirectiveTransforms,\n options.directiveTransforms || {}\n ),\n transformHoist: stringifyStatic\n })\n );\n}\nfunction parse(template, options = {}) {\n return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));\n}\n\nexports.DOMDirectiveTransforms = DOMDirectiveTransforms;\nexports.DOMErrorCodes = DOMErrorCodes;\nexports.DOMErrorMessages = DOMErrorMessages;\nexports.DOMNodeTransforms = DOMNodeTransforms;\nexports.TRANSITION = TRANSITION;\nexports.TRANSITION_GROUP = TRANSITION_GROUP;\nexports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;\nexports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;\nexports.V_MODEL_RADIO = V_MODEL_RADIO;\nexports.V_MODEL_SELECT = V_MODEL_SELECT;\nexports.V_MODEL_TEXT = V_MODEL_TEXT;\nexports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;\nexports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;\nexports.V_SHOW = V_SHOW;\nexports.compile = compile;\nexports.createDOMCompilerError = createDOMCompilerError;\nexports.parse = parse;\nexports.parserOptions = parserOptions;\nexports.transformStyle = transformStyle;\nObject.keys(compilerCore).forEach(function (k) {\n if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];\n});\n","/**\n* @vue/compiler-dom v3.5.28\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\n* @license MIT\n**/\n\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar compilerCore = require('@vue/compiler-core');\nvar shared = require('@vue/shared');\n\nconst V_MODEL_RADIO = /* @__PURE__ */ Symbol(`vModelRadio` );\nconst V_MODEL_CHECKBOX = /* @__PURE__ */ Symbol(\n `vModelCheckbox` \n);\nconst V_MODEL_TEXT = /* @__PURE__ */ Symbol(`vModelText` );\nconst V_MODEL_SELECT = /* @__PURE__ */ Symbol(\n `vModelSelect` \n);\nconst V_MODEL_DYNAMIC = /* @__PURE__ */ Symbol(\n `vModelDynamic` \n);\nconst V_ON_WITH_MODIFIERS = /* @__PURE__ */ Symbol(\n `vOnModifiersGuard` \n);\nconst V_ON_WITH_KEYS = /* @__PURE__ */ Symbol(\n `vOnKeysGuard` \n);\nconst V_SHOW = /* @__PURE__ */ Symbol(`vShow` );\nconst TRANSITION = /* @__PURE__ */ Symbol(`Transition` );\nconst TRANSITION_GROUP = /* @__PURE__ */ Symbol(\n `TransitionGroup` \n);\ncompilerCore.registerRuntimeHelpers({\n [V_MODEL_RADIO]: `vModelRadio`,\n [V_MODEL_CHECKBOX]: `vModelCheckbox`,\n [V_MODEL_TEXT]: `vModelText`,\n [V_MODEL_SELECT]: `vModelSelect`,\n [V_MODEL_DYNAMIC]: `vModelDynamic`,\n [V_ON_WITH_MODIFIERS]: `withModifiers`,\n [V_ON_WITH_KEYS]: `withKeys`,\n [V_SHOW]: `vShow`,\n [TRANSITION]: `Transition`,\n [TRANSITION_GROUP]: `TransitionGroup`\n});\n\nconst parserOptions = {\n parseMode: \"html\",\n isVoidTag: shared.isVoidTag,\n isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),\n isPreTag: (tag) => tag === \"pre\",\n isIgnoreNewlineTag: (tag) => tag === \"pre\" || tag === \"textarea\",\n decodeEntities: void 0,\n isBuiltInComponent: (tag) => {\n if (tag === \"Transition\" || tag === \"transition\") {\n return TRANSITION;\n } else if (tag === \"TransitionGroup\" || tag === \"transition-group\") {\n return TRANSITION_GROUP;\n }\n },\n // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher\n getNamespace(tag, parent, rootNamespace) {\n let ns = parent ? parent.ns : rootNamespace;\n if (parent && ns === 2) {\n if (parent.tag === \"annotation-xml\") {\n if (tag === \"svg\") {\n return 1;\n }\n if (parent.props.some(\n (a) => a.type === 6 && a.name === \"encoding\" && a.value != null && (a.value.content === \"text/html\" || a.value.content === \"application/xhtml+xml\")\n )) {\n ns = 0;\n }\n } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== \"mglyph\" && tag !== \"malignmark\") {\n ns = 0;\n }\n } else if (parent && ns === 1) {\n if (parent.tag === \"foreignObject\" || parent.tag === \"desc\" || parent.tag === \"title\") {\n ns = 0;\n }\n }\n if (ns === 0) {\n if (tag === \"svg\") {\n return 1;\n }\n if (tag === \"math\") {\n return 2;\n }\n }\n return ns;\n }\n};\n\nconst transformStyle = (node) => {\n if (node.type === 1) {\n node.props.forEach((p, i) => {\n if (p.type === 6 && p.name === \"style\" && p.value) {\n node.props[i] = {\n type: 7,\n name: `bind`,\n arg: compilerCore.createSimpleExpression(`style`, true, p.loc),\n exp: parseInlineCSS(p.value.content, p.loc),\n modifiers: [],\n loc: p.loc\n };\n }\n });\n }\n};\nconst parseInlineCSS = (cssText, loc) => {\n const normalized = shared.parseStringStyle(cssText);\n return compilerCore.createSimpleExpression(\n JSON.stringify(normalized),\n false,\n loc,\n 3\n );\n};\n\nfunction createDOMCompilerError(code, loc) {\n return compilerCore.createCompilerError(\n code,\n loc,\n DOMErrorMessages \n );\n}\nconst DOMErrorCodes = {\n \"X_V_HTML_NO_EXPRESSION\": 54,\n \"54\": \"X_V_HTML_NO_EXPRESSION\",\n \"X_V_HTML_WITH_CHILDREN\": 55,\n \"55\": \"X_V_HTML_WITH_CHILDREN\",\n \"X_V_TEXT_NO_EXPRESSION\": 56,\n \"56\": \"X_V_TEXT_NO_EXPRESSION\",\n \"X_V_TEXT_WITH_CHILDREN\": 57,\n \"57\": \"X_V_TEXT_WITH_CHILDREN\",\n \"X_V_MODEL_ON_INVALID_ELEMENT\": 58,\n \"58\": \"X_V_MODEL_ON_INVALID_ELEMENT\",\n \"X_V_MODEL_ARG_ON_ELEMENT\": 59,\n \"59\": \"X_V_MODEL_ARG_ON_ELEMENT\",\n \"X_V_MODEL_ON_FILE_INPUT_ELEMENT\": 60,\n \"60\": \"X_V_MODEL_ON_FILE_INPUT_ELEMENT\",\n \"X_V_MODEL_UNNECESSARY_VALUE\": 61,\n \"61\": \"X_V_MODEL_UNNECESSARY_VALUE\",\n \"X_V_SHOW_NO_EXPRESSION\": 62,\n \"62\": \"X_V_SHOW_NO_EXPRESSION\",\n \"X_TRANSITION_INVALID_CHILDREN\": 63,\n \"63\": \"X_TRANSITION_INVALID_CHILDREN\",\n \"X_IGNORED_SIDE_EFFECT_TAG\": 64,\n \"64\": \"X_IGNORED_SIDE_EFFECT_TAG\",\n \"__EXTEND_POINT__\": 65,\n \"65\": \"__EXTEND_POINT__\"\n};\nconst DOMErrorMessages = {\n [54]: `v-html is missing expression.`,\n [55]: `v-html will override element children.`,\n [56]: `v-text is missing expression.`,\n [57]: `v-text will override element children.`,\n [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,\n [59]: `v-model argument is not supported on plain elements.`,\n [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,\n [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,\n [62]: `v-show is missing expression.`,\n [63]: `<Transition> expects exactly one child element or component.`,\n [64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`\n};\n\nconst transformVHtml = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(54, loc)\n );\n }\n if (node.children.length) {\n context.onError(\n createDOMCompilerError(55, loc)\n );\n node.children.length = 0;\n }\n return {\n props: [\n compilerCore.createObjectProperty(\n compilerCore.createSimpleExpression(`innerHTML`, true, loc),\n exp || compilerCore.createSimpleExpression(\"\", true)\n )\n ]\n };\n};\n\nconst transformVText = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(56, loc)\n );\n }\n if (node.children.length) {\n context.onError(\n createDOMCompilerError(57, loc)\n );\n node.children.length = 0;\n }\n return {\n props: [\n compilerCore.createObjectProperty(\n compilerCore.createSimpleExpression(`textContent`, true),\n exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(\n context.helperString(compilerCore.TO_DISPLAY_STRING),\n [exp],\n loc\n ) : compilerCore.createSimpleExpression(\"\", true)\n )\n ]\n };\n};\n\nconst transformModel = (dir, node, context) => {\n const baseResult = compilerCore.transformModel(dir, node, context);\n if (!baseResult.props.length || node.tagType === 1) {\n return baseResult;\n }\n if (dir.arg) {\n context.onError(\n createDOMCompilerError(\n 59,\n dir.arg.loc\n )\n );\n }\n function checkDuplicatedValue() {\n const value = compilerCore.findDir(node, \"bind\");\n if (value && compilerCore.isStaticArgOf(value.arg, \"value\")) {\n context.onError(\n createDOMCompilerError(\n 61,\n value.loc\n )\n );\n }\n }\n const { tag } = node;\n const isCustomElement = context.isCustomElement(tag);\n if (tag === \"input\" || tag === \"textarea\" || tag === \"select\" || isCustomElement) {\n let directiveToUse = V_MODEL_TEXT;\n let isInvalidType = false;\n if (tag === \"input\" || isCustomElement) {\n const type = compilerCore.findProp(node, `type`);\n if (type) {\n if (type.type === 7) {\n directiveToUse = V_MODEL_DYNAMIC;\n } else if (type.value) {\n switch (type.value.content) {\n case \"radio\":\n directiveToUse = V_MODEL_RADIO;\n break;\n case \"checkbox\":\n directiveToUse = V_MODEL_CHECKBOX;\n break;\n case \"file\":\n isInvalidType = true;\n context.onError(\n createDOMCompilerError(\n 60,\n dir.loc\n )\n );\n break;\n default:\n checkDuplicatedValue();\n break;\n }\n }\n } else if (compilerCore.hasDynamicKeyVBind(node)) {\n directiveToUse = V_MODEL_DYNAMIC;\n } else {\n checkDuplicatedValue();\n }\n } else if (tag === \"select\") {\n directiveToUse = V_MODEL_SELECT;\n } else {\n checkDuplicatedValue();\n }\n if (!isInvalidType) {\n baseResult.needRuntime = context.helper(directiveToUse);\n }\n } else {\n context.onError(\n createDOMCompilerError(\n 58,\n dir.loc\n )\n );\n }\n baseResult.props = baseResult.props.filter(\n (p) => !(p.key.type === 4 && p.key.content === \"modelValue\")\n );\n return baseResult;\n};\n\nconst isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);\nconst isNonKeyModifier = /* @__PURE__ */ shared.makeMap(\n // event propagation management\n `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`\n);\nconst maybeKeyModifier = /* @__PURE__ */ shared.makeMap(\"left,right\");\nconst isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);\nconst resolveModifiers = (key, modifiers, context, loc) => {\n const keyModifiers = [];\n const nonKeyModifiers = [];\n const eventOptionModifiers = [];\n for (let i = 0; i < modifiers.length; i++) {\n const modifier = modifiers[i].content;\n if (modifier === \"native\" && compilerCore.checkCompatEnabled(\n \"COMPILER_V_ON_NATIVE\",\n context,\n loc\n )) {\n eventOptionModifiers.push(modifier);\n } else if (isEventOptionModifier(modifier)) {\n eventOptionModifiers.push(modifier);\n } else {\n if (maybeKeyModifier(modifier)) {\n if (compilerCore.isStaticExp(key)) {\n if (isKeyboardEvent(key.content.toLowerCase())) {\n keyModifiers.push(modifier);\n } else {\n nonKeyModifiers.push(modifier);\n }\n } else {\n keyModifiers.push(modifier);\n nonKeyModifiers.push(modifier);\n }\n } else {\n if (isNonKeyModifier(modifier)) {\n nonKeyModifiers.push(modifier);\n } else {\n keyModifiers.push(modifier);\n }\n }\n }\n }\n return {\n keyModifiers,\n nonKeyModifiers,\n eventOptionModifiers\n };\n};\nconst transformClick = (key, event) => {\n const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === \"onclick\";\n return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([\n `(`,\n key,\n `) === \"onClick\" ? \"${event}\" : (`,\n key,\n `)`\n ]) : key;\n};\nconst transformOn = (dir, node, context) => {\n return compilerCore.transformOn(dir, node, context, (baseResult) => {\n const { modifiers } = dir;\n if (!modifiers.length) return baseResult;\n let { key, value: handlerExp } = baseResult.props[0];\n const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);\n if (nonKeyModifiers.includes(\"right\")) {\n key = transformClick(key, `onContextmenu`);\n }\n if (nonKeyModifiers.includes(\"middle\")) {\n key = transformClick(key, `onMouseup`);\n }\n if (nonKeyModifiers.length) {\n handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [\n handlerExp,\n JSON.stringify(nonKeyModifiers)\n ]);\n }\n if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard\n (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {\n handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [\n handlerExp,\n JSON.stringify(keyModifiers)\n ]);\n }\n if (eventOptionModifiers.length) {\n const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join(\"\");\n key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + \"${modifierPostfix}\"`]);\n }\n return {\n props: [compilerCore.createObjectProperty(key, handlerExp)]\n };\n });\n};\n\nconst transformShow = (dir, node, context) => {\n const { exp, loc } = dir;\n if (!exp) {\n context.onError(\n createDOMCompilerError(62, loc)\n );\n }\n return {\n props: [],\n needRuntime: context.helper(V_SHOW)\n };\n};\n\nconst transformTransition = (node, context) => {\n if (node.type === 1 && node.tagType === 1) {\n const component = context.isBuiltInComponent(node.tag);\n if (component === TRANSITION) {\n return () => {\n if (!node.children.length) {\n return;\n }\n if (hasMultipleChildren(node)) {\n context.onError(\n createDOMCompilerError(\n 63,\n {\n start: node.children[0].loc.start,\n end: node.children[node.children.length - 1].loc.end,\n source: \"\"\n }\n )\n );\n }\n const child = node.children[0];\n if (child.type === 1) {\n for (const p of child.props) {\n if (p.type === 7 && p.name === \"show\") {\n node.props.push({\n type: 6,\n name: \"persisted\",\n nameLoc: node.loc,\n value: void 0,\n loc: node.loc\n });\n }\n }\n }\n };\n }\n }\n};\nfunction hasMultipleChildren(node) {\n const children = node.children = node.children.filter(\n (c) => !compilerCore.isCommentOrWhitespace(c)\n );\n const child = children[0];\n return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);\n}\n\nconst expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;\nconst stringifyStatic = (children, context, parent) => {\n if (context.scopes.vSlot > 0) {\n return;\n }\n const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;\n let nc = 0;\n let ec = 0;\n const currentChunk = [];\n const stringifyCurrentChunk = (currentIndex) => {\n if (nc >= 20 || ec >= 5) {\n const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [\n JSON.stringify(\n currentChunk.map((node) => stringifyNode(node, context)).join(\"\")\n ).replace(expReplaceRE, `\" + $1 + \"`),\n // the 2nd argument indicates the number of DOM nodes this static vnode\n // will insert / hydrate\n String(currentChunk.length)\n ]);\n const deleteCount = currentChunk.length - 1;\n if (isParentCached) {\n children.splice(\n currentIndex - currentChunk.length,\n currentChunk.length,\n // @ts-expect-error\n staticCall\n );\n } else {\n currentChunk[0].codegenNode.value = staticCall;\n if (currentChunk.length > 1) {\n children.splice(currentIndex - currentChunk.length + 1, deleteCount);\n const cacheIndex = context.cached.indexOf(\n currentChunk[currentChunk.length - 1].codegenNode\n );\n if (cacheIndex > -1) {\n for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {\n const c = context.cached[i2];\n if (c) c.index -= deleteCount;\n }\n context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);\n }\n }\n }\n return deleteCount;\n }\n return 0;\n };\n let i = 0;\n for (; i < children.length; i++) {\n const child = children[i];\n const isCached = isParentCached || getCachedNode(child);\n if (isCached) {\n const result = analyzeNode(child);\n if (result) {\n nc += result[0];\n ec += result[1];\n currentChunk.push(child);\n continue;\n }\n }\n i -= stringifyCurrentChunk(i);\n nc = 0;\n ec = 0;\n currentChunk.length = 0;\n }\n stringifyCurrentChunk(i);\n};\nconst getCachedNode = (node) => {\n if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {\n return node.codegenNode;\n }\n};\nconst dataAriaRE = /^(?:data|aria)-/;\nconst isStringifiableAttr = (name, ns) => {\n return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);\n};\nconst isNonStringifiable = /* @__PURE__ */ shared.makeMap(\n `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`\n);\nfunction analyzeNode(node) {\n if (node.type === 1 && isNonStringifiable(node.tag)) {\n return false;\n }\n if (node.type === 1 && compilerCore.findDir(node, \"once\", true)) {\n return false;\n }\n if (node.type === 12) {\n return [1, 0];\n }\n let nc = 1;\n let ec = node.props.length > 0 ? 1 : 0;\n let bailed = false;\n const bail = () => {\n bailed = true;\n return false;\n };\n function walk(node2) {\n const isOptionTag = node2.tag === \"option\" && node2.ns === 0;\n for (let i = 0; i < node2.props.length; i++) {\n const p = node2.props[i];\n if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {\n return bail();\n }\n if (p.type === 7 && p.name === \"bind\") {\n if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {\n return bail();\n }\n if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {\n return bail();\n }\n if (isOptionTag && compilerCore.isStaticArgOf(p.arg, \"value\") && p.exp && !p.exp.isStatic) {\n return bail();\n }\n }\n }\n for (let i = 0; i < node2.children.length; i++) {\n nc++;\n const child = node2.children[i];\n if (child.type === 1) {\n if (child.props.length > 0) {\n ec++;\n }\n walk(child);\n if (bailed) {\n return false;\n }\n }\n }\n return true;\n }\n return walk(node) ? [nc, ec] : false;\n}\nfunction stringifyNode(node, context) {\n if (shared.isString(node)) {\n return node;\n }\n if (shared.isSymbol(node)) {\n return ``;\n }\n switch (node.type) {\n case 1:\n return stringifyElement(node, context);\n case 2:\n return shared.escapeHtml(node.content);\n case 3:\n return `<!--${shared.escapeHtml(node.content)}-->`;\n case 5:\n return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));\n case 8:\n return shared.escapeHtml(evaluateConstant(node));\n case 12:\n return stringifyNode(node.content, context);\n default:\n return \"\";\n }\n}\nfunction stringifyElement(node, context) {\n let res = `<${node.tag}`;\n let innerHTML = \"\";\n for (let i = 0; i < node.props.length; i++) {\n const p = node.props[i];\n if (p.type === 6) {\n res += ` ${p.name}`;\n if (p.value) {\n res += `=\"${shared.escapeHtml(p.value.content)}\"`;\n }\n } else if (p.type === 7) {\n if (p.name === \"bind\") {\n const exp = p.exp;\n if (exp.content[0] === \"_\") {\n res += ` ${p.arg.content}=\"__VUE_EXP_START__${exp.content}__VUE_EXP_END__\"`;\n continue;\n }\n if (shared.isBooleanAttr(p.arg.content) && exp.content === \"false\") {\n continue;\n }\n let evaluated = evaluateConstant(exp);\n if (evaluated != null) {\n const arg = p.arg && p.arg.content;\n if (arg === \"class\") {\n evaluated = shared.normalizeClass(evaluated);\n } else if (arg === \"style\") {\n evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));\n }\n res += ` ${p.arg.content}=\"${shared.escapeHtml(\n evaluated\n )}\"`;\n }\n } else if (p.name === \"html\") {\n innerHTML = evaluateConstant(p.exp);\n } else if (p.name === \"text\") {\n innerHTML = shared.escapeHtml(\n shared.toDisplayString(evaluateConstant(p.exp))\n );\n }\n }\n }\n if (context.scopeId) {\n res += ` ${context.scopeId}`;\n }\n res += `>`;\n if (innerHTML) {\n res += innerHTML;\n } else {\n for (let i = 0; i < node.children.length; i++) {\n res += stringifyNode(node.children[i], context);\n }\n }\n if (!shared.isVoidTag(node.tag)) {\n res += `</${node.tag}>`;\n }\n return res;\n}\nfunction evaluateConstant(exp) {\n if (exp.type === 4) {\n return new Function(`return (${exp.content})`)();\n } else {\n let res = ``;\n exp.children.forEach((c) => {\n if (shared.isString(c) || shared.isSymbol(c)) {\n return;\n }\n if (c.type === 2) {\n res += c.content;\n } else if (c.type === 5) {\n res += shared.toDisplayString(evaluateConstant(c.content));\n } else {\n res += evaluateConstant(c);\n }\n });\n return res;\n }\n}\n\nconst ignoreSideEffectTags = (node, context) => {\n if (node.type === 1 && node.tagType === 0 && (node.tag === \"script\" || node.tag === \"style\")) {\n context.onError(\n createDOMCompilerError(\n 64,\n node.loc\n )\n );\n context.removeNode();\n }\n};\n\nfunction isValidHTMLNesting(parent, child) {\n if (parent === \"template\") {\n return true;\n }\n if (parent in onlyValidChildren) {\n return onlyValidChildren[parent].has(child);\n }\n if (child in onlyValidParents) {\n return onlyValidParents[child].has(parent);\n }\n if (parent in knownInvalidChildren) {\n if (knownInvalidChildren[parent].has(child)) return false;\n }\n if (child in knownInvalidParents) {\n if (knownInvalidParents[child].has(parent)) return false;\n }\n return true;\n}\nconst headings = /* @__PURE__ */ new Set([\"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\"]);\nconst emptySet = /* @__PURE__ */ new Set([]);\nconst onlyValidChildren = {\n head: /* @__PURE__ */ new Set([\n \"base\",\n \"basefront\",\n \"bgsound\",\n \"link\",\n \"meta\",\n \"title\",\n \"noscript\",\n \"noframes\",\n \"style\",\n \"script\",\n \"template\"\n ]),\n optgroup: /* @__PURE__ */ new Set([\"option\"]),\n select: /* @__PURE__ */ new Set([\"optgroup\", \"option\", \"hr\"]),\n // table\n table: /* @__PURE__ */ new Set([\"caption\", \"colgroup\", \"tbody\", \"tfoot\", \"thead\"]),\n tr: /* @__PURE__ */ new Set([\"td\", \"th\"]),\n colgroup: /* @__PURE__ */ new Set([\"col\"]),\n tbody: /* @__PURE__ */ new Set([\"tr\"]),\n thead: /* @__PURE__ */ new Set([\"tr\"]),\n tfoot: /* @__PURE__ */ new Set([\"tr\"]),\n // these elements can not have any children elements\n script: emptySet,\n iframe: emptySet,\n option: emptySet,\n textarea: emptySet,\n style: emptySet,\n title: emptySet\n};\nconst onlyValidParents = {\n // sections\n html: emptySet,\n body: /* @__PURE__ */ new Set([\"html\"]),\n head: /* @__PURE__ */ new Set([\"html\"]),\n // table\n td: /* @__PURE__ */ new Set([\"tr\"]),\n colgroup: /* @__PURE__ */ new Set([\"table\"]),\n caption: /* @__PURE__ */ new Set([\"table\"]),\n tbody: /* @__PURE__ */ new Set([\"table\"]),\n tfoot: /* @__PURE__ */ new Set([\"table\"]),\n col: /* @__PURE__ */ new Set([\"colgroup\"]),\n th: /* @__PURE__ */ new Set([\"tr\"]),\n thead: /* @__PURE__ */ new Set([\"table\"]),\n tr: /* @__PURE__ */ new Set([\"tbody\", \"thead\", \"tfoot\"]),\n // data list\n dd: /* @__PURE__ */ new Set([\"dl\", \"div\"]),\n dt: /* @__PURE__ */ new Set([\"dl\", \"div\"]),\n // other\n figcaption: /* @__PURE__ */ new Set([\"figure\"]),\n // li: new Set([\"ul\", \"ol\"]),\n summary: /* @__PURE__ */ new Set([\"details\"]),\n area: /* @__PURE__ */ new Set([\"map\"])\n};\nconst knownInvalidChildren = {\n p: /* @__PURE__ */ new Set([\n \"address\",\n \"article\",\n \"aside\",\n \"blockquote\",\n \"center\",\n \"details\",\n \"dialog\",\n \"dir\",\n \"div\",\n \"dl\",\n \"fieldset\",\n \"figure\",\n \"footer\",\n \"form\",\n \"h1\",\n \"h2\",\n \"h3\",\n \"h4\",\n \"h5\",\n \"h6\",\n \"header\",\n \"hgroup\",\n \"hr\",\n \"li\",\n \"main\",\n \"nav\",\n \"menu\",\n \"ol\",\n \"p\",\n \"pre\",\n \"section\",\n \"table\",\n \"ul\"\n ]),\n svg: /* @__PURE__ */ new Set([\n \"b\",\n \"blockquote\",\n \"br\",\n \"code\",\n \"dd\",\n \"div\",\n \"dl\",\n \"dt\",\n \"em\",\n \"embed\",\n \"h1\",\n \"h2\",\n \"h3\",\n \"h4\",\n \"h5\",\n \"h6\",\n \"hr\",\n \"i\",\n \"img\",\n \"li\",\n \"menu\",\n \"meta\",\n \"ol\",\n \"p\",\n \"pre\",\n \"ruby\",\n \"s\",\n \"small\",\n \"span\",\n \"strong\",\n \"sub\",\n \"sup\",\n \"table\",\n \"u\",\n \"ul\",\n \"var\"\n ])\n};\nconst knownInvalidParents = {\n a: /* @__PURE__ */ new Set([\"a\"]),\n button: /* @__PURE__ */ new Set([\"button\"]),\n dd: /* @__PURE__ */ new Set([\"dd\", \"dt\"]),\n dt: /* @__PURE__ */ new Set([\"dd\", \"dt\"]),\n form: /* @__PURE__ */ new Set([\"form\"]),\n li: /* @__PURE__ */ new Set([\"li\"]),\n h1: headings,\n h2: headings,\n h3: headings,\n h4: headings,\n h5: headings,\n h6: headings\n};\n\nconst validateHtmlNesting = (node, context) => {\n if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {\n const error = new SyntaxError(\n `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`\n );\n error.loc = node.loc;\n context.onWarn(error);\n }\n};\n\nconst DOMNodeTransforms = [\n transformStyle,\n ...[transformTransition, validateHtmlNesting] \n];\nconst DOMDirectiveTransforms = {\n cloak: compilerCore.noopDirectiveTransform,\n html: transformVHtml,\n text: transformVText,\n model: transformModel,\n // override compiler-core\n on: transformOn,\n // override compiler-core\n show: transformShow\n};\nfunction compile(src, options = {}) {\n return compilerCore.baseCompile(\n src,\n shared.extend({}, parserOptions, options, {\n nodeTransforms: [\n // ignore <script> and <tag>\n // this is not put inside DOMNodeTransforms because that list is used\n // by compiler-ssr to generate vnode fallback branches\n ignoreSideEffectTags,\n ...DOMNodeTransforms,\n ...options.nodeTransforms || []\n ],\n directiveTransforms: shared.extend(\n {},\n DOMDirectiveTransforms,\n options.directiveTransforms || {}\n ),\n transformHoist: stringifyStatic\n })\n );\n}\nfunction parse(template, options = {}) {\n return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));\n}\n\nexports.DOMDirectiveTransforms = DOMDirectiveTransforms;\nexports.DOMErrorCodes = DOMErrorCodes;\nexports.DOMErrorMessages = DOMErrorMessages;\nexports.DOMNodeTransforms = DOMNodeTransforms;\nexports.TRANSITION = TRANSITION;\nexports.TRANSITION_GROUP = TRANSITION_GROUP;\nexports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;\nexports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;\nexports.V_MODEL_RADIO = V_MODEL_RADIO;\nexports.V_MODEL_SELECT = V_MODEL_SELECT;\nexports.V_MODEL_TEXT = V_MODEL_TEXT;\nexports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;\nexports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;\nexports.V_SHOW = V_SHOW;\nexports.compile = compile;\nexports.createDOMCompilerError = createDOMCompilerError;\nexports.parse = parse;\nexports.parserOptions = parserOptions;\nexports.transformStyle = transformStyle;\nObject.keys(compilerCore).forEach(function (k) {\n if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];\n});\n"]} \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js b/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js new file mode 100644 index 0000000..0a43f00 --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js @@ -0,0 +1,357 @@ +module.exports = (function() { +var __MODS__ = {}; +var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; }; +var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; }; +var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } }; +var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; }; +__DEFINE__(1771034509111, function(require, module, exports) { +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = global || self, factory(global.estreeWalker = {})); +}(this, (function (exports) { + + // @ts-check + /** @typedef { import('estree').BaseNode} BaseNode */ + + /** @typedef {{ + skip: () => void; + remove: () => void; + replace: (node: BaseNode) => void; + }} WalkerContext */ + + class WalkerBase { + constructor() { + /** @type {boolean} */ + this.should_skip = false; + + /** @type {boolean} */ + this.should_remove = false; + + /** @type {BaseNode | null} */ + this.replacement = null; + + /** @type {WalkerContext} */ + this.context = { + skip: () => (this.should_skip = true), + remove: () => (this.should_remove = true), + replace: (node) => (this.replacement = node) + }; + } + + /** + * + * @param {any} parent + * @param {string} prop + * @param {number} index + * @param {BaseNode} node + */ + replace(parent, prop, index, node) { + if (parent) { + if (index !== null) { + parent[prop][index] = node; + } else { + parent[prop] = node; + } + } + } + + /** + * + * @param {any} parent + * @param {string} prop + * @param {number} index + */ + remove(parent, prop, index) { + if (parent) { + if (index !== null) { + parent[prop].splice(index, 1); + } else { + delete parent[prop]; + } + } + } + } + + // @ts-check + + /** @typedef { import('estree').BaseNode} BaseNode */ + /** @typedef { import('./walker.js').WalkerContext} WalkerContext */ + + /** @typedef {( + * this: WalkerContext, + * node: BaseNode, + * parent: BaseNode, + * key: string, + * index: number + * ) => void} SyncHandler */ + + class SyncWalker extends WalkerBase { + /** + * + * @param {SyncHandler} enter + * @param {SyncHandler} leave + */ + constructor(enter, leave) { + super(); + + /** @type {SyncHandler} */ + this.enter = enter; + + /** @type {SyncHandler} */ + this.leave = leave; + } + + /** + * + * @param {BaseNode} node + * @param {BaseNode} parent + * @param {string} [prop] + * @param {number} [index] + * @returns {BaseNode} + */ + visit(node, parent, prop, index) { + if (node) { + if (this.enter) { + const _should_skip = this.should_skip; + const _should_remove = this.should_remove; + const _replacement = this.replacement; + this.should_skip = false; + this.should_remove = false; + this.replacement = null; + + this.enter.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const skipped = this.should_skip; + const removed = this.should_remove; + + this.should_skip = _should_skip; + this.should_remove = _should_remove; + this.replacement = _replacement; + + if (skipped) return node; + if (removed) return null; + } + + for (const key in node) { + const value = node[key]; + + if (typeof value !== "object") { + continue; + } else if (Array.isArray(value)) { + for (let i = 0; i < value.length; i += 1) { + if (value[i] !== null && typeof value[i].type === 'string') { + if (!this.visit(value[i], node, key, i)) { + // removed + i--; + } + } + } + } else if (value !== null && typeof value.type === "string") { + this.visit(value, node, key, null); + } + } + + if (this.leave) { + const _replacement = this.replacement; + const _should_remove = this.should_remove; + this.replacement = null; + this.should_remove = false; + + this.leave.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const removed = this.should_remove; + + this.replacement = _replacement; + this.should_remove = _should_remove; + + if (removed) return null; + } + } + + return node; + } + } + + // @ts-check + + /** @typedef { import('estree').BaseNode} BaseNode */ + /** @typedef { import('./walker').WalkerContext} WalkerContext */ + + /** @typedef {( + * this: WalkerContext, + * node: BaseNode, + * parent: BaseNode, + * key: string, + * index: number + * ) => Promise<void>} AsyncHandler */ + + class AsyncWalker extends WalkerBase { + /** + * + * @param {AsyncHandler} enter + * @param {AsyncHandler} leave + */ + constructor(enter, leave) { + super(); + + /** @type {AsyncHandler} */ + this.enter = enter; + + /** @type {AsyncHandler} */ + this.leave = leave; + } + + /** + * + * @param {BaseNode} node + * @param {BaseNode} parent + * @param {string} [prop] + * @param {number} [index] + * @returns {Promise<BaseNode>} + */ + async visit(node, parent, prop, index) { + if (node) { + if (this.enter) { + const _should_skip = this.should_skip; + const _should_remove = this.should_remove; + const _replacement = this.replacement; + this.should_skip = false; + this.should_remove = false; + this.replacement = null; + + await this.enter.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const skipped = this.should_skip; + const removed = this.should_remove; + + this.should_skip = _should_skip; + this.should_remove = _should_remove; + this.replacement = _replacement; + + if (skipped) return node; + if (removed) return null; + } + + for (const key in node) { + const value = node[key]; + + if (typeof value !== "object") { + continue; + } else if (Array.isArray(value)) { + for (let i = 0; i < value.length; i += 1) { + if (value[i] !== null && typeof value[i].type === 'string') { + if (!(await this.visit(value[i], node, key, i))) { + // removed + i--; + } + } + } + } else if (value !== null && typeof value.type === "string") { + await this.visit(value, node, key, null); + } + } + + if (this.leave) { + const _replacement = this.replacement; + const _should_remove = this.should_remove; + this.replacement = null; + this.should_remove = false; + + await this.leave.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const removed = this.should_remove; + + this.replacement = _replacement; + this.should_remove = _should_remove; + + if (removed) return null; + } + } + + return node; + } + } + + // @ts-check + + /** @typedef { import('estree').BaseNode} BaseNode */ + /** @typedef { import('./sync.js').SyncHandler} SyncHandler */ + /** @typedef { import('./async.js').AsyncHandler} AsyncHandler */ + + /** + * + * @param {BaseNode} ast + * @param {{ + * enter?: SyncHandler + * leave?: SyncHandler + * }} walker + * @returns {BaseNode} + */ + function walk(ast, { enter, leave }) { + const instance = new SyncWalker(enter, leave); + return instance.visit(ast, null); + } + + /** + * + * @param {BaseNode} ast + * @param {{ + * enter?: AsyncHandler + * leave?: AsyncHandler + * }} walker + * @returns {Promise<BaseNode>} + */ + async function asyncWalk(ast, { enter, leave }) { + const instance = new AsyncWalker(enter, leave); + return await instance.visit(ast, null); + } + + exports.asyncWalk = asyncWalk; + exports.walk = walk; + + Object.defineProperty(exports, '__esModule', { value: true }); + +}))); + +}, function(modId) {var map = {}; return __REQUIRE__(map[modId], modId); }) +return __REQUIRE__(1771034509111); +})() +//miniprogram-npm-outsideDeps=[] +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js.map b/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js.map new file mode 100644 index 0000000..469e58b --- /dev/null +++ b/miniapp/miniprogram_npm/@vue/compiler-sfc/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["estree-walker.js"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"index.js","sourcesContent":["(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(global = global || self, factory(global.estreeWalker = {}));\n}(this, (function (exports) { \n\n\t// @ts-check\n\t/** @typedef { import('estree').BaseNode} BaseNode */\n\n\t/** @typedef {{\n\t\tskip: () => void;\n\t\tremove: () => void;\n\t\treplace: (node: BaseNode) => void;\n\t}} WalkerContext */\n\n\tclass WalkerBase {\n\t\tconstructor() {\n\t\t\t/** @type {boolean} */\n\t\t\tthis.should_skip = false;\n\n\t\t\t/** @type {boolean} */\n\t\t\tthis.should_remove = false;\n\n\t\t\t/** @type {BaseNode | null} */\n\t\t\tthis.replacement = null;\n\n\t\t\t/** @type {WalkerContext} */\n\t\t\tthis.context = {\n\t\t\t\tskip: () => (this.should_skip = true),\n\t\t\t\tremove: () => (this.should_remove = true),\n\t\t\t\treplace: (node) => (this.replacement = node)\n\t\t\t};\n\t\t}\n\n\t\t/**\n\t\t *\n\t\t * @param {any} parent\n\t\t * @param {string} prop\n\t\t * @param {number} index\n\t\t * @param {BaseNode} node\n\t\t */\n\t\treplace(parent, prop, index, node) {\n\t\t\tif (parent) {\n\t\t\t\tif (index !== null) {\n\t\t\t\t\tparent[prop][index] = node;\n\t\t\t\t} else {\n\t\t\t\t\tparent[prop] = node;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t *\n\t\t * @param {any} parent\n\t\t * @param {string} prop\n\t\t * @param {number} index\n\t\t */\n\t\tremove(parent, prop, index) {\n\t\t\tif (parent) {\n\t\t\t\tif (index !== null) {\n\t\t\t\t\tparent[prop].splice(index, 1);\n\t\t\t\t} else {\n\t\t\t\t\tdelete parent[prop];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// @ts-check\n\n\t/** @typedef { import('estree').BaseNode} BaseNode */\n\t/** @typedef { import('./walker.js').WalkerContext} WalkerContext */\n\n\t/** @typedef {(\n\t * this: WalkerContext,\n\t * node: BaseNode,\n\t * parent: BaseNode,\n\t * key: string,\n\t * index: number\n\t * ) => void} SyncHandler */\n\n\tclass SyncWalker extends WalkerBase {\n\t\t/**\n\t\t *\n\t\t * @param {SyncHandler} enter\n\t\t * @param {SyncHandler} leave\n\t\t */\n\t\tconstructor(enter, leave) {\n\t\t\tsuper();\n\n\t\t\t/** @type {SyncHandler} */\n\t\t\tthis.enter = enter;\n\n\t\t\t/** @type {SyncHandler} */\n\t\t\tthis.leave = leave;\n\t\t}\n\n\t\t/**\n\t\t *\n\t\t * @param {BaseNode} node\n\t\t * @param {BaseNode} parent\n\t\t * @param {string} [prop]\n\t\t * @param {number} [index]\n\t\t * @returns {BaseNode}\n\t\t */\n\t\tvisit(node, parent, prop, index) {\n\t\t\tif (node) {\n\t\t\t\tif (this.enter) {\n\t\t\t\t\tconst _should_skip = this.should_skip;\n\t\t\t\t\tconst _should_remove = this.should_remove;\n\t\t\t\t\tconst _replacement = this.replacement;\n\t\t\t\t\tthis.should_skip = false;\n\t\t\t\t\tthis.should_remove = false;\n\t\t\t\t\tthis.replacement = null;\n\n\t\t\t\t\tthis.enter.call(this.context, node, parent, prop, index);\n\n\t\t\t\t\tif (this.replacement) {\n\t\t\t\t\t\tnode = this.replacement;\n\t\t\t\t\t\tthis.replace(parent, prop, index, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (this.should_remove) {\n\t\t\t\t\t\tthis.remove(parent, prop, index);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst skipped = this.should_skip;\n\t\t\t\t\tconst removed = this.should_remove;\n\n\t\t\t\t\tthis.should_skip = _should_skip;\n\t\t\t\t\tthis.should_remove = _should_remove;\n\t\t\t\t\tthis.replacement = _replacement;\n\n\t\t\t\t\tif (skipped) return node;\n\t\t\t\t\tif (removed) return null;\n\t\t\t\t}\n\n\t\t\t\tfor (const key in node) {\n\t\t\t\t\tconst value = node[key];\n\n\t\t\t\t\tif (typeof value !== \"object\") {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (Array.isArray(value)) {\n\t\t\t\t\t\tfor (let i = 0; i < value.length; i += 1) {\n\t\t\t\t\t\t\tif (value[i] !== null && typeof value[i].type === 'string') {\n\t\t\t\t\t\t\t\tif (!this.visit(value[i], node, key, i)) {\n\t\t\t\t\t\t\t\t\t// removed\n\t\t\t\t\t\t\t\t\ti--;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (value !== null && typeof value.type === \"string\") {\n\t\t\t\t\t\tthis.visit(value, node, key, null);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (this.leave) {\n\t\t\t\t\tconst _replacement = this.replacement;\n\t\t\t\t\tconst _should_remove = this.should_remove;\n\t\t\t\t\tthis.replacement = null;\n\t\t\t\t\tthis.should_remove = false;\n\n\t\t\t\t\tthis.leave.call(this.context, node, parent, prop, index);\n\n\t\t\t\t\tif (this.replacement) {\n\t\t\t\t\t\tnode = this.replacement;\n\t\t\t\t\t\tthis.replace(parent, prop, index, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (this.should_remove) {\n\t\t\t\t\t\tthis.remove(parent, prop, index);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst removed = this.should_remove;\n\n\t\t\t\t\tthis.replacement = _replacement;\n\t\t\t\t\tthis.should_remove = _should_remove;\n\n\t\t\t\t\tif (removed) return null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn node;\n\t\t}\n\t}\n\n\t// @ts-check\n\n\t/** @typedef { import('estree').BaseNode} BaseNode */\n\t/** @typedef { import('./walker').WalkerContext} WalkerContext */\n\n\t/** @typedef {(\n\t * this: WalkerContext,\n\t * node: BaseNode,\n\t * parent: BaseNode,\n\t * key: string,\n\t * index: number\n\t * ) => Promise<void>} AsyncHandler */\n\n\tclass AsyncWalker extends WalkerBase {\n\t\t/**\n\t\t *\n\t\t * @param {AsyncHandler} enter\n\t\t * @param {AsyncHandler} leave\n\t\t */\n\t\tconstructor(enter, leave) {\n\t\t\tsuper();\n\n\t\t\t/** @type {AsyncHandler} */\n\t\t\tthis.enter = enter;\n\n\t\t\t/** @type {AsyncHandler} */\n\t\t\tthis.leave = leave;\n\t\t}\n\n\t\t/**\n\t\t *\n\t\t * @param {BaseNode} node\n\t\t * @param {BaseNode} parent\n\t\t * @param {string} [prop]\n\t\t * @param {number} [index]\n\t\t * @returns {Promise<BaseNode>}\n\t\t */\n\t\tasync visit(node, parent, prop, index) {\n\t\t\tif (node) {\n\t\t\t\tif (this.enter) {\n\t\t\t\t\tconst _should_skip = this.should_skip;\n\t\t\t\t\tconst _should_remove = this.should_remove;\n\t\t\t\t\tconst _replacement = this.replacement;\n\t\t\t\t\tthis.should_skip = false;\n\t\t\t\t\tthis.should_remove = false;\n\t\t\t\t\tthis.replacement = null;\n\n\t\t\t\t\tawait this.enter.call(this.context, node, parent, prop, index);\n\n\t\t\t\t\tif (this.replacement) {\n\t\t\t\t\t\tnode = this.replacement;\n\t\t\t\t\t\tthis.replace(parent, prop, index, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (this.should_remove) {\n\t\t\t\t\t\tthis.remove(parent, prop, index);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst skipped = this.should_skip;\n\t\t\t\t\tconst removed = this.should_remove;\n\n\t\t\t\t\tthis.should_skip = _should_skip;\n\t\t\t\t\tthis.should_remove = _should_remove;\n\t\t\t\t\tthis.replacement = _replacement;\n\n\t\t\t\t\tif (skipped) return node;\n\t\t\t\t\tif (removed) return null;\n\t\t\t\t}\n\n\t\t\t\tfor (const key in node) {\n\t\t\t\t\tconst value = node[key];\n\n\t\t\t\t\tif (typeof value !== \"object\") {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (Array.isArray(value)) {\n\t\t\t\t\t\tfor (let i = 0; i < value.length; i += 1) {\n\t\t\t\t\t\t\tif (value[i] !== null && typeof value[i].type === 'string') {\n\t\t\t\t\t\t\t\tif (!(await this.visit(value[i], node, key, i))) {\n\t\t\t\t\t\t\t\t\t// removed\n\t\t\t\t\t\t\t\t\ti--;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (value !== null && typeof value.type === \"string\") {\n\t\t\t\t\t\tawait this.visit(value, node, key, null);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (this.leave) {\n\t\t\t\t\tconst _replacement = this.replacement;\n\t\t\t\t\tconst _should_remove = this.should_remove;\n\t\t\t\t\tthis.replacement = null;\n\t\t\t\t\tthis.should_remove = false;\n\n\t\t\t\t\tawait this.leave.call(this.context, node, parent, prop, index);\n\n\t\t\t\t\tif (this.replacement) {\n\t\t\t\t\t\tnode = this.replacement;\n\t\t\t\t\t\tthis.replace(parent, prop, index, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (this.should_remove) {\n\t\t\t\t\t\tthis.remove(parent, prop, index);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst removed = this.should_remove;\n\n\t\t\t\t\tthis.replacement = _replacement;\n\t\t\t\t\tthis.should_remove = _should_remove;\n\n\t\t\t\t\tif (removed) return null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn node;\n\t\t}\n\t}\n\n\t// @ts-check\n\n\t/** @typedef { import('estree').BaseNode} BaseNode */\n\t/** @typedef { import('./sync.js').SyncHandler} SyncHandler */\n\t/** @typedef { import('./async.js').AsyncHandler} AsyncHandler */\n\n\t/**\n\t *\n\t * @param {BaseNode} ast\n\t * @param {{\n\t * enter?: SyncHandler\n\t * leave?: SyncHandler\n\t * }} walker\n\t * @returns {BaseNode}\n\t */\n\tfunction walk(ast, { enter, leave }) {\n\t\tconst instance = new SyncWalker(enter, leave);\n\t\treturn instance.visit(ast, null);\n\t}\n\n\t/**\n\t *\n\t * @param {BaseNode} ast\n\t * @param {{\n\t * enter?: AsyncHandler\n\t * leave?: AsyncHandler\n\t * }} walker\n\t * @returns {Promise<BaseNode>}\n\t */\n\tasync function asyncWalk(ast, { enter, leave }) {\n\t\tconst instance = new AsyncWalker(enter, leave);\n\t\treturn await instance.visit(ast, null);\n\t}\n\n\texports.asyncWalk = asyncWalk;\n\texports.walk = walk;\n\n\tObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 8707807..0b1877a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1158,7 +1158,6 @@ "integrity": "sha512-4z2nCSBfVIMnbuu8uinj+f0o4qOeggYJLbjpPHka3KH1om7e+H9yLKTYgksTaHcGco+NClhhY2vyO3HsMH1RGw==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "@typescript-eslint/scope-manager": "8.55.0", "@typescript-eslint/types": "8.55.0", @@ -1659,7 +1658,6 @@ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", - "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -2075,7 +2073,6 @@ "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", @@ -2957,7 +2954,6 @@ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "license": "MIT", - "peer": true, "engines": { "node": ">=12" }, @@ -3420,7 +3416,6 @@ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "devOptional": true, "license": "Apache-2.0", - "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -3459,7 +3454,6 @@ "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "esbuild": "^0.27.0", "fdir": "^6.5.0", @@ -3637,7 +3631,6 @@ "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.28.tgz", "integrity": "sha512-BRdrNfeoccSoIZeIhyPBfvWSLFP4q8J3u8Ju8Ug5vu3LdD+yTM13Sg4sKtljxozbnuMu1NB1X5HBHRYUzFocKg==", "license": "MIT", - "peer": true, "dependencies": { "@vue/compiler-dom": "3.5.28", "@vue/compiler-sfc": "3.5.28",