@shopify/create-app
Version:
A CLI tool to create a new Shopify app.
7,169 lines • 416 kB
JavaScript
import {
__esm,
init_cjs_shims
} from "./chunk-3XNI6LP4.js";
// ../../node_modules/.pnpm/prettier@3.8.4/node_modules/prettier/plugins/babel.mjs
function Ws(a2, t) {
if (a2 == null) return {};
var e = {};
for (var s in a2) if ({}.hasOwnProperty.call(a2, s)) {
if (t.indexOf(s) !== -1) continue;
e[s] = a2[s];
}
return e;
}
function D(a2, t) {
let { line: e, column: s, index: i } = a2;
return new R(e, s + t, i + t);
}
function Ot(a2, t, e) {
Object.defineProperty(a2, t, { enumerable: !1, configurable: !0, value: e });
}
function ti({ toMessage: a2, code: t, reasonCode: e, syntaxPlugin: s }) {
let i = e === "MissingPlugin" || e === "MissingOneOfPlugins";
return function r(n, o) {
let h = new SyntaxError();
return h.code = t, h.reasonCode = e, h.loc = n, h.pos = n.index, h.syntaxPlugin = s, i && (h.missingPlugin = o.missingPlugin), Ot(h, "clone", function(u = {}) {
let { line: f, column: d, index: x } = u.loc ?? n;
return r(new R(f, d, x), Object.assign({}, o, u.details));
}), Ot(h, "details", o), Object.defineProperty(h, "message", { configurable: !0, get() {
let l = `${a2(o)} (${n.line}:${n.column})`;
return this.message = l, l;
}, set(l) {
Object.defineProperty(this, "message", { value: l, writable: !0 });
} }), h;
};
}
function F(a2, t) {
if (Array.isArray(a2)) return (s) => F(s, a2[0]);
let e = {};
for (let s of Object.keys(a2)) {
let i = a2[s], r = typeof i == "string" ? { message: () => i } : typeof i == "function" ? { message: i } : i, { message: n } = r, o = Ws(r, ei), h = typeof n == "string" ? () => n : n;
e[s] = ti(Object.assign({ code: "BABEL_PARSER_SYNTAX_ERROR", reasonCode: s, toMessage: h }, t ? { syntaxPlugin: t } : {}, o));
}
return e;
}
function si() {
return { sourceType: "script", sourceFilename: void 0, startIndex: 0, startColumn: 0, startLine: 1, allowAwaitOutsideFunction: !1, allowReturnOutsideFunction: !1, allowNewTargetOutsideFunction: !1, allowImportExportEverywhere: !1, allowSuperOutsideMethod: !1, allowUndeclaredExports: !1, allowYieldOutsideFunction: !1, plugins: [], strictMode: void 0, ranges: !1, tokens: !1, createImportExpressions: !0, createParenthesizedExpressions: !1, errorRecovery: !1, attachComment: !0, annexB: !0 };
}
function ii(a2) {
let t = si();
if (a2 == null) return t;
if (a2.annexB != null && a2.annexB !== !1) throw new Error("The `annexB` option can only be set to `false`.");
for (let e of Object.keys(t)) a2[e] != null && (t[e] = a2[e]);
if (t.startLine === 1) a2.startIndex == null && t.startColumn > 0 ? t.startIndex = t.startColumn : a2.startColumn == null && t.startIndex > 0 && (t.startColumn = t.startIndex);
else if (a2.startColumn == null || a2.startIndex == null) throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
if (t.sourceType === "commonjs") {
if (a2.allowAwaitOutsideFunction != null) throw new Error("The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`.");
if (a2.allowReturnOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`.");
if (a2.allowNewTargetOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`.");
}
return t;
}
function ne(a2) {
return Ft(a2.loc.start, "index"), Ft(a2.loc.end, "index"), a2;
}
function S(a2, t = {}) {
t.keyword = a2;
let e = P(a2, t);
return ft.set(a2, e), e;
}
function v(a2, t) {
return P(a2, { beforeExpr: T, binop: t });
}
function P(a2, t = {}) {
return ++pe, mt.push(a2), yt.push(t.binop ?? -1), xt.push(t.beforeExpr ?? !1), Pt.push(t.startsExpr ?? !1), gt.push(t.prefix ?? !1), dt.push(new we(a2, t)), pe;
}
function b(a2, t = {}) {
return ++pe, ft.set(a2, pe), mt.push(a2), yt.push(t.binop ?? -1), xt.push(t.beforeExpr ?? !1), Pt.push(t.startsExpr ?? !1), gt.push(t.prefix ?? !1), dt.push(new we("name", t)), pe;
}
function w(a2) {
return a2 >= 93 && a2 <= 133;
}
function hi(a2) {
return a2 <= 92;
}
function O(a2) {
return a2 >= 58 && a2 <= 133;
}
function Jt(a2) {
return a2 >= 58 && a2 <= 137;
}
function ci(a2) {
return xt[a2];
}
function ce(a2) {
return Pt[a2];
}
function li(a2) {
return a2 >= 29 && a2 <= 33;
}
function Bt(a2) {
return a2 >= 129 && a2 <= 131;
}
function pi(a2) {
return a2 >= 90 && a2 <= 92;
}
function Tt(a2) {
return a2 >= 58 && a2 <= 92;
}
function ui(a2) {
return a2 >= 39 && a2 <= 59;
}
function fi(a2) {
return a2 === 34;
}
function di(a2) {
return gt[a2];
}
function mi(a2) {
return a2 >= 121 && a2 <= 123;
}
function yi(a2) {
return a2 >= 124 && a2 <= 130;
}
function z(a2) {
return mt[a2];
}
function Ae(a2) {
return yt[a2];
}
function xi(a2) {
return a2 === 57;
}
function $e(a2) {
return a2 >= 24 && a2 <= 25;
}
function Gt(a2) {
return dt[a2];
}
function Ke(a2, t) {
let e = 65536;
for (let s = 0, i = t.length; s < i; s += 2) {
if (e += t[s], e > a2) return !1;
if (e += t[s + 1], e >= a2) return !0;
}
return !1;
}
function B(a2) {
return a2 < 65 ? a2 === 36 : a2 <= 90 ? !0 : a2 < 97 ? a2 === 95 : a2 <= 122 ? !0 : a2 <= 65535 ? a2 >= 170 && Pi.test(String.fromCharCode(a2)) : Ke(a2, Yt);
}
function K(a2) {
return a2 < 48 ? a2 === 36 : a2 < 58 ? !0 : a2 < 65 ? !1 : a2 <= 90 ? !0 : a2 < 97 ? a2 === 95 : a2 <= 122 ? !0 : a2 <= 65535 ? a2 >= 170 && gi.test(String.fromCharCode(a2)) : Ke(a2, Yt) || Ke(a2, Ti);
}
function Qt(a2, t) {
return t && a2 === "await" || a2 === "enum";
}
function Zt(a2, t) {
return Qt(a2, t) || Ai.has(a2);
}
function es(a2) {
return Si.has(a2);
}
function ts(a2, t) {
return Zt(a2, t) || es(a2);
}
function wi(a2) {
return bi.has(a2);
}
function Ci(a2, t, e) {
return a2 === 64 && t === 64 && B(e);
}
function Ii(a2) {
return Ei.has(a2);
}
function ki(a2) {
return a2.type === "DeclareExportAllDeclaration" || a2.type === "DeclareExportDeclaration" && (!a2.declaration || a2.declaration.type !== "TypeAlias" && a2.declaration.type !== "InterfaceDeclaration");
}
function Rt(a2) {
return a2.importKind === "type" || a2.importKind === "typeof";
}
function Li(a2, t) {
let e = [], s = [];
for (let i = 0; i < a2.length; i++) (t(a2[i], i, a2) ? e : s).push(a2[i]);
return [e, s];
}
function G(a2) {
switch (a2) {
case 10:
case 13:
case 8232:
case 8233:
return !0;
default:
return !1;
}
}
function Ut(a2, t, e) {
for (let s = t; s < e; s++) if (G(a2.charCodeAt(s))) return !0;
return !1;
}
function Fi(a2) {
switch (a2) {
case 9:
case 11:
case 12:
case 32:
case 160:
case 5760:
case 8192:
case 8193:
case 8194:
case 8195:
case 8196:
case 8197:
case 8198:
case 8199:
case 8200:
case 8201:
case 8202:
case 8239:
case 8287:
case 12288:
case 65279:
return !0;
default:
return !1;
}
}
function V(a2) {
return a2 ? a2.type === "JSXOpeningFragment" || a2.type === "JSXClosingFragment" : !1;
}
function J(a2) {
if (a2.type === "JSXIdentifier") return a2.name;
if (a2.type === "JSXNamespacedName") return a2.namespace.name + ":" + a2.name.name;
if (a2.type === "JSXMemberExpression") return J(a2.object) + "." + J(a2.property);
throw new Error("Node had unexpected type: " + a2.type);
}
function Se(a2, t) {
return (a2 ? 2 : 0) | (t ? 1 : 0);
}
function ss(a2, t) {
a2.trailingComments === void 0 ? a2.trailingComments = t : a2.trailingComments.unshift(...t);
}
function Ri(a2, t) {
a2.leadingComments === void 0 ? a2.leadingComments = t : a2.leadingComments.unshift(...t);
}
function X(a2, t) {
a2.innerComments === void 0 ? a2.innerComments = t : a2.innerComments.unshift(...t);
}
function $(a2, t, e) {
let s = null, i = t.length;
for (; s === null && i > 0; ) s = t[--i];
s === null || s.start > e.start ? X(a2, e.comments) : ss(s, e.comments);
}
function jt(a2, t, e, s, i, r) {
let n = e, o = s, h = i, l = "", u = null, f = e, { length: d } = t;
for (; ; ) {
if (e >= d) {
r.unterminated(n, o, h), l += t.slice(f, e);
break;
}
let x = t.charCodeAt(e);
if (_i(a2, x, t, e)) {
l += t.slice(f, e);
break;
}
if (x === 92) {
l += t.slice(f, e);
let A = ji(t, e, s, i, a2 === "template", r);
A.ch === null && !u ? u = { pos: e, lineStart: s, curLine: i } : l += A.ch, { pos: e, lineStart: s, curLine: i } = A, f = e;
} else x === 8232 || x === 8233 ? (++e, ++i, s = e) : x === 10 || x === 13 ? a2 === "template" ? (l += t.slice(f, e) + `
`, ++e, x === 13 && t.charCodeAt(e) === 10 && ++e, ++i, f = s = e) : r.unterminated(n, o, h) : ++e;
}
return { pos: e, str: l, firstInvalidLoc: u, lineStart: s, curLine: i };
}
function _i(a2, t, e, s) {
return a2 === "template" ? t === 96 || t === 36 && e.charCodeAt(s + 1) === 123 : t === (a2 === "double" ? 34 : 39);
}
function ji(a2, t, e, s, i, r) {
let n = !i;
t++;
let o = (l) => ({ pos: t, ch: l, lineStart: e, curLine: s }), h = a2.charCodeAt(t++);
switch (h) {
case 110:
return o(`
`);
case 114:
return o("\r");
case 120: {
let l;
return { code: l, pos: t } = et(a2, t, e, s, 2, !1, n, r), o(l === null ? null : String.fromCharCode(l));
}
case 117: {
let l;
return { code: l, pos: t } = rs(a2, t, e, s, n, r), o(l === null ? null : String.fromCodePoint(l));
}
case 116:
return o(" ");
case 98:
return o("\b");
case 118:
return o("\v");
case 102:
return o("\f");
case 13:
a2.charCodeAt(t) === 10 && ++t;
case 10:
e = t, ++s;
case 8232:
case 8233:
return o("");
case 56:
case 57:
if (i) return o(null);
r.strictNumericEscape(t - 1, e, s);
default:
if (h >= 48 && h <= 55) {
let l = t - 1, f = /^[0-7]+/.exec(a2.slice(l, t + 2))[0], d = parseInt(f, 8);
d > 255 && (f = f.slice(0, -1), d = parseInt(f, 8)), t += f.length - 1;
let x = a2.charCodeAt(t);
if (f !== "0" || x === 56 || x === 57) {
if (i) return o(null);
r.strictNumericEscape(l, e, s);
}
return o(String.fromCharCode(d));
}
return o(String.fromCharCode(h));
}
}
function et(a2, t, e, s, i, r, n, o) {
let h = t, l;
return { n: l, pos: t } = is(a2, t, e, s, 16, i, r, !1, o, !n), l === null && (n ? o.invalidEscapeSequence(h, e, s) : t = h - 1), { code: l, pos: t };
}
function is(a2, t, e, s, i, r, n, o, h, l) {
let u = t, f = i === 16 ? _t.hex : _t.decBinOct, d = i === 16 ? Te.hex : i === 10 ? Te.dec : i === 8 ? Te.oct : Te.bin, x = !1, A = 0;
for (let k = 0, N = r ?? 1 / 0; k < N; ++k) {
let C = a2.charCodeAt(t), I;
if (C === 95 && o !== "bail") {
let Pe = a2.charCodeAt(t - 1), ae = a2.charCodeAt(t + 1);
if (o) {
if (Number.isNaN(ae) || !d(ae) || f.has(Pe) || f.has(ae)) {
if (l) return { n: null, pos: t };
h.unexpectedNumericSeparator(t, e, s);
}
} else {
if (l) return { n: null, pos: t };
h.numericSeparatorInEscapeSequence(t, e, s);
}
++t;
continue;
}
if (C >= 97 ? I = C - 97 + 10 : C >= 65 ? I = C - 65 + 10 : Ui(C) ? I = C - 48 : I = 1 / 0, I >= i) {
if (I <= 9 && l) return { n: null, pos: t };
if (I <= 9 && h.invalidDigit(t, e, s, i)) I = 0;
else if (n) I = 0, x = !0;
else break;
}
++t, A = A * i + I;
}
return t === u || r != null && t - u !== r || x ? { n: null, pos: t } : { n: A, pos: t };
}
function rs(a2, t, e, s, i, r) {
let n = a2.charCodeAt(t), o;
if (n === 123) {
if (++t, { code: o, pos: t } = et(a2, t, e, s, a2.indexOf("}", t) - t, !0, i, r), ++t, o !== null && o > 1114111) if (i) r.invalidCodePoint(t, e, s);
else return { code: null, pos: t };
} else ({ code: o, pos: t } = et(a2, t, e, s, 4, !1, i, r));
return { code: o, pos: t };
}
function he(a2, t, e) {
return new R(e, a2 - t, a2);
}
function zi() {
return new Z(3);
}
function qi() {
return new Ce(1);
}
function $i() {
return new Ce(2);
}
function as() {
return new Z();
}
function Ki(a2) {
if (a2 == null) throw new Error(`Unexpected ${a2} value.`);
return a2;
}
function zt(a2) {
if (!a2) throw new Error("Assert fail");
}
function Hi(a2) {
switch (a2) {
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;
}
}
function qt(a2) {
return a2 === "private" || a2 === "public" || a2 === "protected";
}
function Wi(a2) {
return a2 === "in" || a2 === "out";
}
function lt(a2) {
if (a2.extra?.parenthesized) return !1;
switch (a2.type) {
case "Identifier":
return !0;
case "MemberExpression":
return !a2.computed && lt(a2.object);
case "TSInstantiationExpression":
return lt(a2.expression);
default:
return !1;
}
}
function Gi(a2) {
if (a2.type !== "MemberExpression") return !1;
let { computed: t, property: e } = a2;
return t && e.type !== "StringLiteral" && (e.type !== "TemplateLiteral" || e.expressions.length > 0) ? !1 : os(a2.object);
}
function Xi(a2, t) {
let { type: e } = a2;
if (a2.extra?.parenthesized) return !1;
if (t) {
if (e === "Literal") {
let { value: s } = a2;
if (typeof s == "string" || typeof s == "boolean") return !0;
}
} else if (e === "StringLiteral" || e === "BooleanLiteral") return !0;
return !!(ns(a2, t) || Yi(a2, t) || e === "TemplateLiteral" && a2.expressions.length === 0 || Gi(a2));
}
function ns(a2, t) {
return t ? a2.type === "Literal" && (typeof a2.value == "number" || "bigint" in a2) : a2.type === "NumericLiteral" || a2.type === "BigIntLiteral";
}
function Yi(a2, t) {
if (a2.type === "UnaryExpression") {
let { operator: e, argument: s } = a2;
if (e === "-" && ns(s, t)) return !0;
}
return !1;
}
function os(a2) {
return a2.type === "Identifier" ? !0 : a2.type !== "MemberExpression" || a2.computed ? !1 : os(a2.object);
}
function er(a2) {
if (a2.has("decorators")) {
if (a2.has("decorators-legacy")) throw new Error("Cannot use the decorators and decorators-legacy plugin together");
let t = a2.get("decorators").decoratorsBeforeExport;
if (t != null && typeof t != "boolean") throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
let e = a2.get("decorators").allowCallParenthesized;
if (e != null && typeof e != "boolean") throw new Error("'allowCallParenthesized' must be a boolean.");
}
if (a2.has("flow") && a2.has("typescript")) throw new Error("Cannot combine flow and typescript plugins.");
if (a2.has("placeholders") && a2.has("v8intrinsic")) throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
if (a2.has("pipelineOperator")) {
let t = a2.get("pipelineOperator").proposal;
if (!Kt.includes(t)) {
let e = Kt.map((s) => `"${s}"`).join(", ");
throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${e}.`);
}
if (t === "hack") {
if (a2.has("placeholders")) throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
if (a2.has("v8intrinsic")) throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
let e = a2.get("pipelineOperator").topicToken;
if (!Ht.includes(e)) {
let s = Ht.map((i) => `"${i}"`).join(", ");
throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${s}.`);
}
}
}
if (a2.has("moduleAttributes")) throw new Error("`moduleAttributes` has been removed in Babel 8, please migrate to import attributes instead.");
if (a2.has("importAssertions")) throw new Error("`importAssertions` has been removed in Babel 8, please use import attributes instead. To use the non-standard `assert` syntax you can enable the `deprecatedImportAssert` parser plugin.");
if (!a2.has("deprecatedImportAssert") && a2.has("importAttributes") && a2.get("importAttributes").deprecatedAssertSyntax) throw new Error("The 'importAttributes' plugin has been removed in Babel 8. If you need to enable support for the deprecated `assert` syntax, you can enable the `deprecatedImportAssert` parser plugin.");
if (a2.has("recordAndTuple")) throw new Error("The 'recordAndTuple' plugin has been removed in Babel 8. Please remove it from your configuration.");
if (a2.has("asyncDoExpressions") && !a2.has("doExpressions")) {
let t = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
throw t.missingPlugins = "doExpressions", t;
}
if (a2.has("optionalChainingAssign") && a2.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 (a2.has("discardBinding") && a2.get("discardBinding").syntaxType !== "void") throw new Error("The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'.");
{
if (a2.has("decimal")) throw new Error("The 'decimal' plugin has been removed in Babel 8. Please remove it from your configuration.");
if (a2.has("importReflection")) throw new Error("The 'importReflection' plugin has been removed in Babel 8. Use 'sourcePhaseImports' instead, and replace 'import module' with 'import source' in your code.");
}
}
function rr(a2, t, e) {
for (let s = 0; s < a2.length; s++) {
let i = a2[s], { type: r } = i;
typeof r == "number" && (i.type = Gt(r));
}
return a2;
}
function Ie(a2, t) {
if (t?.sourceType === "unambiguous") {
t = Object.assign({}, t);
try {
t.sourceType = "module";
let e = le(t, a2), s = e.parse();
if (e.sawUnambiguousESM) return s;
if (e.ambiguousScriptDifferentAst) try {
return t.sourceType = "script", le(t, a2).parse();
} catch {
}
else s.program.sourceType = "script";
return s;
} catch (e) {
try {
return t.sourceType = "script", le(t, a2).parse();
} catch {
}
throw e;
}
} else return le(t, a2).parse();
}
function Ne(a2, t) {
let e = le(t, a2);
return e.options.strictMode && (e.state.strict = !0), e.getExpression();
}
function ar(a2) {
let t = {};
for (let e of Object.keys(a2)) t[e] = Gt(a2[e]);
return t;
}
function le(a2, t) {
let e = Ee, s = /* @__PURE__ */ new Map();
if (a2?.plugins) {
for (let i of a2.plugins) {
let r, n;
typeof i == "string" ? r = i : [r, n] = i, s.has(r) || s.set(r, n || {});
}
er(s), e = nr(s);
}
return new e(a2, t, s);
}
function nr(a2) {
let t = [];
for (let i of tr) a2.has(i) && t.push(i);
let e = t.join("|"), s = Wt.get(e);
if (!s) {
s = Ee;
for (let i of t) s = hs[i](s);
Wt.set(e, s);
}
return s;
}
function ke(a2) {
return (t, e, s) => {
let i = !!s?.backwards;
if (e === !1) return !1;
let { length: r } = t, n = e;
for (; n >= 0 && n < r; ) {
let o = t.charAt(n);
if (a2 instanceof RegExp) {
if (!a2.test(o)) return n;
} else if (!a2.includes(o)) return n;
i ? n-- : n++;
}
return n === -1 || n === r ? n : !1;
};
}
function or(a2, t) {
if (t === !1) return !1;
if (a2.charAt(t) === "/" && a2.charAt(t + 1) === "*") {
for (let e = t + 2; e < a2.length; ++e) if (a2.charAt(e) === "*" && a2.charAt(e + 1) === "/") return e + 2;
}
return t;
}
function hr(a2, t, e) {
let s = !!e?.backwards;
if (t === !1) return !1;
let i = a2.charAt(t);
if (s) {
if (a2.charAt(t - 1) === "\r" && i === `
`) return t - 2;
if (us(i)) return t - 1;
} else {
if (i === "\r" && a2.charAt(t + 1) === `
`) return t + 2;
if (us(i)) return t + 1;
}
return t;
}
function cr(a2, t) {
return t === !1 ? !1 : a2.charAt(t) === "/" && a2.charAt(t + 1) === "/" ? ls(a2, t) : t;
}
function lr(a2, t) {
let e = null, s = t;
for (; s !== e; ) e = s, s = cs(a2, s), s = ps(a2, s), s = ds(a2, s), s = fs(a2, s);
return s;
}
function ys(a2) {
let t = [];
for (let e of a2) try {
return e();
} catch (s) {
t.push(s);
}
throw Object.assign(new Error("All combinations failed"), { errors: t });
}
function pr(a2) {
if (!a2.startsWith("#!")) return "";
let t = a2.indexOf(`
`);
return t === -1 ? a2 : a2.slice(0, t);
}
function dr(a2) {
return this[a2 < 0 ? this.length + a2 : a2];
}
function M(a2) {
let t = a2.range?.[0] ?? a2.start, e = (a2.declaration?.decorators ?? a2.decorators)?.[0];
return e ? Math.min(M(e), t) : t;
}
function L(a2) {
return a2.range?.[1] ?? a2.end;
}
function yr(a2) {
let t = new Set(a2);
return (e) => t.has(e?.type);
}
function gr(a2) {
return St.has(a2) || St.set(a2, se(a2) && a2.value[0] === "*" && /@(?:type|satisfies)\b/u.test(a2.value)), St.get(a2);
}
function Tr(a2) {
if (!se(a2)) return !1;
let t = `*${a2.value}*`.split(`
`);
return t.length > 1 && t.every((e) => e.trimStart()[0] === "*");
}
function br(a2) {
return wt.has(a2) || wt.set(a2, Tr(a2)), wt.get(a2);
}
function Ar(a2) {
if (a2.length < 2) return;
let t;
for (let e = a2.length - 1; e >= 0; e--) {
let s = a2[e];
if (t && L(s) === M(t) && Ct(s) && Ct(t) && (a2.splice(e + 1, 1), s.value += "*//*" + t.value, s.range = [M(s), L(t)]), !gs(s) && !se(s)) throw new TypeError(`Unknown comment type: "${s.type}".`);
t = s;
}
}
function Sr(a2) {
return a2 !== null && typeof a2 == "object";
}
function ye(a2) {
if (me !== null && typeof me.property) {
let t = me;
return me = ye.prototype = null, t;
}
return me = ye.prototype = a2 ?? /* @__PURE__ */ Object.create(null), new ye();
}
function Et(a2) {
return ye(a2);
}
function Cr(a2, t = "type") {
Et(a2);
function e(s) {
let i = s[t], r = a2[i];
if (!Array.isArray(r)) throw Object.assign(new Error(`Missing visitor keys for '${i}'.`), { node: s });
return r;
}
return e;
}
function Le(a2, t) {
if (!As(a2)) return a2;
if (Array.isArray(a2)) {
for (let s = 0; s < a2.length; s++) a2[s] = Le(a2[s], t);
return a2;
}
if (t.onEnter) {
let s = t.onEnter(a2) ?? a2;
if (s !== a2) return Le(s, t);
a2 = s;
}
let e = Cs(a2);
for (let s = 0; s < e.length; s++) a2[e[s]] = Le(a2[e[s]], t);
return t.onLeave && (a2 = t.onLeave(a2) || a2), a2;
}
function Ir(a2, t) {
let { parser: e, text: s } = t, { comments: i } = a2, r = e === "oxc" && t.oxcAstType === "ts";
bs(i);
let n = a2.type === "File" ? a2.program : a2;
n.interpreter && (i.unshift(n.interpreter), delete n.interpreter), r && a2.hashbang && (i.unshift(a2.hashbang), delete a2.hashbang), a2.type === "Program" && (a2.range = [0, s.length]);
let o;
return a2 = Es(a2, { onEnter(h) {
switch (h.type) {
case "ParenthesizedExpression": {
let { expression: l } = h, u = M(h);
if (l.type === "TypeCastExpression") return l.range = [u, L(h)], l;
let f = !1;
if (!r) {
if (!o) {
o = [];
for (let x of i) Ts(x) && o.push(L(x));
}
let d = xs(0, o, (x) => x <= u);
f = d && s.slice(d, u).trim().length === 0;
}
return f ? void 0 : (l.extra = { ...l.extra, parenthesized: !0 }, l);
}
case "TemplateLiteral":
if (h.expressions.length !== h.quasis.length - 1) throw new Error("Malformed template literal.");
break;
case "TemplateElement":
if (e === "flow" || e === "hermes" || e === "espree" || e === "typescript" || r) {
let l = M(h) + 1, u = L(h) - (h.tail ? 1 : 2);
h.range = [l, u];
}
break;
case "VariableDeclaration": {
let l = Ps(0, h.declarations, -1);
l?.init && s[L(l)] !== ";" && (h.range = [M(h), L(l)]);
break;
}
case "TSParenthesizedType":
return h.typeAnnotation;
case "TopicReference":
a2.extra = { ...a2.extra, __isUsingHackPipeline: !0 };
break;
case "TSUnionType":
case "TSIntersectionType":
if (h.types.length === 1) return h.types[0];
break;
case "ImportExpression":
e === "hermes" && h.attributes && !h.options && (h.options = h.attributes);
break;
}
}, onLeave(h) {
switch (h.type) {
case "LogicalExpression":
if (Is(h)) return It(h);
break;
case "TSImportType":
!h.source && h.argument.type === "TSLiteralType" && (h.source = h.argument.literal, delete h.argument);
break;
}
} }), a2;
}
function Is(a2) {
return a2.type === "LogicalExpression" && a2.right.type === "LogicalExpression" && a2.operator === a2.right.operator;
}
function It(a2) {
return Is(a2) ? It({ type: "LogicalExpression", operator: a2.operator, left: It({ type: "LogicalExpression", operator: a2.operator, left: a2.left, right: a2.right.left, range: [M(a2.left), L(a2.right.left)] }), right: a2.right.right, range: [M(a2), L(a2)] }) : a2;
}
function Nr(a2, t) {
let e = new SyntaxError(a2 + " (" + t.loc.start.line + ":" + t.loc.start.column + ")");
return Object.assign(e, t);
}
function kr(a2) {
let { message: t, loc: e, reasonCode: s } = a2;
if (!e) return a2;
let { line: i, column: r } = e, n = a2;
(s === "MissingPlugin" || s === "MissingOneOfPlugins") && (t = "Unexpected token.", n = void 0);
let o = ` (${i}:${r})`;
return t.endsWith(o) && (t = t.slice(0, -o.length)), t.startsWith(ks) && (t = t.slice(ks.length)), De(t, { loc: { start: { line: i, column: r + 1 } }, cause: n });
}
function Ds(a2) {
let t = a2.match(Or);
return t ? t[0].trimStart() : "";
}
function Ms(a2) {
a2 = xe(0, a2.replace(Mr, "").replace(Dr, ""), Rr, "$1");
let e = "";
for (; e !== a2; ) e = a2, a2 = xe(0, a2, Br, `
$1 $2
`);
a2 = a2.replace(vs, "").trimEnd();
let s = /* @__PURE__ */ Object.create(null), i = xe(0, a2, Ls, "").replace(vs, "").trimEnd(), r;
for (; r = Ls.exec(a2); ) {
let n = xe(0, r[2], Fr, "");
if (typeof s[r[1]] == "string" || Array.isArray(s[r[1]])) {
let o = s[r[1]];
s[r[1]] = [...Ur, ...Array.isArray(o) ? o : [o], n];
} else s[r[1]] = n;
}
return { comments: i, pragmas: s };
}
function Bs(a2) {
let t = ve(a2);
t && (a2 = a2.slice(t.length + 1));
let e = Ds(a2), { pragmas: s, comments: i } = Ms(e);
return { shebang: t, text: a2, pragmas: s, comments: i };
}
function Rs(a2) {
let { pragmas: t } = Bs(a2);
return Fs.some((e) => Object.prototype.hasOwnProperty.call(t, e));
}
function Us(a2) {
let { pragmas: t } = Bs(a2);
return Os.some((e) => Object.prototype.hasOwnProperty.call(t, e));
}
function _r(a2) {
return a2 = typeof a2 == "function" ? { parse: a2 } : a2, { astFormat: "estree", hasPragma: Rs, hasIgnorePragma: Us, locStart: M, locEnd: L, ...a2 };
}
function _s(a2) {
if (typeof a2 == "string") {
if (a2 = a2.toLowerCase(), /\.(?:mjs|mts)$/iu.test(a2)) return Oe;
if (/\.(?:cjs|cts)$/iu.test(a2)) return Nt;
}
}
function jr(a2, t) {
let { type: e = "JsExpressionRoot", rootMarker: s, text: i } = t, { tokens: r, comments: n } = a2;
return delete a2.tokens, delete a2.comments, { tokens: r, comments: n, type: e, node: a2, range: [0, i.length], rootMarker: s };
}
function qr(a2, t) {
if (t?.endsWith(".js.flow")) return !0;
let e = ve(a2);
e && (a2 = a2.slice(e.length));
let s = ms(a2, 0);
return s !== !1 && (a2 = a2.slice(0, s)), zr.test(a2);
}
function $r(a2, t, e) {
let s = a2(t, e), i = s.errors.find((r) => !Hr.has(r.reasonCode));
if (i) throw i;
return s;
}
function Kr({ isExpression: a2 = !1, optionsCombinations: t }) {
return (e, s = {}) => {
let { filepath: i } = s;
if (typeof i != "string" && (i = void 0), (s.parser === "babel" || s.parser === "__babel_estree") && qr(e, i)) return s.parser = "babel-flow", qs.parse(e, s);
let r = t, n = s.__babelSourceType ?? _s(i);
n && n !== Oe && (r = r.map((u) => ({ ...u, sourceType: n, ...n === Nt ? { allowReturnOutsideFunction: void 0, allowNewTargetOutsideFunction: void 0 } : void 0 })));
let o = /%[A-Z]/u.test(e);
e.includes("|>") ? r = (o ? [...Vs, js] : Vs).flatMap((f) => r.map((d) => _([f], d))) : o && (r = r.map((u) => _([js], u)));
let h = a2 ? Ne : Ie, l;
try {
l = ys(r.map((u) => () => $r(h, e, u)));
} catch ({ errors: [u] }) {
throw Me(u);
}
return a2 && (l = Fe(l, { text: e, rootMarker: s.rootMarker })), Ns(l, { text: e });
};
}
function Qr(a2) {
return Array.isArray(a2) && a2.length > 0;
}
function Zr(a2) {
let t = Ie(a2, $s), { program: e } = t;
if (e.body.length === 0 && e.directives.length === 0 && !e.interpreter) return t;
}
function Be(a2, t = {}) {
let { allowComments: e = !0, allowEmpty: s = !1 } = t, i;
try {
i = Ne(a2, $s);
} catch (r) {
if (s && r.code === "BABEL_PARSER_SYNTAX_ERROR" && r.reasonCode === "ParseExpressionEmptyInput") try {
i = Zr(a2);
} catch {
}
if (!i) throw Me(r);
}
if (!e && vt(i.comments)) throw q(i.comments[0], "Comment");
return i = Fe(i, { type: "JsonRoot", text: a2 }), i.node.type === "File" ? delete i.node : re(i.node), i;
}
function q(a2, t) {
let [e, s] = [a2.loc.start, a2.loc.end].map(({ line: i, column: r }) => ({ line: i, column: r + 1 }));
return De(`${t} is not allowed in JSON.`, { loc: { start: e, end: s } });
}
function re(a2) {
switch (a2.type) {
case "ArrayExpression":
for (let t of a2.elements) t !== null && re(t);
return;
case "ObjectExpression":
for (let t of a2.properties) re(t);
return;
case "ObjectProperty":
if (a2.computed) throw q(a2.key, "Computed key");
if (a2.shorthand) throw q(a2.key, "Shorthand property");
a2.key.type !== "Identifier" && re(a2.key), re(a2.value);
return;
case "UnaryExpression": {
let { operator: t, argument: e } = a2;
if (t !== "+" && t !== "-") throw q(a2, `Operator '${a2.operator}'`);
if (e.type === "NumericLiteral" || e.type === "Identifier" && (e.name === "Infinity" || e.name === "NaN")) return;
throw q(e, `Operator '${t}' before '${e.type}'`);
}
case "Identifier":
if (a2.name !== "Infinity" && a2.name !== "NaN" && a2.name !== "undefined") throw q(a2, `Identifier '${a2.name}'`);
return;
case "TemplateLiteral":
if (vt(a2.expressions)) throw q(a2.expressions[0], "'TemplateLiteral' with expression");
for (let t of a2.quasis) re(t);
return;
case "NullLiteral":
case "BooleanLiteral":
case "NumericLiteral":
case "StringLiteral":
case "TemplateElement":
return;
default:
throw q(a2, `'${a2.type}'`);
}
}
var Hs, Re, Ks, kt, R, Q, Dt, Js, Mt, be, Gs, Xs, Ys, Qs, Zs, ei, p, ri, Ft, ai, W, E, T, m, Ue, oe, j, ni, we, ft, pe, dt, mt, yt, xt, Pt, gt, oi, bt, Xt, Pi, gi, Yt, Ti, At, bi, Ai, Si, Ei, ue, fe, He, We, Ni, g, vi, Di, Mi, Oi, ge, _e, je, U, Bi, Je, Ge, Xe, Ye, Qe, Ze, Ui, _t, Te, Vi, tt, st, it, rt, Z, Ce, at, nt, Y, de, Vt, ot, ht, ct, Ve, y, Ji, $t, Qi, Zi, Kt, Ht, hs, tr, pt, ze, sr, ir, qe, ut, Ee, ua, Wt, da, cs, ma, ls, ps, us, fs, ds, ms, ve, ee, ur, fr, xs, mr, Ps, te, xr, se, Pr, gs, St, Ts, wt, Ct, bs, As, me, wr, Ss, c, ws, Er, Cs, Es, fn, Ns, De, ks, Me, vr, Lr, xe, Dr, Mr, Or, Fr, vs, Br, Ls, Rr, Ur, Os, Fs, H, Oe, Nt, Fe, ie, Vr, js, Vs, _, zr, Hr, zs, Wr, Jr, Gr, Xr, qs, Yr, Lt, vt, $s, ea, ta, sa, ia, ra, init_babel = __esm({
"../../node_modules/.pnpm/prettier@3.8.4/node_modules/prettier/plugins/babel.mjs"() {
init_cjs_shims();
Hs = Object.defineProperty, Re = (a2, t) => {
for (var e in t) Hs(a2, e, { get: t[e], enumerable: !0 });
}, Ks = {};
Re(Ks, { parsers: () => ra });
kt = {};
Re(kt, { __babel_estree: () => Yr, __js_expression: () => Gr, __ts_expression: () => Xr, __vue_event_binding: () => Wr, __vue_expression: () => Gr, __vue_ts_event_binding: () => Jr, __vue_ts_expression: () => Xr, babel: () => Wr, "babel-flow": () => qs, "babel-ts": () => Jr });
R = class {
line;
column;
index;
constructor(t, e, s) {
this.line = t, this.column = e, this.index = s;
}
}, Q = class {
start;
end;
filename;
identifierName;
constructor(t, e) {
this.start = t, this.end = e;
}
};
Dt = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED", Js = { ImportMetaOutsideModule: { message: `import.meta may appear only with 'sourceType: "module"'`, code: Dt }, ImportOutsideModule: { message: `'import' and 'export' may appear only with 'sourceType: "module"'`, code: Dt } }, Mt = { 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" }, be = (a2) => a2.type === "UpdateExpression" ? Mt.UpdateExpression[`${a2.prefix}`] : Mt[a2.type], Gs = { AccessorIsGenerator: ({ kind: a2 }) => `A ${a2}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: a2 }) => `Missing initializer in ${a2} 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: a2 }) => `\`${a2}\` 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: a2, exportName: t }) => `A string literal cannot be used as an exported binding without \`from\`.
- Did you mean \`export { '${a2}' as '${t}' } from 'some-module'\`?`, ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.", ForInOfLoopInitializer: ({ type: a2 }) => `'${a2 === "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: a2 }) => `Unsyntactic ${a2 === "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: a2 }) => `A string literal cannot be used as an imported binding.
- Did you mean \`import { "${a2}" 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: a2 }) => `Expected number in radix ${a2}.`, InvalidEscapeSequence: "Bad character escape sequence.", InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.", InvalidEscapedReservedWord: ({ reservedWord: a2 }) => `Escape sequence in keyword ${a2}.`, InvalidIdentifier: ({ identifierName: a2 }) => `Invalid identifier ${a2}.`, InvalidLhs: ({ ancestor: a2 }) => `Invalid left-hand side in ${be(a2)}.`, InvalidLhsBinding: ({ ancestor: a2 }) => `Binding invalid left-hand side in ${be(a2)}.`, InvalidLhsOptionalChaining: ({ ancestor: a2 }) => `Invalid optional chaining in the left-hand side of ${be(a2)}.`, InvalidNumber: "Invalid number.", InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.", InvalidOrUnexpectedToken: ({ unexpected: a2 }) => `Unexpected character '${a2}'.`, InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.", InvalidPrivateFieldResolution: ({ identifierName: a2 }) => `Private name #${a2} 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: a2 }) => `Label '${a2}' 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: a2 }) => `This experimental syntax requires enabling the parser plugin: ${a2.map((t) => JSON.stringify(t)).join(", ")}.`, MissingOneOfPlugins: ({ missingPlugin: a2 }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${a2.map((t) => JSON.stringify(t)).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: a2 }) => `Duplicate key "${a2}" is not allowed in module attributes.`, ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode: a2 }) => `An export name cannot include a lone surrogate, found '\\u${a2.toString(16)}'.`, ModuleExportUndefined: ({ localName: a2 }) => `Export '${a2}' 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: a2 }) => `Private names are only allowed in property accesses (\`obj.#${a2}\`) or in \`in\` expressions (\`#${a2} in obj\`).`, PrivateNameRedeclaration: ({ identifierName: a2 }) => `Duplicate private name #${a2}.`, 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: a2 }) => `Unexpected keyword '${a2}'.`, 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: a2 }) => `Unexpected reserved word '${a2}'.`, UnexpectedSuper: "'super' is only allowed in object methods and classes.", UnexpectedToken: ({ expected: a2, unexpected: t }) => `Unexpected token${t ? ` '${t}'.` : ""}${a2 ? `, expected "${a2}"` : ""}`, 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: a2, onlyValidPropertyName: t }) => `The only valid meta property for ${a2} is ${a2}.${t}.`, 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: a2 }) => `Identifier '${a2}' 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." }, Xs = { StrictDelete: "Deleting local variable in strict mode.", StrictEvalArguments: ({ referenceName: a2 }) => `Assigning to '${a2}' in strict mode.`, StrictEvalArgumentsBinding: ({ bindingName: a2 }) => `Binding '${a2}' 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." }, Ys = { ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.", ParseExpressionExpectsEOF: ({ unexpected: a2 }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(a2)}\`.` }, Qs = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]), Zs = 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 references are only supported when using the `"proposal": "hack"` version of the pipeline proposal.', PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.", PipeTopicUnconfiguredToken: ({ token: a2 }) => `Invalid topic token ${a2}. In order to use ${a2} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${a2}" }.`, PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.", PipeUnparenthesizedBody: ({ type: a2 }) => `Hack-style pipe body cannot be an unparenthesized ${be({ type: a2 })}; please wrap it in parentheses.` }, {}), ei = ["message"];
p = Object.assign({}, F(Js), F(Gs), F(Xs), F(Ys), F`pipelineOperator`(Zs));
({ defineProperty: ri } = Object), Ft = (a2, t) => {
a2 && ri(a2, t, { enumerable: !1, value: a2[t] });
};
ai = (a2) => class extends a2 {
parse() {
let e = ne(super.parse());
return this.optionFlags & 256 && (e.tokens = e.tokens.map(ne)), e;
}
parseRegExpLiteral({ pattern: e, flags: s }) {
let i = null;
try {
i = new RegExp(e, s);
} catch {
}
let r = this.estreeParseLiteral(i);
return r.regex = { pattern: e, flags: s }, r;
}
parseBigIntLiteral(e) {
let s;
try {
s = BigInt(e);
} catch {
s = null;
}
let i = this.estreeParseLiteral(s);
return i.bigint = String(i.value || e), i;
}
parseDecimalLiteral(e) {
let i = this.estreeParseLiteral(null);
return i.decimal = String(i.value || e), i;
}
estreeParseLiteral(e) {
return this.parseLiteral(e, "Literal");
}
parseStringLiteral(e) {
return this.estreeParseLiteral(e);
}
parseNumericLiteral(e) {
return this.estreeParseLiteral(e);
}
parseNullLiteral() {
return this.estreeParseLiteral(null);
}
parseBooleanLiteral(e) {
return this.estreeParseLiteral(e);
}
estreeParseChainExpression(e, s) {
let i = this.startNodeAtNode(e);
return i.expression = e, this.finishNodeAt(i, "ChainExpression", s);
}
directiveToStmt(e) {
let s = e.value;
delete e.value, this.castNodeTo(s, "Literal"), s.raw = s.extra.raw, s.value = s.extra.expressionValue;
let i = this.castNodeTo(e, "ExpressionStatement");
return i.expression = s, i.directive = s.extra.rawValue, delete s.extra, i;
}
fillOptionalPropertiesForTSESLint(e) {
}
cloneEstreeStringLiteral(e) {
let { start: s, end: i, loc: r, range: n, raw: o, value: h } = e, l = Object.create(e.constructor.prototype);
return l.type = "Literal", l.start = s, l.end = i, l.loc = r, l.range = n, l.raw = o, l.value = h, l;
}
initFunction(e, s) {
super.initFunction(e, s), e.expression = !1;
}
checkDeclaration(e) {
e != null && this.isObjectProperty(e) ? this.checkDeclaration(e.value) : super.checkDeclaration(e);
}
getObjectOrClassMethodParams(e) {
return e.value.params;
}
isValidDirective(e) {
return e.type === "ExpressionStatement" && e.expression.type === "Literal" && typeof e.expression.value == "string" && !e.expression.extra?.parenthesized;
}
parseBlockBody(e, s, i, r, n) {
super.parseBlockBody(e, s, i, r, n);
let o = e.directives.map((h) => this.directiveToStmt(h));
e.body = o.concat(e.body), delete e.directives;
}
parsePrivateName() {
let e = super.parsePrivateName();
return this.convertPrivateNameToPrivateIdentifier(e);
}
convertPrivateNameToPrivateIdentifier(e) {
let s = super.getPrivateNameSV(e);
return delete e.id, e.name = s, this.castNodeTo(e, "PrivateIdentifier");
}
isPrivateName(e) {
return e.type === "PrivateIdentifier";
}
getPrivateNameSV(e) {
return e.name;
}
parseLiteral(e, s) {
let i = super.parseLiteral(e, s);
return i.raw = i.extra.raw, delete i.extra, i;
}
parseFunctionBody(e, s, i = !1) {
super.parseFunctionBody(e, s, i), e.expression = e.body.type !== "BlockStatement";
}
parseMethod(e, s, i, r, n, o, h = !1) {
let l = this.startNode();
l.kind = e.kind, l = super.parseMethod(l, s, i, r, n, o, h), delete l.kind;
let { typeParameters: u } = e;
u && (delete e.typeParameters, l.typeParameters = u, this.resetStartLocationFromNode(l, u));
let f = this.castNodeTo(l, this.hasPlugin("typescript") && !l.body ? "TSEmptyBodyFunctionExpression" : "FunctionExpression");
return e.value = f, o === "ClassPrivateMethod" && (e.computed = !1), this.hasPlugin("typescript") && e.abstract ? (delete e.abstract, this.finishNode(e, "TSAbstractMethodDefinition")) : o === "ObjectMethod" ? (e.kind === "method" && (e.kind = "init"), e.shorthand = !1, this.finishNode(e, "Property")) : this.finishNode(e, "MethodDefinition");
}
nameIsConstructor(e) {
return e.type === "Literal" ? e.value === "constructor" : super.nameIsConstructor(e);
}
parseClassProperty(...e) {
let s = super.parseClassProperty(...e);
return s.abstract && this.hasPlugin("typescript") ? (delete s.abstract, this.castNodeTo(s, "TSAbstractPropertyDefinition")) : this.castNodeTo(s, "PropertyDefinition"), s;
}
parseClassPrivateProperty(...e) {
let s = super.parseClassPrivateProperty(...e);
return s.abstract && this.hasPlugin("typescript") ? this.castNodeTo(s, "TSAbstractPropertyDefinition") : this.castNodeTo(s, "PropertyDefinition"), s.computed = !1, s;
}
parseClassAccessorProperty(e) {
let s = super.parseClassAccessorProperty(e);
return s.abstract && this.hasPlugin("typescript") ? (delete s.abstract, this.castNodeTo(s, "TSAbstractAccessorProperty")) : this.castNodeTo(s, "AccessorProperty"), s;
}
parseObjectProperty(e, s, i, r) {
let n = super.parseObjectProperty(e, s, i, r);
return n && (n.kind = "init", this.castNodeTo(n, "Property")), n;
}
finishObjectProperty(e) {
return e.kind = "init", this.finishNode(e, "Property");
}
isValidLVal(e, s, i, r) {
return e === "Property" ? "value" : super.isValidLVal(e, s, i, r);
}
isAssignable(e, s) {
return e != null && this.isObjectProperty(e) ? this.isAssignable(e.value, s) : super.isAssignable(e, s);
}
toAssignable(e, s = !1) {
if (e != null && this.isObjectProperty(e)) {
let { key: i, value: r } = e;
this.isPrivateName(i) && this.classScope.usePrivateName(this.getPrivateNameSV(i), i.loc.start), this.toAssignable(r, s);
} else super.toAssignable(e, s);
}
toAssignableObjectExpressionProp(e, s, i) {
e.type === "Property" && (e.kind === "get" || e.kind === "set") ? this.raise(p.PatternHasAccessor, e.key) : e.type === "Property" && e.method ? this.raise(p.PatternHasMethod, e.key) : super.toAssignableObjectExpressionProp(e, s, i);
}
finishCallExpression(e, s) {
let i = super.finishCallExpression(e, s);
return i.callee.type === "Import" ? (this.castNodeTo(i, "ImportExpression"), i.source = i.arguments[0], i.options = i.arguments[1] ?? null, delete i.arguments, delete i.callee) : i.type === "OptionalCallExpression" ? this.castNodeTo(i, "CallExpression") : i.optional = !1, i;
}
toReferencedArguments(e) {
e.type !== "ImportExpression" && super.toReferencedArguments(e);
}
parseExport(e, s) {
let i = this.state.lastTokStartLoc, r = super.parseExport(e, s);
switch (r.type) {
case "ExportAllDeclaration":
r.exported = null;
break;
case "ExportNamedDeclaration":
r.specifiers.length === 1 && r.specifiers[0].type === "ExportNamespaceSpecifier" && (this.castNodeTo(r, "ExportAllDeclaration"), r.exported = r.specifiers[0].exported, delete r.specifiers);
case "ExportDefaultDeclaration":
{
let { declaration: n } = r;
n?.type === "ClassDeclaration" && n.decorators?.length > 0 && n.start === r.start && this.resetStartLocation(r, i);
}
break;
}
return r;
}
stopParseSubscript(e, s) {
let i = super.stopParseSubscript(e, s);
return s.optionalChainMember ? this.estreeParseChainExpression(i, e.loc.end) : i;
}
parseMember(e, s, i, r, n) {
let o = super.parseMember(e, s, i, r, n);
return o.type === "OptionalMemberExpression" ? this.castNodeTo(o, "MemberExpression") : o.optional = !1, o;
}
isOptionalMemberExpression(e) {
return e.type === "ChainExpression" ? e.expression.type === "MemberExpression" : super.isOptionalMemberExpression(e);
}
hasPropertyAsPrivateName(e) {
return e.type === "ChainExpression" && (e = e.expression), super.hasPropertyAsPrivateName(e);
}
isObjectProperty(e) {
return e.type === "Property" && e.kind === "init" && !e.method;
}
isObjectMethod(e) {
return e.type === "Property" && (e.method || e.kind === "get" || e.kind === "set");
}
castNodeTo(e, s) {
let i = super.castNodeTo(e, s);
return this.fillOptionalPropertiesForTSESLint(i), i;
}
cloneIdentifier(e) {
let s = super.cloneIdentifier(e);
return this.fillOptionalPropertiesForTSESLint(s), s;
}
cloneStringLiteral(e) {
return e.type === "Literal" ? this.cloneEstreeStringLiteral(e) : super.cloneStringLiteral(e);
}
finishNodeAt(e, s, i) {
return ne(super.finishNodeAt(e, s, i));
}
finishNode(e, s) {
let i = super.finishNode(e, s);
return this.fillOptionalPropertiesForTSESLint(i), i;
}
resetStartLocation(e, s) {
super.resetStartLocation(e, s), ne(e);
}
resetEndLocation(e, s = this.state.lastTokEndLoc) {
super.resetEndLocation(e, s), ne(e);
}
}, W = class {
constructor(t, e) {
this.token = t, this.preserveSpace = !!e;
}
token;
preserveSpace;
}, E = { brace: new W("{"), j_oTag: new W("<tag"), j_cTag: new W("</tag"), j_expr: new W("<tag>...</tag>", !0) }, T = !0, m = !0, Ue = !0, oe = !0, j = !0, ni = !0, we = class {
label;
keyword;
beforeExpr;
startsExpr;
rightAssociative;
isLoop;
isAssign;
prefix;
postfix;
binop;
constructor(t, e = {}) {
this.label = t, this.keyword = e.keyword, this.beforeExpr = !!e.beforeExpr, this.startsExpr = !!e.startsExpr, this.rightAssociative = !!e.rightAssociative, this.isLoop = !!e.isLoop, this.isAssign = !!e.isAssign, this.prefix = !!e.prefix, this.postfix = !!e.postfix, this.binop = e.binop != null ? e.binop : null;
}
}, ft = /* @__PURE__ */ new Map();
pe = -1, dt = [], mt = [], yt = [], xt = [], Pt = [], gt = [];
oi = { bracketL: P("[", { beforeExpr: T, startsExpr: m }), bracketHashL: P("#[", { beforeExpr: T, startsExpr: m }), bracketBarL: P("[|", { beforeExpr: T, startsExpr: m }), bracketR: P("]"), bracketBarR: P("|]"), braceL: P("{", { beforeExpr: T, startsExpr: m }), braceBarL: P("{|", { beforeExpr: T, startsExpr: m }), braceHashL: P("#{", { beforeExpr: T, startsExpr: m }), braceR: P("}"), braceBarR: P("|}"), parenL: P("(", { beforeExpr: T, startsExpr: m }), parenR: P(")"), comma: P(",", { beforeExpr: T }), semi: P(";", { beforeExpr: T }), colon: P(":", { beforeExpr: T }), doubleColon: P("::", { beforeExpr: T }), dot: P("."), question: P("?", { beforeExpr: T }), questionDot: P("?."), arrow: P("=>", { beforeExpr: T }), template: P("template"), ellipsis: P("...", { beforeExpr: T }), backQuote: P("`", { startsExpr: m }), dollarBraceL: P("${", { beforeExpr: T, startsExpr: m }), templateTail: P("...`", { startsExpr: m }), templateNonTail: P("...${", { beforeExpr: T, startsExpr: m }), at: P("@"), hash: P("#", { startsExpr: m }), interpreterDirective: P("#!..."), eq: P("=", { beforeExpr: T, isAssign: oe }), assign: P("_=", { beforeExpr: T, isAssign: oe }), slashAssign: P("_=", { beforeExpr: T, isAssign: oe }), xorAssign: P("_=", { beforeExpr: T, isAssign: oe }), moduloAssign: P("_=", { beforeExpr: T, isAssign: oe }), incDec: P("++/--", { prefix: j, postfix: ni, startsExpr: m }), bang: P("!", { beforeExpr: T, prefix: j, startsExpr: m }), tilde: P("~", { beforeExpr: T, prefix: j, startsExpr: m }), doubleCaret: P("^^", { startsExpr: m }), doubleAt: P("@@", { startsExpr: m }), pipeline: v("|>", 0), nullishCoalescing: v("??", 1), logicalOR: v("||", 1), logicalAND: v("&&", 2), bitwiseOR: v("|", 3), bitwiseXOR: v("^", 4), bitwiseAND: v("&", 5), equality: v("==/!=/===/!==", 6), lt: v("</>/<=/>=", 7), gt: v("</>/<=/>=", 7), relational: v("</>/<=/>=", 7), bitShift: v("<</>>/>>>", 8), bitShiftL: v("<</>>/>>>", 8), bitShiftR: v("<</>>/>>>", 8), plusMin: P("+/-", { beforeExpr: T, binop: 9, prefix: j, startsExpr: m }), modulo: P("%", { binop: 10, startsExpr: m }), star: P("*", { binop: 10 }), slash: v("/", 10), exponent: P("**", { beforeExpr: T, binop: 11, rightAssociative: !0 }), _in: S("in", { beforeExpr: T, binop: 7 }), _instanceof: S("instanceof", { beforeExpr: T, binop: 7 }), _break: S("break"), _case: S("case", { beforeExpr: T }), _catch: S("catch"), _continue: S("continue"), _debugger: S("debugger"), _default: S("default", { beforeExpr: T }), _else: S("else", { beforeExpr: T }), _finally: S("finally"), _function: S("function", { startsExpr: m }), _if: S("if"), _return: S("return", { beforeExpr: T }), _switch: S("switch"), _throw: S("throw", { beforeExpr: T, prefix: j, startsExpr: m }), _try: S("try"), _var: S("var"), _const: S("const"), _with: S("with"), _new: S("new", { beforeExpr: T, startsExpr: m }), _this: S("this", { startsExpr: m }), _super: S("super", { startsExpr: m }), _class: S("class", { startsExpr: m }), _extends: S("extends", { beforeExpr: T }), _export: S("export"), _import: S("import", { startsExpr: m }), _null: S("null", { startsExpr: m }), _true: S("true", { startsExpr: m }), _false: S("false", { startsExpr: m }), _typeof: S("typeof", { beforeExpr: T, prefix: j, startsExpr: m }), _void: S("void", { beforeExpr: T, prefix: j, startsExpr: m }), _delete: S("delete", { beforeExpr: T, prefix: j, startsExpr: m }), _do: S("do", { isLoop: Ue, beforeExpr: T }), _for: S("for", { isLoop: Ue }), _while: S("while", { isLoop: Ue }), _as: b("as", { startsExpr: m }), _assert: b("assert", { startsExpr: m }), _async: b("async", { startsExpr: m }), _await: b("await", { startsExpr: m }), _defer: b("defer", { startsExpr: m }), _from: b("from", { startsExpr: m }), _get: b("get", { startsExpr: m }), _let: b("let", { startsExpr: m }), _meta: b("meta", { startsExpr: m }), _of: b("of", { startsExpr: m }), _sent: b("sent", { startsExpr: m }), _set: b("set", { startsExpr: m }), _source: b("source", { startsExpr: m }), _static: b("static", { startsExpr: m }), _using: b("using", { startsExpr: m }), _yield: b("yield", { startsExpr: m }), _asserts: b("asserts", { startsExpr: m }), _checks: b("checks", { startsExpr: m }), _exports: b("exports", { startsExpr: m }), _global: b("global", { startsExpr: m }), _implements: b("implements", { startsExpr: m }), _intrinsic: b("intrinsic", { startsExpr: m }), _infer: b("infer", { startsExpr: m }), _is: b("is", { startsExpr: m }), _mixins: b("mixins", { startsExpr: m }), _proto: b("proto", { startsExpr: m }), _require: b("require", { startsExpr: m }), _satisfies: b("satisfies", { startsExpr: m }), _keyof: b("keyof", { startsExpr: m }), _readonly: b("readonly", { startsExpr: m }), _unique: b("unique", { startsExpr: m }), _abstract: b("abstract", { startsExpr: m }), _declare: b("declare", { startsExpr: m }), _enum: b("enum", { startsExpr: m }), _module: b("module", { startsExpr: m }), _namespace: b("namespace", { startsExpr: m }), _interface: b("interface", { startsExpr: m }), _type: b("type", { startsExpr: m }), _opaque: b("opaque", { startsExpr: m }), name: P("name", { startsExpr: m }), placeholder: P("%%", { startsExpr: m }), string: P("string", { startsExpr: m }), num: P("num", { startsExpr: m }), bigint: P("bigint", { startsExpr: m }), decimal: P("decimal", { startsExpr: m }), regexp: P("regexp", { startsExpr: m }), privateName: P("#name", { startsExpr: m }), eof: P("eof"), jsxName: P("jsxName"), jsxText: P("jsxText", { beforeExpr: T }), jsxTagStart: P("jsxTagStart", { startsExpr: m }), jsxTagEnd: P("jsxTagEnd") };
bt = "\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", Xt = "\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", Pi = new RegExp("[" + bt + "]"), gi = new RegExp("[" + bt + Xt + "]");
bt = Xt = null;
Yt = [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], Ti = [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];
At = { 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"] }, bi = new Set(At.keyword), Ai = new Set(At.strict), Si = new Set(At.strictBind);
Ei = /* @__PURE__ */ 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"]);
ue = class {
flags = 0;
names = /* @__PURE__ */ new Map();
firstLexicalName = "";
constructor(t) {
this.flags = t;
}
}, fe = class {
parser;
scopeStack = [];
inModule;
undefinedExports = /* @__PURE__ */ new Map();
constructor(t, e) {
this.parser = t, this.inModule = e;
}
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() {
let t = this.currentThisScopeFlags();
return (t & 64) > 0 && (t & 2) === 0;
}
get inStaticBlock() {
for (let t = this.scopeStack.length - 1; ; t--) {
let { flags: e } = this.scopeStack[t];
if (e & 128) return !0;
if (e & 1731) return !1;
}
}
get inNonArrowFunction() {
return (this.currentThisScopeFlags() & 2) > 0;
}
get inBareCaseStatement() {
return (this.currentScope().flags & 256) > 0;
}
get treatFunctionsAsVar() {
return this.treatFunctionsAsVarInScope(this.currentScope());
}
createScope(t) {
return new ue(t);
}
enter(t) {
this.scopeStack.push(this.createScope(t));
}
exit() {
return this.scopeStack.pop().flags;
}
treatFunctionsAsVarInScope(t) {
return !!(t.flags & 130 || !this.parser.inModule && t.flags & 1);
}
declareName(t, e, s) {
let i = this.currentScope();
if (e & 8 || e & 16) {
this.checkRedeclarationInScope(i, t, e, s);
let r = i.names.get(t) || 0;
e & 16 ? r = r | 4 : (i.firstLexicalName || (i.firstLexicalName = t), r = r | 2), i.names.set(t, r), e & 8 && this.maybeExportDefined(i, t);
} else if (e & 4) for (let r = this.scopeStack.length - 1; r >= 0 && (i = this.scopeStack[r], this.checkRedeclarationInScope(i, t, e, s), i.names.set(t, (i.names.get(t) || 0) | 1), this.maybeExportDefined(i, t), !(i.flags & 1667)); --r) ;
this.parser.inModule && i.flags & 1 && this.undefinedExports.delete(t);
}
maybeExportDefined(t, e) {
this.parser.inModule && t.flags & 1 && this.undefinedExports.delete(e);
}
checkRedeclarationInScope(t, e, s, i) {
this.isRedeclaredInScope(t, e, s) && this.parser.raise(p.VarRedeclaration, i, { identifierName: e });
}
isRedeclaredInScope(t, e, s) {
if (!(s & 1)) return !1;
if (s & 8) return t.names.has(e);
let i = t.names.get(e) || 0;
return s & 16 ? (i & 2) > 0 || !this.treatFunctionsAsVarInScope(t) && (i & 1) > 0 : (i & 2) > 0 && !(t.flags & 8 && t.firstLexicalName === e) || !this.treatFunctionsAsVarInScope(t) && (i & 4) > 0;
}
checkLocalExport(t) {
let { name: e } = t;
this.scopeStack[0].names.has(e) || this.undefinedExports.set(e, t.loc.start);
}
currentScope() {
return this.scopeStack[this.scopeStack.length - 1];
}
currentVarScopeFlags() {
for (let t = this.scopeStack.length - 1; ; t--) {
let { flags: e } = this.scopeStack[t];
if (e & 1667) return e;
}
}
currentThisScopeFlags() {
for (let t = this.scopeStack.length - 1; ; t--) {
let { flags: e } = this.scopeStack[t];
if (e & 1731 && !(e & 4)) return e;
}
}
}, He = class extends ue {
declareFunctions = /* @__PURE__ */ new Set();
}, We = class extends fe {
createScope(t) {
return new He(t);
}
declareName(t, e, s) {
let i = this.currentScope();
if (e & 2048) {
this.checkRedeclarationInScope(i, t, e, s), this.maybeExportDefined(i, t), i.declareFunctions.add(t);
return;
}
super.declareName(t, e, s);
}
isRedeclaredInScope(t, e, s) {
if (super.isRedeclaredInScope(t, e, s)) return !0;
if (s & 2048 && !t.declareFunctions.has(e)) {
let i = t.names.get(e);
return (i & 4) > 0 || (i & 2) > 0;
}
return !1;
}
checkLocalExport(t) {
this.scopeStack[0].declareFunctions.has(t.name) || super.checkLocalExport(t);
}
}, Ni = /* @__PURE__ */ new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]), g = F`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: a2 }) => `Cannot overwrite reserved type ${a2}.`, 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: a2, enumName: t }) => `Boolean enum members need to be initialized. Use either \`${a2} = true,\` or \`${a2} = false,\` in enum \`${t}\`.`, EnumDuplicateMemberName: ({ memberName: a2, enumName: t }) => `Enum member names need to be unique, but the name \`${a2}\` has already been used before in enum \`${t}\`.`, EnumInconsistentMemberValues: ({ enumName: a2 }) => `Enum \`${a2}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`, EnumInvalidExplicitType: ({ invalidEnumType: a2, enumName: t }) => `Enum type \`${a2}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${t}\`.`, EnumInvalidExplicitTypeUnknownSupplied: ({ enumName: a2 }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${a2}\`.`, EnumInvalidMemberInitializerPrimaryType: ({ enumName: a2, memberName: t, explicitType: e }) => `Enum \`${a2}\` has type \`${e}\`, so the initializer of \`${t}\` needs to be a ${e} literal.`, EnumInvalidMemberInitializerSymbolType: ({ enumName: a2, memberName: t }) => `Symbol enum members cannot be initialized. Use \`${t},\` in enum \`${a2}\`.`, EnumInvalidMemberInitializerUnknownType: ({ enumName: a2, memberName: t }) => `The enum member initializer for \`${t}\` needs to be a literal (either a boolean, number, or string) in enum \`${a2}\`.`, EnumInvalidMemberName: ({ enumName: a2, memberName: t, suggestion: e }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${t}\`, consider using \`${e}\`, in enum \`${a2}\`.`, EnumNumberMemberNotInitialized: ({ enumName: a2, memberName: t }) => `Number enum members need to be initialized, e.g. \`${t} = 1\` in enum \`${a2}\`.`, EnumStringMemberInconsistentlyInitialized: ({ enumName: a2 }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${a2}\`.`, 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." }, {}), 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: a2 }) => `Unexpected reserved type ${a2}.`, 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 `<T> async () => {}`, use `async <T>() => {}`.", UnsupportedDeclareExportKind: ({ unsupportedExportKind: a2, suggestion: t }) => `\`declare export ${a2}\` is not supported. Use \`${t}\` instead.`, UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.", UnterminatedFlowComment: "Unterminated flow-comment." });
vi = { const: "declare export var", let: "declare export var", type: "export type", interface: "export interface" };
Di = /\*?\s*@((?:no)?flow)\b/, Mi = (a2) => class extends a2 {
flowPragma = void 0;
getScopeHandler() {
return We;
}
shouldParseTypes() {
return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
}
finishToken(e, s) {
e !== 134 && e !== 13 && e !== 28 && this.flowPragma === void 0 && (this.flowPragma = null), super.finishToken(e, s);
}
addComment(e) {
if (this.flowPragma === void 0) {
let s = Di.exec(e.value);
if (s) if (s[1] === "flow") this.flowPragma = "flow";
else if (s[1] === "noflow") this.flowPragma = "noflow";
else throw new Error("Unexpected flow pragma");
}
super.addComment(e);
}
flowParseTypeInitialiser(e) {
let s = this.state.inType;
this.state.inType = !0, this.expect(e || 14);
let i = this.flowParseType();
return this.state.inType = s, i;
}
flowParsePredicate() {
let e = this.startNode(), s = this.state.startLoc;
return this.next(), this.expectContextual(110), this.state.lastTokStartLoc.index > s.index + 1 && this.raise(g.UnexpectedSpaceBetweenModuloChecks, s), this.eat(10) ? (e.value = super.parseExpression(), this.expect(11), this.finishNode(e, "DeclaredPredicate")) : this.finishNode(e, "InferredPredicate");
}
flowParseTypeAndPredicateInitialiser() {
let e = this.state.inType;
this.state.inType = !0, this.expect(14);
let s = null, i = null;
return this.match(54) ? (this.state.inType = e, i = this.flowParsePredicate()) : (s = this.flowParseType(), this.state.inType = e, this.match(54) && (i = this.flowParsePredicate())), [s, i];
}
flowParseDeclareClass(e) {
return this.next(), this.flowParseInterfaceish(e, !0), this.finishNode(e, "DeclareClass");
}
flowParseDeclareFunction(e) {
this.next();
let s = e.id = this.parseIdentifier(), i = this.startNode(), r = this.startNode();
this.match(47) ? i.typeParameters = this.flowParseTypeParameterDeclaration() : i.typeParameters = null, this.expect(10);
let n = this.flowParseFunctionTypeParams();
return i.params = n.params, i.rest = n.rest, i.this = n._this, this.expect(11), [i.returnType, e.predicate] = this.flowParseTypeAndPredicateInitialiser(), r.typeAnnotation = this.finishNode(i, "FunctionTypeAnnotation"), s.typeAnnotation = this.finishNode(r, "TypeAnnotation"), this.resetEndLocation(s), this.semicolon(), this.scope.declareName(e.id.name, 2048, e.id.loc.start), this.finishNode(e, "DeclareFunction");
}
flowParseDeclare(e, s) {
if (this.match(80)) return this.flowParseDeclareClass(e);
if (this.match(68)) return this.flowParseDeclareFunction(e);
if (this.match(74)) return this.flowParseDeclareVariable(e);
if (this.eatContextual(127)) return this.match(16) ? this.flowParseDeclareModuleExports(e) : (s && this.raise(g.NestedDeclareModule, this.state.lastTokStartLoc), this.flowParseDeclareModule(e));
if (this.isContextual(130)) return this.flowParseDeclareTypeAlias(e);
if (this.isContextual(131)) return this.flowParseDeclareOpaqueType(e);
if (this.isContextual(129)) return this.flowParseDeclareInterface(e);
if (this.match(82)) return this.flowParseDeclareExportDeclaration(e, s);
throw this.unexpected();
}
flowParseDeclareVariable(e) {
return this.next(), e.id = this.flowParseTypeAnnotatableIdentifier(!0), this.scope.declareName(e.id.name, 5, e.id.loc.start), this.semicolon(), this.finishNode(e, "DeclareVariable");
}
flowParseDeclareModule(e) {
this.scope.enter(0), this.match(134) ? e.id = super.parseExprAtom() : e.id = this.parseIdentifier();
let s = e.body = this.startNode(), i = s.body = [];
for (this.expect(5); !this.match(8); ) {
let o = this.startNode();
this.match(83) ? (this.next(), !this.isContextual(130) && !this.match(87) && this.raise(g.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc), i.push(super.parseImport(o))) : (this.expectContextual(125, g.UnsupportedStatementInDeclareModule), i.push(this.flowParseDeclare(o, !0)));
}
this.scope.exit(), this.expect(8), this.finishNode(s, "BlockStatement");
let r = null, n = !1;
return i.forEach((o) => {
ki(o) ? (r === "CommonJS" && this.raise(g.AmbiguousDeclareModuleKind, o), r = "ES") : o.type === "DeclareModuleExports" && (n && this.raise(g.DuplicateDeclareModuleExports, o), r === "ES" && this.raise(g.AmbiguousDeclareModuleKind, o), r = "CommonJS", n = !0);
}), e.kind = r || "CommonJS", this.finishNode(e, "DeclareModule");
}
flowParseDeclareExportDeclaration(e, s) {
if (this.expect(82), this.eat(65)) return this.match(68) || this.match(80) ? e.declaration = this.flowParseDeclare(this.startNode()) : (e.declaration = this.flowParseType(), this.semicolon()), e.default = !0, this.finishNode(e, "DeclareExportDeclaration");
if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !s) {
let i = this.state.value;
throw this.raise(g.UnsupportedDeclareExportKind, this.state.startLoc, { unsupportedExportKind: i, suggestion: vi[i] });
}
if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) return e.declaration = this.flowParseDeclare(this.startNode()), e.default = !1, this.finishNode(e, "DeclareExportDeclaration");
if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) return e = this.parseExport(e, null), e.type === "ExportNamedDeclaration" ? (e.default = !1, delete e.exportKind, this.castNodeTo(e, "DeclareExportDeclaration")) : this.castNodeTo(e, "DeclareExportAllDeclaration");
throw this.unexpected();
}
flowParseDeclareModuleExports(e) {
return this.next(), this.expectContextual(111), e.typeAnnotation = this.flowParseTypeAnnotation(), this.semicolon(), this.finishNode(e, "DeclareModuleExports");
}
flowParseDeclareTypeAlias(e) {
this.next();
let s = this.flowParseTypeAlias(e);
return this.castNodeTo(s, "DeclareTypeAlias"), s;
}
flowParseDeclareOpaqueType(e) {
this.next();
let s = this.flowParseOpaqueType(e, !0);
return this.castNodeTo(s, "DeclareOpaqueType"), s;
}
flowParseDeclareInterface(e) {
return this.next(), this.flowParseInterfaceish(e, !1), this.finishNode(e, "DeclareInterface");
}
flowParseInterfaceish(e, s) {
if (e.id = this.flowParseRestrictedIdentifier(!s, !0), this.scope.declareName(e.id.name, s ? 17 : 8201, e.id.loc.start), this.match(47) ? e.typeParameters = this.flowParseTypeParameterDeclaration() : e.typeParameters = null, e.extends = [], this.eat(81)) do
e.extends.push(this.flowParseInterfaceExtends());
while (!s && this.eat(12));
if (s) {
if (e.implements = [], e.mixins = [], this.eatContextual(117)) do
e.mixins.push(this.flowParseInterfaceExtends());
while (this.eat(12));
if (this.eatContextual(113)) do
e.implements.push(this.flowParseInterfaceExtends());
while (this.eat(12));
}
e.body = this.flowParseObjectType({ allowStatic: s, allowExact: !1, allowSpread: !1, allowProto: s, allowInexact: !1 });
}
flowParseInterfaceExtends() {
let e = this.startNode();
return e.id = this.flowParseQualifiedTypeIdentifier(), this.match(47) ? e.typeParameters = this.flowParseTypeParameterInstantiation() : e.typeParameters = null, this.finishNode(e, "InterfaceExtends");
}
flowParseInterface(e) {
return this.flowParseInterfaceish(e, !1), this.finishNode(e, "InterfaceDeclaration");
}
checkNotUnderscore(e) {
e === "_" && this.raise(g.UnexpectedReservedUnderscore, this.state.startLoc);
}
checkReservedType(e, s, i) {
Ni.has(e) && this.raise(i ? g.AssignReservedType : g.UnexpectedReservedType, s, { reservedType: e });
}
flowParseRestrictedIdentifier(e, s) {
return this.checkReservedType(this.state.value, this.state.startLoc, s), this.parseIdentifier(e);
}
flowParseTypeAlias(e) {
return e.id = this.flowParseRestrictedIdentifier(!1, !0), this.scope.declareName(e.id.name, 8201, e.id.loc.start), this.match(47) ? e.typeParameters = this.flowParseTypeParameterDeclaration() : e.typeParameters = null, e.right = this.flowParseTypeInitialiser(29), this.semicolon(), this.finishNode(e, "TypeAlias");
}
flowParseOpaqueType(e, s) {
return this.expectContextual(130), e.id = this.flowParseRestrictedIdentifier(!0, !0), this.scope.declareName(e.id.name, 8201, e.id.loc.start), this.match(47) ? e.typeParameters = this.flowParseTypeParameterDeclaration() : e.typeParameters = null, e.supertype = null, this.match(14) && (e.supertype = this.flowParseTypeInitialiser(14)), e.impltype = null, s || (e.impltype = this.flowParseTypeInitialiser(29)), this.semicolon(), this.finishNode(e, "OpaqueType");
}
flowParseTypeParameter(e = !1) {
let s = this.state.startLoc, i = this.startNode(), r = this.flowParseVariance(), n = this.flowParseTypeAnnotatableIdentifier();
return i.name = n.name, i.variance = r, i.bound = n.typeAnnotation, this.match(29) ? (this.eat(29), i.default = this.flowParseType()) : e && this.raise(g.MissingTypeParamDefault, s), this.finishNode(i, "TypeParameter");
}
flowParseTypeParameterDeclaration() {
let e = this.state.inType, s = this.startNode();
s.params = [], this.state.inType = !0, this.match(47) || this.match(143) ? this.next() : this.unexpected();
let i = !1;
do {
let r = this.flowParseTypeParameter(i);
s.params.push(r), r.default && (i = !0), this.match(48) || this.expect(12);
} while (!this.match(48));
return this.expect(48), this.state.inType = e, this.finishNode(s, "TypeParameterDeclaration");
}
flowInTopLevelContext(e) {
if (this.curContext() !== E.brace) {
let s = this.state.context;
this.state.context = [s[0]];
try {
return e();
} finally {
this.state.context = s;
}
} else return e();
}
flowParseTypeParameterInstantiationInExpression() {
if (this.reScan_lt() === 47) return this.flowParseTypeParameterInstantiation();
}
flowParseTypeParameterInstantiation() {
let e = this.startNode(), s = this.state.inType;
return this.state.inType = !0, e.params = [], this.flowInTopLevelContext(() => {
this.expect(47);
let i = this.state.noAnonFunctionType;
for (this.state.noAnonFunctionType = !1; !this.match(48); ) e.params.push(this.flowParseType()), this.match(48) || this.expect(12);
this.state.noAnonFunctionType = i;
}), this.state.inType = s, !this.state.inType && this.curContext() === E.brace && this.reScan_lt_gt(), this.expect(48), this.finishNode(e, "TypeParameterInstantiation");
}
flowParseTypeParameterInstantiationCallOrNew() {
if (this.reScan_lt() !== 47) return null;
let e = this.startNode(), s = this.state.inType;
for (e.params = [], this.state.inType = !0, this.expect(47); !this.match(48); ) e.params.push(this.flowParseTypeOrImplicitInstantiation()), this.match(48) || this.expect(12);
return this.expect(48), this.state.inType = s, this.finishNode(e, "TypeParameterInstantiation");
}
flowParseInterfaceType() {
let e = this.startNode();
if (this.expectContextual(129), e.extends = [], this.eat(81)) do
e.extends.push(this.flowParseInterfaceExtends());
while (this.eat(12));
return e.body = this.flowParseObjectType({ allowStatic: !1, allowExact: !1, allowSpread: !1, allowProto: !1, allowInexact: !1 }), this.finishNode(e, "InterfaceTypeAnnotation");
}
flowParseObjectPropertyKey() {
return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(!0);
}
flowParseObjectTypeIndexer(e, s, i) {
return e.static = s, this.lookahead().type === 14 ? (e.id = this.flowParseObjectPropertyKey(), e.key = this.flowParseTypeInitialiser()) : (e.id = null, e.key = this.flowParseType()), this.expect(3), e.value = this.flowParseTypeInitialiser(), e.variance = i, this.finishNode(e, "ObjectTypeIndexer");
}
flowParseObjectTypeInternalSlot(e, s) {
return e.static = s, e.id = this.flowParseObjectPropertyKey(), this.expect(3), this.expect(3), this.match(47) || this.match(10) ? (e.method = !0, e.optional = !1, e.value = this.flowParseObjectTypeMethodish(this.startNodeAt(e.loc.start))) : (e.method = !1, this.eat(17) && (e.optional = !0), e.value = this.flowParseTypeInitialiser()), this.finishNode(e, "ObjectTypeInternalSlot");
}
flowParseObjectTypeMethodish(e) {
for (e.params = [], e.rest = null, e.typeParameters = null, e.this = null, this.match(47) && (e.typeParameters = this.flowParseTypeParameterDeclaration()), this.expect(10), this.match(78) && (e.this = this.flowParseFunctionTypeParam(!0), e.this.name = null, this.match(11) || this.expect(12)); !this.match(11) && !this.match(21); ) e.params.push(this.flowParseFunctionTypeParam(!1)), this.match(11) || this.expect(12);
return this.eat(21) && (e.rest = this.flowParseFunctionTypeParam(!1)), this.expect(11), e.returnType = this.flowParseTypeInitialiser(), this.finishNode(e, "FunctionTypeAnnotation");
}
flowParseObjectTypeCallProperty(e, s) {
let i = this.startNode();
return e.static = s, e.value = this.flowParseObjectTypeMethodish(i), this.finishNode(e, "ObjectTypeCallProperty");
}
flowParseObjectType({ allowStatic: e, allowExact: s, allowSpread: i, allowProto: r, allowInexact: n }) {
let o = this.state.inType;
this.state.inType = !0;
let h = this.startNode();
h.callProperties = [], h.properties = [], h.indexers = [], h.internalSlots = [];
let l, u, f = !1;
for (s && this.match(6) ? (this.expect(6), l = 9, u = !0) : (this.expect(5), l = 8, u = !1), h.exact = u; !this.match(l); ) {
let x = !1, A = null, k = null, N = this.startNode();
if (r && this.isContextual(118)) {
let I = this.lookahead();
I.type !== 14 && I.type !== 17 && (this.next(), A = this.state.startLoc, e = !1);
}
if (e && this.isContextual(106)) {
let I = this.lookahead();
I.type !== 14 && I.type !== 17 && (this.next(), x = !0);
}
let C = this.flowParseVariance();
if (this.eat(0)) A != null && this.unexpected(A), this.eat(0) ? (C && this.unexpected(C.loc.start), h.internalSlots.push(this.flowParseObjectTypeInternalSlot(N, x))) : h.indexers.push(this.flowParseObjectTypeIndexer(N, x, C));
else if (this.match(10) || this.match(47)) A != null && this.unexpected(A), C && this.unexpected(C.loc.start), h.callProperties.push(this.flowParseObjectTypeCallProperty(N, x));
else {
let I = "init";
if (this.isContextual(99) || this.isContextual(104)) {
let ae = this.lookahead();
Jt(ae.type) && (I = this.state.value, this.next());
}
let Pe = this.flowParseObjectTypeProperty(N, x, A, C, I, i, n ?? !u);
Pe === null ? (f = !0, k = this.state.lastTokStartLoc) : h.properties.push(Pe);
}
this.flowObjectTypeSemicolon(), k && !this.match(8) && !this.match(9) && this.raise(g.UnexpectedExplicitInexactInObject, k);
}
this.expect(l), i && (h.inexact = f);
let d = this.finishNode(h, "ObjectTypeAnnotation");
return this.state.inType = o, d;
}
flowParseObjectTypeProperty(e, s, i, r, n, o, h) {
if (this.eat(21)) return this.match(12) || this.match(13) || this.match(8) || this.match(9) ? (o ? h || this.raise(g.InexactInsideExact, this.state.lastTokStartLoc) : this.raise(g.InexactInsideNonObject, this.state.lastTokStartLoc), r && this.raise(g.InexactVariance, r), null) : (o || this.raise(g.UnexpectedSpreadType, this.state.lastTokStartLoc), i != null && this.unexpected(i), r && this.raise(g.SpreadVariance, r), e.argument = this.flowParseType(), this.finishNode(e, "ObjectTypeSpreadProperty"));
{
e.key = this.flowParseObjectPropertyKey(), e.static = s, e.proto = i != null, e.kind = n;
let l = !1;
return this.match(47) || this.match(10) ? (e.method = !0, i != null && this.unexpected(i), r && this.unexpected(r.loc.start), e.value = this.flowParseObjectTypeMethodish(this.startNodeAt(e.loc.start)), (n === "get" || n === "set") && this.flowCheckGetterSetterParams(e), !o && e.key.name === "constructor" && e.value.this && this.raise(g.ThisParamBannedInConstructor, e.value.this)) : (n !== "init" && this.unexpected(), e.method = !1, this.eat(17) && (l = !0), e.value = this.flowParseTypeInitialiser(), e.variance = r), e.optional = l, this.finishNode(e, "ObjectTypeProperty");
}
}
flowCheckGetterSetterParams(e) {
let s = e.kind === "get" ? 0 : 1, i = e.value.params.length + (e.value.rest ? 1 : 0);
e.value.this && this.raise(e.kind === "get" ? g.GetterMayNotHaveThisParam : g.SetterMayNotHaveThisParam, e.value.this), i !== s && this.raise(e.kind === "get" ? p.BadGetterArity : p.BadSetterArity, e), e.kind === "set" && e.value.rest && this.raise(p.BadSetterRestParameter, e);
}
flowObjectTypeSemicolon() {
!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9) && this.unexpected();
}
flowParseQualifiedTypeIdentifier(e, s) {
e ?? (e = this.state.startLoc);
let i = s || this.flowParseRestrictedIdentifier(!0);
for (; this.eat(16); ) {
let r = this.startNodeAt(e);
r.qualification = i, r.id = this.flowParseRestrictedIdentifier(!0), i = this.finishNode(r, "QualifiedTypeIdentifier");
}
return i;
}
flowParseGenericType(e, s) {
let i = this.startNodeAt(e);
return i.typeParameters = null, i.id = this.flowParseQualifiedTypeIdentifier(e, s), this.match(47) && (i.typeParameters = this.flowParseTypeParameterInstantiation()), this.finishNode(i, "GenericTypeAnnotation");
}
flowParseTypeofType() {
let e = this.startNode();
return this.expect(87), e.argument = this.flowParsePrimaryType(), this.finishNode(e, "TypeofTypeAnnotation");
}
flowParseTupleType() {
let e = this.startNode();
for (e.types = [], this.expect(0); this.state.pos < this.length && !this.match(3) && (e.types.push(this.flowParseType()), !this.match(3)); ) this.expect(12);
return this.expect(3), this.finishNode(e, "TupleTypeAnnotation");
}
flowParseFunctionTypeParam(e) {
let s = null, i = !1, r = null, n = this.startNode(), o = this.lookahead(), h = this.state.type === 78;
return o.type === 14 || o.type === 17 ? (h && !e && this.raise(g.ThisParamMustBeFirst, n), s = this.parseIdentifier(h), this.eat(17) && (i = !0, h && this.raise(g.ThisParamMayNotBeOptional, n)), r = this.flowParseTypeInitialiser()) : r = this.flowParseType(), n.name = s, n.optional = i, n.typeAnnotation = r, this.finishNode(n, "FunctionTypeParam");
}
reinterpretTypeAsFunctionTypeParam(e) {
let s = this.startNodeAt(e.loc.start);
return s.name = null, s.optional = !1, s.typeAnnotation = e, this.finishNode(s, "FunctionTypeParam");
}
flowParseFunctionTypeParams(e = []) {
let s = null, i = null;
for (this.match(78) && (i = this.flowParseFunctionTypeParam(!0), i.name = null, this.match(11) || this.expect(12)); !this.match(11) && !this.match(21); ) e.push(this.flowParseFunctionTypeParam(!1)), this.match(11) || this.expect(12);
return this.eat(21) && (s = this.flowParseFunctionTypeParam(!1)), { params: e, rest: s, _this: i };
}
flowIdentToTypeAnnotation(e, s, i) {
switch (i.name) {
case "any":
return this.finishNode(s, "AnyTypeAnnotation");
case "bool":
case "boolean":
return this.finishNode(s, "BooleanTypeAnnotation");
case "mixed":
return this.finishNode(s, "MixedTypeAnnotation");
case "empty":
return this.finishNode(s, "EmptyTypeAnnotation");
case "number":
return this.finishNode(s, "NumberTypeAnnotation");
case "string":
return this.finishNode(s, "StringTypeAnnotation");
case "symbol":
return this.finishNode(s, "SymbolTypeAnnotation");
default:
return this.checkNotUnderscore(i.name), this.flowParseGenericType(e, i);
}
}
flowParsePrimaryType() {
let e = this.state.startLoc, s = this.startNode(), i, r, n = !1, o = this.state.noAnonFunctionType;
switch (this.state.type) {
case 5:
return this.flowParseObjectType({ allowStatic: !1, allowExact: !1, allowSpread: !0, allowProto: !1, allowInexact: !0 });
case 6:
return this.flowParseObjectType({ allowStatic: !1, allowExact: !0, allowSpread: !0, allowProto: !1, allowInexact: !1 });
case 0:
return this.state.noAnonFunctionType = !1, r = this.flowParseTupleType(), this.state.noAnonFunctionType = o, r;
case 47: {
let h = this.startNode();
return h.typeParameters = this.flowParseTypeParameterDeclaration(), this.expect(10), i = this.flowParseFunctionTypeParams(), h.params = i.params, h.rest = i.rest, h.this = i._this, this.expect(11), this.expect(19), h.returnType = this.flowParseType(), this.finishNode(h, "FunctionTypeAnnotation");
}
case 10: {
let h = this.startNode();
if (this.next(), !this.match(11) && !this.match(21)) if (w(this.state.type) || this.match(78)) {
let l = this.lookahead().type;
n = l !== 17 && l !== 14;
} else n = !0;
if (n) {
if (this.state.noAnonFunctionType = !1, r = this.flowParseType(), this.state.noAnonFunctionType = o, this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) return this.expect(11), r;
this.eat(12);
}
return r ? i = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(r)]) : i = this.flowParseFunctionTypeParams(), h.params = i.params, h.rest = i.rest, h.this = i._this, this.expect(11), this.expect(19), h.returnType = this.flowParseType(), h.typeParameters = null, this.finishNode(h, "FunctionTypeAnnotation");
}
case 134:
return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
case 85:
case 86:
return s.value = this.match(85), this.next(), this.finishNode(s, "BooleanLiteralTypeAnnotation");
case 53:
if (this.state.value === "-") {
if (this.next(), this.match(135)) return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", s);
if (this.match(136)) return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", s);
throw this.raise(g.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:
return this.next(), this.finishNode(s, "VoidTypeAnnotation");
case 84:
return this.next(), this.finishNode(s, "NullLiteralTypeAnnotation");
case 78:
return this.next(), this.finishNode(s, "ThisTypeAnnotation");
case 55:
return this.next(), this.finishNode(s, "ExistsTypeAnnotation");
case 87:
return this.flowParseTypeofType();
default:
if (Tt(this.state.type)) {
let h = z(this.state.type);
return this.next(), super.createIdentifier(s, h);
} else if (w(this.state.type)) return this.isContextual(129) ? this.flowParseInterfaceType() : this.flowIdentToTypeAnnotation(e, s, this.parseIdentifier());
}
throw this.unexpected();
}
flowParsePostfixType() {
let e = this.state.startLoc, s = this.flowParsePrimaryType(), i = !1;
for (; (this.match(0) || this.match(18)) && !this.canInsertSemicolon(); ) {
let r = this.startNodeAt(e), n = this.eat(18);
i = i || n, this.expect(0), !n && this.match(3) ? (r.elementType = s, this.next(), s = this.finishNode(r, "ArrayTypeAnnotation")) : (r.objectType = s, r.indexType = this.flowParseType(), this.expect(3), i ? (r.optional = n, s = this.finishNode(r, "OptionalIndexedAccessType")) : s = this.finishNode(r, "IndexedAccessType"));
}
return s;
}
flowParsePrefixType() {
let e = this.startNode();
return this.eat(17) ? (e.typeAnnotation = this.flowParsePrefixType(), this.finishNode(e, "NullableTypeAnnotation")) : this.flowParsePostfixType();
}
flowParseAnonFunctionWithoutParens() {
let e = this.flowParsePrefixType();
if (!this.state.noAnonFunctionType && this.eat(19)) {
let s = this.startNodeAt(e.loc.start);
return s.params = [this.reinterpretTypeAsFunctionTypeParam(e)], s.rest = null, s.this = null, s.returnType = this.flowParseType(), s.typeParameters = null, this.finishNode(s, "FunctionTypeAnnotation");
}
return e;
}
flowParseIntersectionType() {
let e = this.startNode();
this.eat(45);
let s = this.flowParseAnonFunctionWithoutParens();
for (e.types = [s]; this.eat(45); ) e.types.push(this.flowParseAnonFunctionWithoutParens());
return e.types.length === 1 ? s : this.finishNode(e, "IntersectionTypeAnnotation");
}
flowParseUnionType() {
let e = this.startNode();
this.eat(43);
let s = this.flowParseIntersectionType();
for (e.types = [s]; this.eat(43); ) e.types.push(this.flowParseIntersectionType());
return e.types.length === 1 ? s : this.finishNode(e, "UnionTypeAnnotation");
}
flowParseType() {
let e = this.state.inType;
this.state.inType = !0;
let s = this.flowParseUnionType();
return this.state.inType = e, s;
}
flowParseTypeOrImplicitInstantiation() {
if (this.state.type === 132 && this.state.value === "_") {
let e = this.state.startLoc, s = this.parseIdentifier();
return this.flowParseGenericType(e, s);
} else return this.flowParseType();
}
flowParseTypeAnnotation() {
let e = this.startNode();
return e.typeAnnotation = this.flowParseTypeInitialiser(), this.finishNode(e, "TypeAnnotation");
}
flowParseTypeAnnotatableIdentifier(e) {
let s = e ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
return this.match(14) && (s.typeAnnotation = this.flowParseTypeAnnotation(), this.resetEndLocation(s)), s;
}
typeCastToParameter(e) {
return e.expression.typeAnnotation = e.typeAnnotation, this.resetEndLocation(e.expression, e.typeAnnotation.loc.end), e.expression;
}
flowParseVariance() {
let e = null;
return this.match(53) ? (e = this.startNode(), this.state.value === "+" ? e.kind = "plus" : e.kind = "minus", this.next(), this.finishNode(e, "Variance")) : e;
}
parseFunctionBody(e, s, i = !1) {
if (s) {
this.forwardNoArrowParamsConversionAt(e, () => super.parseFunctionBody(e, !0, i));
return;
}
super.parseFunctionBody(e, !1, i);
}
parseFunctionBodyAndFinish(e, s, i = !1) {
if (this.match(14)) {
let r = this.startNode();
[r.typeAnnotation, e.predicate] = this.flowParseTypeAndPredicateInitialiser(), e.returnType = r.typeAnnotation ? this.finishNode(r, "TypeAnnotation") : null;
}
return super.parseFunctionBodyAndFinish(e, s, i);
}
parseStatementLike(e) {
if (this.state.strict && this.isContextual(129)) {
let i = this.lookahead();
if (O(i.type)) {
let r = this.startNode();
return this.next(), this.flowParseInterface(r);
}
} else if (this.isContextual(126)) {
let i = this.startNode();
return this.next(), this.flowParseEnumDeclaration(i);
}
let s = super.parseStatementLike(e);
return this.flowPragma === void 0 && !this.isValidDirective(s) && (this.flowPragma = null), s;
}
parseExpressionStatement(e, s, i) {
if (s.type === "Identifier") {
if (s.name === "declare") {
if (this.match(80) || w(this.state.type) || this.match(68) || this.match(74) || this.match(82)) return this.flowParseDeclare(e);
} else if (w(this.state.type)) {
if (s.name === "interface") return this.flowParseInterface(e);
if (s.name === "type") return this.flowParseTypeAlias(e);
if (s.name === "opaque") return this.flowParseOpaqueType(e, !1);
}
}
return super.parseExpressionStatement(e, s, i);
}
shouldParseExportDeclaration() {
let { type: e } = this.state;
return e === 126 || Bt(e) ? !this.state.containsEsc : super.shouldParseExportDeclaration();
}
isExportDefaultSpecifier() {
let { type: e } = this.state;
return e === 126 || Bt(e) ? this.state.containsEsc : super.isExportDefaultSpecifier();
}
parseExportDefaultExpression() {
if (this.isContextual(126)) {
let e = this.startNode();
return this.next(), this.flowParseEnumDeclaration(e);
}
return super.parseExportDefaultExpression();
}
parseConditional(e, s, i) {
if (!this.match(17)) return e;
if (this.state.maybeInArrowParameters) {
let d = this.lookaheadCharCode();
if (d === 44 || d === 61 || d === 58 || d === 41) return this.setOptionalParametersError(i), e;
}
this.expect(17);
let r = this.state.clone(), n = this.state.noArrowAt, o = this.startNodeAt(s), { consequent: h, failed: l } = this.tryParseConditionalConsequent(), [u, f] = this.getArrowLikeExpressions(h);
if (l || f.length > 0) {
let d = [...n];
if (f.length > 0) {
this.state = r, this.state.noArrowAt = d;
for (let x = 0; x < f.length; x++) d.push(f[x].start);
({ consequent: h, failed: l } = this.tryParseConditionalConsequent()), [u, f] = this.getArrowLikeExpressions(h);
}
l && u.length > 1 && this.raise(g.AmbiguousConditionalArrow, r.startLoc), l && u.length === 1 && (this.state = r, d.push(u[0].start), this.state.noArrowAt = d, { consequent: h, failed: l } = this.tryParseConditionalConsequent());
}
return this.getArrowLikeExpressions(h, !0), this.state.noArrowAt = n, this.expect(14), o.test = e, o.consequent = h, o.alternate = this.forwardNoArrowParamsConversionAt(o, () => this.parseMaybeAssign(void 0, void 0)), this.finishNode(o, "ConditionalExpression");
}
tryParseConditionalConsequent() {
this.state.noArrowParamsConversionAt.push(this.state.start);
let e = this.parseMaybeAssignAllowIn(), s = !this.match(14);
return this.state.noArrowParamsConversionAt.pop(), { consequent: e, failed: s };
}
getArrowLikeExpressions(e, s) {
let i = [e], r = [];
for (; i.length !== 0; ) {
let n = i.pop();
n.type === "ArrowFunctionExpression" && n.body.type !== "BlockStatement" ? (n.typeParameters || !n.returnType ? this.finishArrowValidation(n) : r.push(n), i.push(n.body)) : n.type === "ConditionalExpression" && (i.push(n.consequent), i.push(n.alternate));
}
return s ? (r.forEach((n) => this.finishArrowValidation(n)), [r, []]) : Li(r, (n) => n.params.every((o) => this.isAssignable(o, !0)));
}
finishArrowValidation(e) {
this.toAssignableList(e.params, e.extra?.trailingCommaLoc, !1), this.scope.enter(518), super.checkParams(e, !1, !0), this.scope.exit();
}
forwardNoArrowParamsConversionAt(e, s) {
let i;
return this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(e.start)) ? (this.state.noArrowParamsConversionAt.push(this.state.start), i = s(), this.state.noArrowParamsConversionAt.pop()) : i = s(), i;
}
parseParenItem(e, s) {
let i = super.parseParenItem(e, s);
if (this.eat(17) && (i.optional = !0, this.resetEndLocation(e)), this.match(14)) {
let r = this.startNodeAt(s);
return r.expression = i, r.typeAnnotation = this.flowParseTypeAnnotation(), this.finishNode(r, "TypeCastExpression");
}
return i;
}
assertModuleNodeAllowed(e) {
e.type === "ImportDeclaration" && (e.importKind === "type" || e.importKind === "typeof") || e.type === "ExportNamedDeclaration" && e.exportKind === "type" || e.type === "ExportAllDeclaration" && e.exportKind === "type" || super.assertModuleNodeAllowed(e);
}
parseExportDeclaration(e) {
if (this.isContextual(130)) {
e.exportKind = "type";
let s = this.startNode();
return this.next(), this.match(5) ? (e.specifiers = this.parseExportSpecifiers(!0), super.parseExportFrom(e), null) : this.flowParseTypeAlias(s);
} else if (this.isContextual(131)) {
e.exportKind = "type";
let s = this.startNode();
return this.next(), this.flowParseOpaqueType(s, !1);
} else if (this.isContextual(129)) {
e.exportKind = "type";
let s = this.startNode();
return this.next(), this.flowParseInterface(s);
} else if (this.isContextual(126)) {
e.exportKind = "value";
let s = this.startNode();
return this.next(), this.flowParseEnumDeclaration(s);
} else return super.parseExportDeclaration(e);
}
eatExportStar(e) {
return super.eatExportStar(e) ? !0 : this.isContextual(130) && this.lookahead().type === 55 ? (e.exportKind = "type", this.next(), this.next(), !0) : !1;
}
maybeParseExportNamespaceSpecifier(e) {
let { startLoc: s } = this.state, i = super.maybeParseExportNamespaceSpecifier(e);
return i && e.exportKind === "type" && this.unexpected(s), i;
}
parseClassId(e, s, i) {
super.parseClassId(e, s, i), this.match(47) && (e.typeParameters = this.flowParseTypeParameterDeclaration());
}
parseClassMember(e, s, i) {
let { startLoc: r } = this.state;
if (this.isContextual(125)) {
if (super.parseClassMemberFromModifier(e, s)) return;
s.declare = !0;
}
super.parseClassMember(e, s, i), s.declare && (s.type !== "ClassProperty" && s.type !== "ClassPrivateProperty" && s.type !== "PropertyDefinition" ? this.raise(g.DeclareClassElement, r) : s.value && this.raise(g.DeclareClassFieldInitializer, s.value));
}
isIterator(e) {
return e === "iterator" || e === "asyncIterator";
}
readIterator() {
let e = super.readWord1(), s = "@@" + e;
(!this.isIterator(e) || !this.state.inType) && this.raise(p.InvalidIdentifier, this.state.curPosition(), { identifierName: s }), this.finishToken(132, s);
}
getTokenFromCode(e) {
let s = this.input.charCodeAt(this.state.pos + 1);
e === 123 && s === 124 ? this.finishOp(6, 2) : this.state.inType && (e === 62 || e === 60) ? this.finishOp(e === 62 ? 48 : 47, 1) : this.state.inType && e === 63 ? s === 46 ? this.finishOp(18, 2) : this.finishOp(17, 1) : Ci(e, s, this.input.charCodeAt(this.state.pos + 2)) ? (this.state.pos += 2, this.readIterator()) : super.getTokenFromCode(e);
}
isAssignable(e, s) {
return e.type === "TypeCastExpression" ? this.isAssignable(e.expression, s) : super.isAssignable(e, s);
}
toAssignable(e, s = !1) {
!s && e.type === "AssignmentExpression" && e.left.type === "TypeCastExpression" && (e.left = this.typeCastToParameter(e.left)), super.toAssignable(e, s);
}
toAssignableList(e, s, i) {
for (let r = 0; r < e.length; r++) {
let n = e[r];
n?.type === "TypeCastExpression" && (e[r] = this.typeCastToParameter(n));
}
super.toAssignableList(e, s, i);
}
toReferencedList(e, s) {
for (let i = 0; i < e.length; i++) {
let r = e[i];
r && r.type === "TypeCastExpression" && !r.extra?.parenthesized && (e.length > 1 || !s) && this.raise(g.TypeCastInPattern, r.typeAnnotation);
}
return e;
}
parseArrayLike(e, s, i) {
let r = super.parseArrayLike(e, s, i);
return i != null && !this.state.maybeInArrowParameters && this.toReferencedList(r.elements), r;
}
isValidLVal(e, s, i, r) {
return e === "TypeCastExpression" || super.isValidLVal(e, s, i, r);
}
parseClassProperty(e) {
return this.match(14) && (e.typeAnnotation = this.flowParseTypeAnnotation()), super.parseClassProperty(e);
}
parseClassPrivateProperty(e) {
return this.match(14) && (e.typeAnnotation = this.flowParseTypeAnnotation()), super.parseClassPrivateProperty(e);
}
isClassMethod() {
return this.match(47) || super.isClassMethod();
}
isClassProperty() {
return this.match(14) || super.isClassProperty();
}
isNonstaticConstructor(e) {
return !this.match(14) && super.isNonstaticConstructor(e);
}
pushClassMethod(e, s, i, r, n, o) {
if (s.variance && this.unexpected(s.variance.loc.start), delete s.variance, this.match(47) && (s.typeParameters = this.flowParseTypeParameterDeclaration()), super.pushClassMethod(e, s, i, r, n, o), s.params && n) {
let h = s.params;
h.length > 0 && this.isThisParam(h[0]) && this.raise(g.ThisParamBannedInConstructor, s);
} else if (s.type === "MethodDefinition" && n && s.value.params) {
let h = s.value.params;
h.length > 0 && this.isThisParam(h[0]) && this.raise(g.ThisParamBannedInConstructor, s);
}
}
pushClassPrivateMethod(e, s, i, r) {
s.variance && this.unexpected(s.variance.loc.start), delete s.variance, this.match(47) && (s.typeParameters = this.flowParseTypeParameterDeclaration()), super.pushClassPrivateMethod(e, s, i, r);
}
parseClassSuper(e) {
if (super.parseClassSuper(e), e.superClass && (this.match(47) || this.match(51)) && (e.superTypeArguments = this.flowParseTypeParameterInstantiationInExpression()), this.isContextual(113)) {
this.next();
let s = e.implements = [];
do {
let i = this.startNode();
i.id = this.flowParseRestrictedIdentifier(!0), this.match(47) ? i.typeParameters = this.flowParseTypeParameterInstantiation() : i.typeParameters = null, s.push(this.finishNode(i, "ClassImplements"));
} while (this.eat(12));
}
}
checkGetterSetterParams(e) {
super.checkGetterSetterParams(e);
let s = this.getObjectOrClassMethodParams(e);
if (s.length > 0) {
let i = s[0];
this.isThisParam(i) && e.kind === "get" ? this.raise(g.GetterMayNotHaveThisParam, i) : this.isThisParam(i) && this.raise(g.SetterMayNotHaveThisParam, i);
}
}
parsePropertyNamePrefixOperator(e) {
e.variance = this.flowParseVariance();
}
parseObjPropValue(e, s, i, r, n, o, h) {
e.variance && this.unexpected(e.variance.loc.start), delete e.variance;
let l;
this.match(47) && !o && (l = this.flowParseTypeParameterDeclaration(), this.match(10) || this.unexpected());
let u = super.parseObjPropValue(e, s, i, r, n, o, h);
return l && ((u.value || u).typeParameters = l), u;
}
parseFunctionParamType(e) {
return this.eat(17) && (e.type !== "Identifier" && this.raise(g.PatternIsOptional, e), this.isThisParam(e) && this.raise(g.ThisParamMayNotBeOptional, e), e.optional = !0), this.match(14) ? e.typeAnnotation = this.flowParseTypeAnnotation() : this.isThisParam(e) && this.raise(g.ThisParamAnnotationRequired, e), this.match(29) && this.isThisParam(e) && this.raise(g.ThisParamNoDefault, e), this.resetEndLocation(e), e;
}
parseMaybeDefault(e, s) {
let i = super.parseMaybeDefault(e, s);
return i.type === "AssignmentPattern" && i.typeAnnotation && i.right.start < i.typeAnnotation.start && this.raise(g.TypeBeforeInitializer, i.typeAnnotation), i;
}
checkImportReflection(e) {
super.checkImportReflection(e), e.module && e.importKind !== "value" && this.raise(g.ImportReflectionHasImportType, e.specifiers[0].loc.start);
}
parseImportSpecifierLocal(e, s, i) {
s.local = Rt(e) ? this.flowParseRestrictedIdentifier(!0, !0) : this.parseIdentifier(), e.specifiers.push(this.finishImportSpecifier(s, i));
}
isPotentialImportPhase(e) {
if (super.isPotentialImportPhase(e)) return !0;
if (this.isContextual(130)) {
if (!e) return !0;
let s = this.lookaheadCharCode();
return s === 123 || s === 42;
}
return !e && this.isContextual(87);
}
applyImportPhase(e, s, i, r) {
if (super.applyImportPhase(e, s, i, r), s) {
if (!i && this.match(65)) return;
e.exportKind = i === "type" ? i : "value";
} else i === "type" && this.match(55) && this.unexpected(), e.importKind = i === "type" || i === "typeof" ? i : "value";
}
parseImportSpecifier(e, s, i, r, n) {
let o = e.imported, h = null;
o.type === "Identifier" && (o.name === "type" ? h = "type" : o.name === "typeof" && (h = "typeof"));
let l = !1;
if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
let f = this.parseIdentifier(!0);
h !== null && !O(this.state.type) ? (e.imported = f, e.importKind = h, e.local = this.cloneIdentifier(f)) : (e.imported = o, e.importKind = null, e.local = this.parseIdentifier());
} else {
if (h !== null && O(this.state.type)) e.imported = this.parseIdentifier(!0), e.importKind = h;
else {
if (s) throw this.raise(p.ImportBindingIsString, e, { importName: o.value });
e.imported = o, e.importKind = null;
}
this.eatContextual(93) ? e.local = this.parseIdentifier() : (l = !0, e.local = this.cloneIdentifier(e.imported));
}
let u = Rt(e);
return i && u && this.raise(g.ImportTypeShorthandOnlyInPureImport, e), (i || u) && this.checkReservedType(e.local.name, e.local.loc.start, !0), l && !i && !u && this.checkReservedWord(e.local.name, e.loc.start, !0, !0), this.finishImportSpecifier(e, "ImportSpecifier");
}
parseBindingAtom() {
return this.state.type === 78 ? this.parseIdentifier(!0) : super.parseBindingAtom();
}
parseFunctionParams(e, s) {
let i = e.kind;
i !== "get" && i !== "set" && this.match(47) && (e.typeParameters = this.flowParseTypeParameterDeclaration()), super.parseFunctionParams(e, s);
}
parseVarId(e, s) {
super.parseVarId(e, s), this.match(14) && (e.id.typeAnnotation = this.flowParseTypeAnnotation(), this.resetEndLocation(e.id));
}
parseAsyncArrowFromCallExpression(e, s) {
if (this.match(14)) {
let i = this.state.noAnonFunctionType;
this.state.noAnonFunctionType = !0, e.returnType = this.flowParseTypeAnnotation(), this.state.noAnonFunctionType = i;
}
return super.parseAsyncArrowFromCallExpression(e, s);
}
shouldParseAsyncArrow() {
return this.match(14) || super.shouldParseAsyncArrow();
}
parseMaybeAssign(e, s) {
let i = null, r;
if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
if (i = this.state.clone(), r = this.tryParse(() => super.parseMaybeAssign(e, s), i), !r.error) return r.node;
let { context: n } = this.state, o = n[n.length - 1];
(o === E.j_oTag || o === E.j_expr) && n.pop();
}
if (r?.error || this.match(47)) {
i = i || this.state.clone();
let n, o = this.tryParse((l) => {
n = this.flowParseTypeParameterDeclaration();
let u = this.forwardNoArrowParamsConversionAt(n, () => {
let d = super.parseMaybeAssign(e, s);
return this.resetStartLocationFromNode(d, n), d;
});
u.extra?.parenthesized && l();
let f = this.maybeUnwrapTypeCastExpression(u);
return f.type !== "ArrowFunctionExpression" && l(), f.typeParameters = n, this.resetStartLocationFromNode(f, n), u;
}, i), h = null;
if (o.node && this.maybeUnwrapTypeCastExpression(o.node).type === "ArrowFunctionExpression") {
if (!o.error && !o.aborted) return o.node.async && this.raise(g.UnexpectedTypeParameterBeforeAsyncArrowFunction, n), o.node;
h = o.node;
}
if (r?.node) return this.state = r.failState, r.node;
if (h) return this.state = o.failState, h;
throw r?.thrown ? r.error : o.thrown ? o.error : this.raise(g.UnexpectedTokenAfterTypeParameter, n);
}
return super.parseMaybeAssign(e, s);
}
parseArrow(e) {
if (this.match(14)) {
let s = this.tryParse(() => {
let i = this.state.noAnonFunctionType;
this.state.noAnonFunctionType = !0;
let r = this.startNode();
return [r.typeAnnotation, e.predicate] = this.flowParseTypeAndPredicateInitialiser(), this.state.noAnonFunctionType = i, this.canInsertSemicolon() && this.unexpected(), this.match(19) || this.unexpected(), r;
});
if (s.thrown) return null;
s.error && (this.state = s.failState), e.returnType = s.node.typeAnnotation ? this.finishNode(s.node, "TypeAnnotation") : null;
}
return super.parseArrow(e);
}
shouldParseArrow(e) {
return this.match(14) || super.shouldParseArrow(e);
}
setArrowFunctionParameters(e, s) {
this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(e.start)) ? e.params = s : super.setArrowFunctionParameters(e, s);
}
checkParams(e, s, i, r = !0) {
if (!(i && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(e.start)))) {
for (let n = 0; n < e.params.length; n++) this.isThisParam(e.params[n]) && n > 0 && this.raise(g.ThisParamMustBeFirst, e.params[n]);
super.checkParams(e, s, i, r);
}
}
parseParenAndDistinguishExpression(e) {
return super.parseParenAndDistinguishExpression(e && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
}
parseSubscripts(e, s, i) {
if (e.type === "Identifier" && e.name === "async" && this.state.noArrowAt.includes(s.index)) {
this.next();
let r = this.startNodeAt(s);
r.callee = e, r.arguments = super.parseCallExpressionArguments(), e = this.finishNode(r, "CallExpression");
} else if (e.type === "Identifier" && e.name === "async" && this.match(47)) {
let r = this.state.clone(), n = this.tryParse((h) => this.parseAsyncArrowWithTypeParameters(s) || h(), r);
if (!n.error && !n.aborted) return n.node;
let o = this.tryParse(() => super.parseSubscripts(e, s, i), r);
if (o.node && !o.error) return o.node;
if (n.node) return this.state = n.failState, n.node;
if (o.node) return this.state = o.failState, o.node;
throw n.error || o.error;
}
return super.parseSubscripts(e, s, i);
}
parseSubscript(e, s, i, r) {
if (this.match(18) && this.isLookaheadToken_lt()) {
if (r.optionalChainMember = !0, i) return r.stop = !0, e;
this.next();
let n = this.startNodeAt(s);
return n.callee = e, n.typeArguments = this.flowParseTypeParameterInstantiationInExpression(), this.expect(10), n.arguments = this.parseCallExpressionArguments(), n.optional = !0, this.finishCallExpression(n, !0);
} else if (!i && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
let n = this.startNodeAt(s);
n.callee = e;
let o = this.tryParse(() => (n.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew(), this.expect(10), n.arguments = super.parseCallExpressionArguments(), r.optionalChainMember && (n.optional = !1), this.finishCallExpression(n, r.optionalChainMember)));
if (o.node) return o.error && (this.state = o.failState), o.node;
}
return super.parseSubscript(e, s, i, r);
}
parseNewCallee(e) {
super.parseNewCallee(e);
let s = null;
this.shouldParseTypes() && this.match(47) && (s = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node), e.typeArguments = s;
}
parseAsyncArrowWithTypeParameters(e) {
let s = this.startNodeAt(e);
if (this.parseFunctionParams(s, !1), !!this.parseArrow(s)) return super.parseArrowExpression(s, void 0, !0);
}
readToken_mult_modulo(e) {
let s = this.input.charCodeAt(this.state.pos + 1);
if (e === 42 && s === 47 && this.state.hasFlowComment) {
this.state.hasFlowComment = !1, this.state.pos += 2, this.nextToken();
return;
}
super.readToken_mult_modulo(e);
}
readToken_pipe_amp(e) {
let s = this.input.charCodeAt(this.state.pos + 1);
if (e === 124 && s === 125) {
this.finishOp(9, 2);
return;
}
super.readToken_pipe_amp(e);
}
parseTopLevel(e, s) {
let i = super.parseTopLevel(e, s);
return this.state.hasFlowComment && this.raise(g.UnterminatedFlowComment, this.state.curPosition()), i;
}
skipBlockComment() {
if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
if (this.state.hasFlowComment) throw this.raise(g.NestedFlowComment, this.state.startLoc);
this.hasFlowCommentCompletion();
let e = this.skipFlowComment();
e && (this.state.pos += e, this.state.hasFlowComment = !0);
return;
}
return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
}
skipFlowComment() {
let { pos: e } = this.state, s = 2;
for (; [32, 9].includes(this.input.charCodeAt(e + s)); ) s++;
let i = this.input.charCodeAt(s + e), r = this.input.charCodeAt(s + e + 1);
return i === 58 && r === 58 ? s + 2 : this.input.slice(s + e, s + e + 12) === "flow-include" ? s + 12 : i === 58 && r !== 58 ? s : !1;
}
hasFlowCommentCompletion() {
if (this.input.indexOf("*/", this.state.pos) === -1) throw this.raise(p.UnterminatedComment, this.state.curPosition());
}
flowEnumErrorBooleanMemberNotInitialized(e, { enumName: s, memberName: i }) {
this.raise(g.EnumBooleanMemberNotInitialized, e, { memberName: i, enumName: s });
}
flowEnumErrorInvalidMemberInitializer(e, s) {
return this.raise(s.explicitType ? s.explicitType === "symbol" ? g.EnumInvalidMemberInitializerSymbolType : g.EnumInvalidMemberInitializerPrimaryType : g.EnumInvalidMemberInitializerUnknownType, e, s);
}
flowEnumErrorNumberMemberNotInitialized(e, s) {
this.raise(g.EnumNumberMemberNotInitialized, e, s);
}
flowEnumErrorStringMemberInconsistentlyInitialized(e, s) {
this.raise(g.EnumStringMemberInconsistentlyInitialized, e, s);
}
flowEnumMemberInit() {
let e = this.state.startLoc, s = () => this.match(12) || this.match(8);
switch (this.state.type) {
case 135: {
let i = this.parseNumericLiteral(this.state.value);
return s() ? { type: "number", loc: i.loc.start, value: i } : { type: "invalid", loc: e };
}
case 134: {
let i = this.parseStringLiteral(this.state.value);
return s() ? { type: "string", loc: i.loc.start, value: i } : { type: "invalid", loc: e };
}
case 85:
case 86: {
let i = this.parseBooleanLiteral(this.match(85));
return s() ? { type: "boolean", loc: i.loc.start, value: i } : { type: "invalid", loc: e };
}
default:
return { type: "invalid", loc: e };
}
}
flowEnumMemberRaw() {
let e = this.state.startLoc, s = this.parseIdentifier(!0), i = this.eat(29) ? this.flowEnumMemberInit() : { type: "none", loc: e };
return { id: s, init: i };
}
flowEnumCheckExplicitTypeMismatch(e, s, i) {
let { explicitType: r } = s;
r !== null && r !== i && this.flowEnumErrorInvalidMemberInitializer(e, s);
}
flowEnumMembers({ enumName: e, explicitType: s }) {
let i = /* @__PURE__ */ new Set(), r = { booleanMembers: [], numberMembers: [], stringMembers: [], defaultedMembers: [] }, n = !1;
for (; !this.match(8); ) {
if (this.eat(21)) {
n = !0;
break;
}
let o = this.startNode(), { id: h, init: l } = this.flowEnumMemberRaw(), u = h.name;
if (u === "") continue;
/^[a-z]/.test(u) && this.raise(g.EnumInvalidMemberName, h, { memberName: u, suggestion: u[0].toUpperCase() + u.slice(1), enumName: e }), i.has(u) && this.raise(g.EnumDuplicateMemberName, h, { memberName: u, enumName: e }), i.add(u);
let f = { enumName: e, explicitType: s, memberName: u };
switch (o.id = h, l.type) {
case "boolean": {
this.flowEnumCheckExplicitTypeMismatch(l.loc, f, "boolean"), o.init = l.value, r.booleanMembers.push(this.finishNode(o, "EnumBooleanMember"));
break;
}
case "number": {
this.flowEnumCheckExplicitTypeMismatch(l.loc, f, "number"), o.init = l.value, r.numberMembers.push(this.finishNode(o, "EnumNumberMember"));
break;
}
case "string": {
this.flowEnumCheckExplicitTypeMismatch(l.loc, f, "string"), o.init = l.value, r.stringMembers.push(this.finishNode(o, "EnumStringMember"));
break;
}
case "invalid":
throw this.flowEnumErrorInvalidMemberInitializer(l.loc, f);
case "none":
switch (s) {
case "boolean":
this.flowEnumErrorBooleanMemberNotInitialized(l.loc, f);
break;
case "number":
this.flowEnumErrorNumberMemberNotInitialized(l.loc, f);
break;
default:
r.defaultedMembers.push(this.finishNode(o, "EnumDefaultedMember"));
}
}
this.match(8) || this.expect(12);
}
return { members: r, hasUnknownMembers: n };
}
flowEnumStringMembers(e, s, { enumName: i }) {
if (e.length === 0) return s;
if (s.length === 0) return e;
if (s.length > e.length) {
for (let r of e) this.flowEnumErrorStringMemberInconsistentlyInitialized(r, { enumName: i });
return s;
} else {
for (let r of s) this.flowEnumErrorStringMemberInconsistentlyInitialized(r, { enumName: i });
return e;
}
}
flowEnumParseExplicitType({ enumName: e }) {
if (!this.eatContextual(102)) return null;
if (!w(this.state.type)) throw this.raise(g.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, { enumName: e });
let { value: s } = this.state;
return this.next(), s !== "boolean" && s !== "number" && s !== "string" && s !== "symbol" && this.raise(g.EnumInvalidExplicitType, this.state.startLoc, { enumName: e, invalidEnumType: s }), s;
}
flowEnumBody(e, s) {
let i = s.name, r = s.loc.start, n = this.flowEnumParseExplicitType({ enumName: i });
this.expect(5);
let { members: o, hasUnknownMembers: h } = this.flowEnumMembers({ enumName: i, explicitType: n });
switch (e.hasUnknownMembers = h, n) {
case "boolean":
return e.explicitType = !0, e.members = o.booleanMembers, this.expect(8), this.finishNode(e, "EnumBooleanBody");
case "number":
return e.explicitType = !0, e.members = o.numberMembers, this.expect(8), this.finishNode(e, "EnumNumberBody");
case "string":
return e.explicitType = !0, e.members = this.flowEnumStringMembers(o.stringMembers, o.defaultedMembers, { enumName: i }), this.expect(8), this.finishNode(e, "EnumStringBody");
case "symbol":
return e.members = o.defaultedMembers, this.expect(8), this.finishNode(e, "EnumSymbolBody");
default: {
let l = () => (e.members = [], this.expect(8), this.finishNode(e, "EnumStringBody"));
e.explicitType = !1;
let u = o.booleanMembers.length, f = o.numberMembers.length, d = o.stringMembers.length, x = o.defaultedMembers.length;
if (!u && !f && !d && !x) return l();
if (!u && !f) return e.members = this.flowEnumStringMembers(o.stringMembers, o.defaultedMembers, { enumName: i }), this.expect(8), this.finishNode(e, "EnumStringBody");
if (!f && !d && u >= x) {
for (let A of o.defaultedMembers) this.flowEnumErrorBooleanMemberNotInitialized(A.loc.start, { enumName: i, memberName: A.id.name });
return e.members = o.booleanMembers, this.expect(8), this.finishNode(e, "EnumBooleanBody");
} else if (!u && !d && f >= x) {
for (let A of o.defaultedMembers) this.flowEnumErrorNumberMemberNotInitialized(A.loc.start, { enumName: i, memberName: A.id.name });
return e.members = o.numberMembers, this.expect(8), this.finishNode(e, "EnumNumberBody");
} else return this.raise(g.EnumInconsistentMemberValues, r, { enumName: i }), l();
}
}
}
flowParseEnumDeclaration(e) {
let s = this.parseIdentifier();
return e.id = s, e.body = this.flowEnumBody(this.startNode(), s), this.finishNode(e, "EnumDeclaration");
}
jsxParseOpeningElementAfterName(e) {
return this.shouldParseTypes() && (this.match(47) || this.match(51)) && (e.typeArguments = this.flowParseTypeParameterInstantiationInExpression()), super.jsxParseOpeningElementAfterName(e);
}
isLookaheadToken_lt() {
let e = this.nextTokenStart();
if (this.input.charCodeAt(e) === 60) {
let s = this.input.charCodeAt(e + 1);
return s !== 60 && s !== 61;
}
return !1;
}
reScan_lt_gt() {
let { type: e } = this.state;
e === 47 ? (this.state.pos -= 1, this.readToken_lt()) : e === 48 && (this.state.pos -= 1, this.readToken_gt());
}
reScan_lt() {
let { type: e } = this.state;
return e === 51 ? (this.state.pos -= 2, this.finishOp(47, 1), 47) : e;
}
maybeUnwrapTypeCastExpression(e) {
return e.type === "TypeCastExpression" ? e.expression : e;
}
}, Oi = /\r\n|[\r\n\u2028\u2029]/, ge = new RegExp(Oi.source, "g");
_e = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g, je = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
U = F`jsx`({ AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.", MissingClosingTagElement: ({ openingTagName: a2 }) => `Expected corresponding JSX closing tag for <${a2}>.`, 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: a2, HTMLEntity: t }) => `Unexpected token \`${a2}\`. Did you mean \`${t}\` or \`{'${a2}'}\`?`, 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 <>...</>?" });
Bi = (a2) => class extends a2 {
jsxReadToken() {
let e = "", s = this.state.pos;
for (; ; ) {
if (this.state.pos >= this.length) throw this.raise(U.UnterminatedJsxContent, this.state.startLoc);
let i = this.input.charCodeAt(this.state.pos);
switch (i) {
case 60:
case 123:
if (this.state.pos === this.state.start) {
i === 60 && this.state.canStartJSXElement ? (++this.state.pos, this.finishToken(143)) : super.getTokenFromCode(i);
return;
}
e += this.input.slice(s, this.state.pos), this.finishToken(142, e);
return;
case 38:
e += this.input.slice(s, this.state.pos), e += this.jsxReadEntity(), s = this.state.pos;
break;
case 62:
case 125:
this.raise(U.UnexpectedToken, this.state.curPosition(), { unexpected: this.input[this.state.pos], HTMLEntity: i === 125 ? "}" : ">" });
default:
G(i) ? (e += this.input.slice(s, this.state.pos), e += this.jsxReadNewLine(!0), s = this.state.pos) : ++this.state.pos;
}
}
}
jsxReadNewLine(e) {
let s = this.input.charCodeAt(this.state.pos), i;
return ++this.state.pos, s === 13 && this.input.charCodeAt(this.state.pos) === 10 ? (++this.state.pos, i = e ? `
` : `\r
`) : i = String.fromCharCode(s), ++this.state.curLine, this.state.lineStart = this.state.pos, i;
}
jsxReadString(e) {
let s = "", i = ++this.state.pos;
for (; ; ) {
if (this.state.pos >= this.length) throw this.raise(p.UnterminatedString, this.state.startLoc);
let r = this.input.charCodeAt(this.state.pos);
if (r === e) break;
r === 38 ? (s += this.input.slice(i, this.state.pos), s += this.jsxReadEntity(), i = this.state.pos) : G(r) ? (s += this.input.slice(i, this.state.pos), s += this.jsxReadNewLine(!1), i = this.state.pos) : ++this.state.pos;
}
s += this.input.slice(i, this.state.pos++), this.finishToken(134, s);
}
jsxReadEntity() {
let e = ++this.state.pos;
if (this.codePointAtPos(this.state.pos) === 35) {
++this.state.pos;
let s = 10;
this.codePointAtPos(this.state.pos) === 120 && (s = 16, ++this.state.pos);
let i = this.readInt(s, void 0, !1, "bail");
if (i !== null && this.codePointAtPos(this.state.pos) === 59) return ++this.state.pos, String.fromCodePoint(i);
} else {
let s = 0, i = !1;
for (; s++ < 10 && this.state.pos < this.length && !(i = this.codePointAtPos(this.state.pos) === 59); ) ++this.state.pos;
if (i) {
let r = this.input.slice(e, this.state.pos), n;
if (++this.state.pos, n) return n;
}
}
return this.state.pos = e, "&";
}
jsxReadWord() {
let e, s = this.state.pos;
do
e = this.input.charCodeAt(++this.state.pos);
while (K(e) || e === 45);
this.finishToken(141, this.input.slice(s, this.state.pos));
}
jsxParseIdentifier() {
let e = this.startNode();
return this.match(141) ? e.name = this.state.value : Tt(this.state.type) ? e.name = z(this.state.type) : this.unexpected(), this.next(), this.finishNode(e, "JSXIdentifier");
}
jsxParseNamespacedName() {
let e = this.state.startLoc, s = this.jsxParseIdentifier();
if (!this.eat(14)) return s;
let i = this.startNodeAt(e);
return i.namespace = s, i.name = this.jsxParseIdentifier(), this.finishNode(i, "JSXNamespacedName");
}
jsxParseElementName() {
let e = this.state.startLoc, s = this.jsxParseNamespacedName();
if (s.type === "JSXNamespacedName") return s;
for (; this.eat(16); ) {
let i = this.startNodeAt(e);
i.object = s, i.property = this.jsxParseIdentifier(), s = this.finishNode(i, "JSXMemberExpression");
}
return s;
}
jsxParseAttributeValue() {
let e;
switch (this.state.type) {
case 5:
return e = this.startNode(), this.setContext(E.brace), this.next(), e = this.jsxParseExpressionContainer(e, E.j_oTag), e.expression.type === "JSXEmptyExpression" && this.raise(U.AttributeIsEmpty, e), e;
case 143:
case 134:
return this.parseExprAtom();
default:
throw this.raise(U.UnsupportedJsxValue, this.state.startLoc);
}
}
jsxParseEmptyExpression() {
let e = this.startNodeAt(this.state.lastTokEndLoc);
return this.finishNodeAt(e, "JSXEmptyExpression", this.state.startLoc);
}
jsxParseSpreadChild(e) {
return this.next(), e.expression = this.parseExpression(), this.setContext(E.j_expr), this.state.canStartJSXElement = !0, this.expect(8), this.finishNode(e, "JSXSpreadChild");
}
jsxParseExpressionContainer(e, s) {
if (this.match(8)) e.expression = this.jsxParseEmptyExpression();
else {
let i = this.parseExpression();
i.type === "SequenceExpression" && !i.extra?.parenthesized && this.raise(U.UnexpectedSequenceExpression, i.expressions[1]), e.expression = i;
}
return this.setContext(s), this.state.canStartJSXElement = !0, this.expect(8), this.finishNode(e, "JSXExpressionContainer");
}
jsxParseAttribute() {
let e = this.startNode();
return this.match(5) ? (this.setContext(E.brace), this.next(), this.expect(21), e.argument = this.parseMaybeAssignAllowIn(), this.setContext(E.j_oTag), this.state.canStartJSXElement = !0, this.expect(8), this.finishNode(e, "JSXSpreadAttribute")) : (e.name = this.jsxParseNamespacedName(), e.value = this.eat(29) ? this.jsxParseAttributeValue() : null, this.finishNode(e, "JSXAttribute"));
}
jsxParseOpeningElementAt(e) {
let s = this.startNodeAt(e);
return this.eat(144) ? this.finishNode(s, "JSXOpeningFragment") : (s.name = this.jsxParseElementName(), this.jsxParseOpeningElementAfterName(s));
}
jsxParseOpeningElementAfterName(e) {
let s = [];
for (; !this.match(56) && !this.match(144); ) s.push(this.jsxParseAttribute());
return e.attributes = s, e.selfClosing = this.eat(56), this.expect(144), this.finishNode(e, "JSXOpeningElement");
}
jsxParseClosingElementAt(e) {
let s = this.startNodeAt(e);
return this.eat(144) ? this.finishNode(s, "JSXClosingFragment") : (s.name = this.jsxParseElementName(), this.expect(144), this.finishNode(s, "JSXClosingElement"));
}
jsxParseElementAt(e) {
let s = this.startNodeAt(e), i = [], r = this.jsxParseOpeningElementAt(e), n = null;
if (!r.selfClosing) {
e: for (; ; ) switch (this.state.type) {
case 143:
if (e = this.state.startLoc, this.next(), this.eat(56)) {
n = this.jsxParseClosingElementAt(e);
break e;
}
i.push(this.jsxParseElementAt(e));
break;
case 142:
i.push(this.parseLiteral(this.state.value, "JSXText"));
break;
case 5: {
let o = this.startNode();
this.setContext(E.brace), this.next(), this.match(21) ? i.push(this.jsxParseSpreadChild(o)) : i.push(this.jsxParseExpressionContainer(o, E.j_expr));
break;
}
default:
this.unexpected();
}
V(r) && !V(n) && n !== null ? this.raise(U.MissingClosingTagFragment, n) : !V(r) && V(n) ? this.raise(U.MissingClosingTagElement, n, { openingTagName: J(r.name) }) : !V(r) && !V(n) && J(n.name) !== J(r.name) && this.raise(U.MissingClosingTagElement, n, { openingTagName: J(r.name) });
}
if (V(r) ? (s.openingFragment = r, s.closingFragment = n) : (s.openingElement = r, s.closingElement = n), s.children = i, this.match(47)) throw this.raise(U.UnwrappedAdjacentJSXElements, this.state.startLoc);
return V(r) ? this.finishNode(s, "JSXFragment") : this.finishNode(s, "JSXElement");
}
jsxParseElement() {
let e = this.state.startLoc;
return this.next(), this.jsxParseElementAt(e);
}
setContext(e) {
let { context: s } = this.state;
s[s.length - 1] = e;
}
parseExprAtom(e) {
return this.match(143) ? this.jsxParseElement() : this.match(47) && this.input.charCodeAt(this.state.pos) !== 33 ? (this.replaceToken(143), this.jsxParseElement()) : super.parseExprAtom(e);
}
skipSpace() {
this.curContext().preserveSpace || super.skipSpace();
}
getTokenFromCode(e) {
let s = this.curContext();
if (s === E.j_expr) {
this.jsxReadToken();
return;
}
if (s === E.j_oTag || s === E.j_cTag) {
if (B(e)) {
this.jsxReadWord();
return;
}
if (e === 62) {
++this.state.pos, this.finishToken(144);
return;
}
if ((e === 34 || e === 39) && s === E.j_oTag) {
this.jsxReadString(e);
return;
}
}
if (e === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
++this.state.pos, this.finishToken(143);
return;
}
super.getTokenFromCode(e);
}
updateContext(e) {
let { context: s, type: i } = this.state;
if (i === 56 && e === 143) s.splice(-2, 2, E.j_cTag), this.state.canStartJSXElement = !1;
else if (i === 143) s.push(E.j_oTag);
else if (i === 144) {
let r = s[s.length - 1];
r === E.j_oTag && e === 56 || r === E.j_cTag ? (s.pop(), this.state.canStartJSXElement = s[s.length - 1] === E.j_expr) : (this.setContext(E.j_expr), this.state.canStartJSXElement = !0);
} else this.state.canStartJSXElement = ci(i);
}
}, Je = class extends ue {
tsNames = /* @__PURE__ */ new Map();
}, Ge = class extends fe {
importsStack = [];
createScope(t) {
return this.importsStack.push(/* @__PURE__ */ new Set()), new Je(t);
}
enter(t) {
t === 1024 && this.importsStack.push(/* @__PURE__ */ new Set()), super.enter(t);
}
exit() {
let t = super.exit();
return t === 1024 && this.importsStack.pop(), t;
}
hasImport(t, e) {
let s = this.importsStack.length;
if (this.importsStack[s - 1].has(t)) return !0;
if (!e && s > 1) {
for (let i = 0; i < s - 1; i++) if (this.importsStack[i].has(t)) return !0;
}
return !1;
}
declareName(t, e, s) {
if (e & 4096) {
this.hasImport(t, !0) && this.parser.raise(p.VarRedeclaration, s, { identifierName: t }), this.importsStack[this.importsStack.length - 1].add(t);
return;
}
let i = this.currentScope(), r = i.tsNames.get(t) || 0;
if (e & 1024) {
this.maybeExportDefined(i, t), i.tsNames.set(t, r | 16);
return;
}
super.declareName(t, e, s), e & 2 && (e & 1 || (this.checkRedeclarationInScope(i, t, e, s), this.maybeExportDefined(i, t)), r = r | 1), e & 256 && (r = r | 2), e & 512 && (r = r | 4), e & 128 && (r = r | 8), r && i.tsNames.set(t, r);
}
isRedeclaredInScope(t, e, s) {
let i = t.tsNames.get(e);
if ((i & 2) > 0) {
if (s & 256) {
let r = !!(s & 512), n = (i & 4) > 0;
return r !== n;
}
return !0;
}
return s & 128 && (i & 8) > 0 ? t.names.get(e) & 2 ? !!(s & 1) : !1 : s & 2 && (i & 1) > 0 ? !0 : super.isRedeclaredInScope(t, e, s);
}
checkLocalExport(t) {
let { name: e } = t;
if (this.hasImport(e)) return;
let s = this.scopeStack.length;
for (let i = s - 1; i >= 0; i--) {
let n = this.scopeStack[i].tsNames.get(e);
if ((n & 1) > 0 || (n & 16) > 0) return;
}
super.checkLocalExport(t);
}
}, Xe = class {
stacks = [];
enter(t) {
this.stacks.push(t);
}
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;
}
};
Ye = class {
sawUnambiguousESM = !1;
ambiguousScriptDifferentAst = !1;
sourceToOffsetPos(t) {
return t + this.startIndex;
}
offsetToSourcePos(t) {
return t - this.startIndex;
}
hasPlugin(t) {
if (typeof t == "string") return this.plugins.has(t);
{
let [e, s] = t;
if (!this.hasPlugin(e)) return !1;
let i = this.plugins.get(e);
for (let r of Object.keys(s)) if (i?.[r] !== s[r]) return !1;
return !0;
}
}
getPluginOption(t, e) {
return this.plugins.get(t)?.[e];
}
};
Qe = class extends Ye {
addComment(t) {
this.filename && (t.loc.filename = this.filename);
let { commentsLen: e } = this.state;
this.comments.length !== e && (this.comments.length = e), this.comments.push(t), this.state.commentsLen++;
}
processComment(t) {
let { commentStack: e } = this.state, s = e.length;
if (s === 0) return;
let i = s - 1, r = e[i];
r.start === t.end && (r.leadingNode = t, i--);
let { start: n } = t;
for (; i >= 0; i--) {
let o = e[i], h = o.end;
if (h > n) o.containingNode = t, this.finalizeComment(o), e.splice(i, 1);
else {
h === n && (o.trailingNode = t);
break;
}
}
}
finalizeComment(t) {
let { comments: e } = t;
if (t.leadingNode !== null || t.trailingNode !== null) t.leadingNode !== null && ss(t.leadingNode, e), t.trailingNode !== null && Ri(t.trailingNode, e);
else {
let s = t.containingNode, i = t.start;
if (this.input.charCodeAt(this.offsetToSourcePos(i) - 1) === 44) switch (s.type) {
case "ObjectExpression":
case "ObjectPattern":
case "RecordExpression":
$(s, s.properties, t);
break;
case "CallExpression":
case "OptionalCallExpression":
$(s, s.arguments, t);
break;
case "ImportExpression":
$(s, [s.source, s.options ?? null], t);
break;
case "FunctionDeclaration":
case "FunctionExpression":
case "ArrowFunctionExpression":
case "ObjectMethod":
case "ClassMethod":
case "ClassPrivateMethod":
$(s, s.params, t);
break;
case "ArrayExpression":
case "ArrayPattern":
case "TupleExpression":
$(s, s.elements, t);
break;
case "ExportNamedDeclaration":
case "ImportDeclaration":
$(s, s.specifiers, t);
break;
case "TSEnumDeclaration":
X(s, e);
break;
case "TSEnumBody":
$(s, s.members, t);
break;
default:
X(s, e);
}
else X(s, e);
}
}
finalizeRemainingComments() {
let { commentStack: t } = this.state;
for (let e = t.length - 1; e >= 0; e--) this.finalizeComment(t[e]);
this.state.commentStack = [];
}
resetPreviousNodeTrailingComments(t) {
let { commentStack: e } = this.state, { length: s } = e;
if (s === 0) return;
let i = e[s - 1];
i.leadingNode === t && (i.leadingNode = null);
}
takeSurroundingComments(t, e, s) {
let { commentStack: i } = this.state, r = i.length;
if (r === 0) return;
let n = r - 1;
for (; n >= 0; n--) {
let o = i[n], h = o.end;
if (o.start === s) o.leadingNode = t;
else if (h === e) o.trailingNode = t;
else if (h < e) break;
}
}
}, Ze = class a {
flags = 1024;
get strict() {
return (this.flags & 1) > 0;
}
set strict(t) {
t ? this.flags |= 1 : this.flags &= -2;
}
startIndex;
curLine;
lineStart;
startLoc;
endLoc;
init({ strictMode: t, sourceType: e, startIndex: s, startLine: i, startColumn: r }) {
this.strict = t === !1 ? !1 : t === !0 ? !0 : e === "module", this.startIndex = s, this.curLine = i, this.lineStart = -r, this.startLoc = this.endLoc = new R(i, r, s);
}
errors = [];
potentialArrowAt = -1;
noArrowAt = [];
noArrowParamsConversionAt = [];
get maybeInArrowParameters() {
return (this.flags & 2) > 0;
}
set maybeInArrowParameters(t) {
t ? this.flags |= 2 : this.flags &= -3;
}
get inType() {
return (this.flags & 4) > 0;
}
set inType(t) {
t ? this.flags |= 4 : this.flags &= -5;
}
get noAnonFunctionType() {
return (this.flags & 8) > 0;
}
set noAnonFunctionType(t) {
t ? this.flags |= 8 : this.flags &= -9;
}
get hasFlowComment() {
return (this.flags & 16) > 0;
}
set hasFlowComment(t) {
t ? this.flags |= 16 : this.flags &= -17;
}
get isAmbientContext() {
return (this.flags & 32) > 0;
}
set isAmbientContext(t) {
t ? this.flags |= 32 : this.flags &= -33;
}
get inAbstractClass() {
return (this.flags & 64) > 0;
}
set inAbstractClass(t) {
t ? this.flags |= 64 : this.flags &= -65;
}
get inDisallowConditionalTypesContext() {
return (this.flags & 128) > 0;
}
set inDisallowConditionalTypesContext(t) {
t ? this.flags |= 128 : this.flags &= -129;
}
topicContext = { maxNumOfResolvableTopics: 0, maxTopicIndex: null };
get soloAwait() {
return (this.flags & 256) > 0;
}
set soloAwait(t) {
t ? this.flags |= 256 : this.flags &= -257;
}
get inFSharpPipelineDirectBody() {
return (this.flags & 512) > 0;
}
set inFSharpPipelineDirectBody(t) {
t ? this.flags |= 512 : this.flags &= -513;
}
labels = [];
commentsLen = 0;
commentStack = [];
pos = 0;
type = 140;
value = null;
start = 0;
end = 0;
lastTokEndLoc = null;
lastTokStartLoc = null;
context = [E.brace];
get canStartJSXElement() {
return (this.flags & 1024) > 0;
}
set canStartJSXElement(t) {
t ? this.flags |= 1024 : this.flags &= -1025;
}
get containsEsc() {
return (this.flags & 2048) > 0;
}
set containsEsc(t) {
t ? this.flags |= 2048 : this.flags &= -2049;
}
firstInvalidTemplateEscapePos = null;
get hasTopLevelAwait() {
return (this.flags & 4096) > 0;
}
set hasTopLevelAwait(t) {
t ? this.flags |= 4096 : this.flags &= -4097;
}
strictErrors = /* @__PURE__ */ new Map();
tokensLength = 0;
curPosition() {
return new R(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex);
}
clone() {
let t = new a();
return t.flags = this.flags, t.startIndex = this.startIndex, t.curLine = this.curLine, t.lineStart = this.lineStart, t.startLoc = this.startLoc, t.endLoc = this.endLoc, t.errors = this.errors.slice(), t.potentialArrowAt = this.potentialArrowAt, t.noArrowAt = this.noArrowAt.slice(), t.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice(), t.topicContext = this.topicContext, t.labels = this.labels.slice(), t.commentsLen = this.commentsLen, t.commentStack = this.commentStack.slice(), t.pos = this.pos, t.type = this.type, t.value = this.value, t.start = this.start, t.end = this.end, t.lastTokEndLoc = this.lastTokEndLoc, t.lastTokStartLoc = this.lastTokStartLoc, t.context = this.context.slice(), t.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos, t.strictErrors = this.strictErrors, t.tokensLength = this.tokensLength, t;
}
}, Ui = function(t) {
return t >= 48 && t <= 57;
}, _t = { decBinOct: /* @__PURE__ */ new Set([46, 66, 69, 79, 95, 98, 101, 111]), hex: /* @__PURE__ */ new Set([46, 88, 95, 120]) }, Te = { bin: (a2) => a2 === 48 || a2 === 49, oct: (a2) => a2 >= 48 && a2 <= 55, dec: (a2) => a2 >= 48 && a2 <= 57, hex: (a2) => a2 >= 48 && a2 <= 57 || a2 >= 65 && a2 <= 70 || a2 >= 97 && a2 <= 102 };
Vi = /* @__PURE__ */ new Set([103, 109, 115, 105, 121, 117, 100, 118]), tt = class {
constructor(t) {
let e = t.startIndex || 0;
this.type = t.type, this.value = t.value, this.start = e + t.start, this.end = e + t.end, this.loc = new Q(t.startLoc, t.endLoc);
}
}, st = class extends Qe {
isLookahead;
tokens = [];
constructor(t, e) {
super(), this.state = new Ze(), this.state.init(t), this.input = e, this.length = e.length, this.comments = [], this.isLookahead = !1;
}
pushToken(t) {
this.tokens.length = this.state.tokensLength, this.tokens.push(t), ++this.state.tokensLength;
}
next() {
this.checkKeywordEscapes(), this.optionFlags & 256 && this.pushToken(new tt(this.state)), this.state.lastTokEndLoc = this.state.endLoc, this.state.lastTokStartLoc = this.state.startLoc, this.nextToken();
}
eat(t) {
return this.match(t) ? (this.next(), !0) : !1;
}
match(t) {
return this.state.type === t;
}
createLookaheadState(t) {
return { pos: t.pos, value: null, type: t.type, start: t.start, end: t.end, context: [this.curContext()], inType: t.inType, startLoc: t.startLoc, lastTokEndLoc: t.lastTokEndLoc, curLine: t.curLine, lineStart: t.lineStart, curPosition: t.curPosition };
}
lookahead() {
let t = this.state;
this.state = this.createLookaheadState(t), this.isLookahead = !0, this.nextToken(), this.isLookahead = !1;
let e = this.state;
return this.state = t, e;
}
nextTokenStart() {
return this.nextTokenStartSince(this.state.pos);
}
nextTokenStartSince(t) {
return _e.lastIndex = t, _e.test(this.input) ? _e.lastIndex : t;
}
lookaheadCharCode() {
return this.lookaheadCharCodeSince(this.state.pos);
}
lookaheadCharCodeSince(t) {
return this.input.charCodeAt(this.nextTokenStartSince(t));
}
nextTokenInLineStart() {
return this.nextTokenInLineStartSince(this.state.pos);
}
nextTokenInLineStartSince(t) {
return je.lastIndex = t, je.test(this.input) ? je.lastIndex : t;
}
lookaheadInLineCharCode() {
return this.input.charCodeAt(this.nextTokenInLineStart());
}
codePointAtPos(t) {
let e = this.input.charCodeAt(t);
if ((e & 64512) === 55296 && ++t < this.input.length) {
let s = this.input.charCodeAt(t);
(s & 64512) === 56320 && (e = 65536 + ((e & 1023) << 10) + (s & 1023));
}
return e;
}
setStrict(t) {
this.state.strict = t, t && (this.state.strictErrors.forEach(([e, s]) => this.raise(e, s)), this.state.strictErrors.clear());
}
curContext() {
return this.state.context[this.state.context.length - 1];
}
nextToken() {
if (this.skipSpace(), this.state.start = this.state.pos, this.isLookahead || (this.state.startLoc = this.state.curPosition()), this.state.pos >= this.length) {
this.finishToken(140);
return;
}
this.getTokenFromCode(this.codePointAtPos(this.state.pos));
}
skipBlockComment(t) {
let e;
this.isLookahead || (e = this.state.curPosition());
let s = this.state.pos, i = this.input.indexOf(t, s + 2);
if (i === -1) throw this.raise(p.UnterminatedComment, this.state.curPosition());
for (this.state.pos = i + t.length, ge.lastIndex = s + 2; ge.test(this.input) && ge.lastIndex <= i; ) ++this.state.curLine, this.state.lineStart = ge.lastIndex;
if (this.isLookahead) return;
let r = { type: "CommentBlock", value: this.input.slice(s + 2, i), start: this.sourceToOffsetPos(s), end: this.sourceToOffsetPos(i + t.length), loc: new Q(e, this.state.curPosition()) };
return this.optionFlags & 256 && this.pushToken(r), r;
}
skipLineComment(t) {
let e = this.state.pos, s;
this.isLookahead || (s = this.state.curPosition());
let i = this.input.charCodeAt(this.state.pos += t);
if (this.state.pos < this.length) for (; !G(i) && ++this.state.pos < this.length; ) i = this.input.charCodeAt(this.state.pos);
if (this.isLookahead) return;
let r = this.state.pos, o = { type: "CommentLine", value: this.input.slice(e + t, r), start: this.sourceToOffsetPos(e), end: this.sourceToOffsetPos(r), loc: new Q(s, this.state.curPosition()) };
return this.optionFlags & 256 && this.pushToken(o), o;
}
skipSpace() {
let t = this.state.pos, e = this.optionFlags & 4096 ? [] : null;
e: for (; this.state.pos < this.length; ) {
let s = this.input.charCodeAt(this.state.pos);
switch (s) {
case 32:
case 160:
case 9:
++this.state.pos;
break;
case 13:
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: {
let i = this.skipBlockComment("*/");
i !== void 0 && (this.addComment(i), e?.push(i));
break;
}
case 47: {
let i = this.skipLineComment(2);
i !== void 0 && (this.addComment(i), e?.push(i));
break;
}
default:
break e;
}
break;
default:
if (Fi(s)) ++this.state.pos;
else if (s === 45 && !this.inModule && this.optionFlags & 8192) {
let i = this.state.pos;
if (this.input.charCodeAt(i + 1) === 45 && this.input.charCodeAt(i + 2) === 62 && (t === 0 || this.state.lineStart > t)) {
let r = this.skipLineComment(3);
r !== void 0 && (this.addComment(r), e?.push(r));
} else break e;
} else if (s === 60 && !this.inModule && this.optionFlags & 8192) {
let i = this.state.pos;
if (this.input.charCodeAt(i + 1) === 33 && this.input.charCodeAt(i + 2) === 45 && this.input.charCodeAt(i + 3) === 45) {
let r = this.skipLineComment(4);
r !== void 0 && (this.addComment(r), e?.push(r));
} else break e;
} else break e;
}
}
if (e?.length > 0) {
let s = this.state.pos, i = { start: this.sourceToOffsetPos(t), end: this.sourceToOffsetPos(s), comments: e, leadingNode: null, trailingNode: null, containingNode: null };
this.state.commentStack.push(i);
}
}
finishToken(t, e) {
this.state.end = this.state.pos, this.state.endLoc = this.state.curPosition();
let s = this.state.type;
this.state.type = t, this.state.value = e, this.isLookahead || this.updateContext(s);
}
replaceToken(t) {
this.state.type = t, this.updateContext();
}
readToken_numberSign() {
if (this.state.pos === 0 && this.readToken_interpreter()) return;
let t = this.state.pos + 1, e = this.codePointAtPos(t);
if (e >= 48 && e <= 57) throw this.raise(p.UnexpectedDigitAfterHash, this.state.curPosition());
B(e) ? (++this.state.pos, this.finishToken(139, this.readWord1(e))) : e === 92 ? (++this.state.pos, this.finishToken(139, this.readWord1())) : this.finishOp(27, 1);
}
readToken_dot() {
let t = this.input.charCodeAt(this.state.pos + 1);
if (t >= 48 && t <= 57) {
this.readNumber(!0);
return;
}
t === 46 && this.input.charCodeAt(this.state.pos + 2) === 46 ? (this.state.pos += 3, this.finishToken(21)) : (++this.state.pos, this.finishToken(16));
}
readToken_slash() {
this.input.charCodeAt(this.state.pos + 1) === 61 ? this.finishOp(31, 2) : this.finishOp(56, 1);
}
readToken_interpreter() {
if (this.state.pos !== 0 || this.length < 2) return !1;
let t = this.input.charCodeAt(this.state.pos + 1);
if (t !== 33) return !1;
let e = this.state.pos;
for (this.state.pos += 1; !G(t) && ++this.state.pos < this.length; ) t = this.input.charCodeAt(this.state.pos);
let s = this.input.slice(e + 2, this.state.pos);
return this.finishToken(28, s), !0;
}
readToken_mult_modulo(t) {
let e = t === 42 ? 55 : 54, s = 1, i = this.input.charCodeAt(this.state.pos + 1);
t === 42 && i === 42 && (s++, i = this.input.charCodeAt(this.state.pos + 2), e = 57), i === 61 && !this.state.inType && (s++, e = t === 37 ? 33 : 30), this.finishOp(e, s);
}
readToken_pipe_amp(t) {
let e = this.input.charCodeAt(this.state.pos + 1);
if (e === t) {
this.input.charCodeAt(this.state.pos + 2) === 61 ? this.finishOp(30, 3) : this.finishOp(t === 124 ? 41 : 42, 2);
return;
}
if (t === 124 && e === 62) {
this.finishOp(39, 2);
return;
}
if (e === 61) {
this.finishOp(30, 2);
return;
}
this.finishOp(t === 124 ? 43 : 45, 1);
}
readToken_caret() {
let t = this.input.charCodeAt(this.state.pos + 1);
t === 61 && !this.state.inType ? this.finishOp(32, 2) : t === 94 && this.hasPlugin(["pipelineOperator", { proposal: "hack", topicToken: "^^" }]) ? (this.finishOp(37, 2), this.input.codePointAt(this.state.pos) === 94 && this.unexpected()) : this.finishOp(44, 1);
}
readToken_atSign() {
this.input.charCodeAt(this.state.pos + 1) === 64 && this.hasPlugin(["pipelineOperator", { proposal: "hack", topicToken: "@@" }]) ? this.finishOp(38, 2) : this.finishOp(26, 1);
}
readToken_plus_min(t) {
let e = this.input.charCodeAt(this.state.pos + 1);
if (e === t) {
this.finishOp(34, 2);
return;
}
e === 61 ? this.finishOp(30, 2) : this.finishOp(53, 1);
}
readToken_lt() {
let { pos: t } = this.state, e = this.input.charCodeAt(t + 1);
if (e === 60) {
if (this.input.charCodeAt(t + 2) === 61) {
this.finishOp(30, 3);
return;
}
this.finishOp(51, 2);
return;
}
if (e === 61) {
this.finishOp(49, 2);
return;
}
this.finishOp(47, 1);
}
readToken_gt() {
let { pos: t } = this.state, e = this.input.charCodeAt(t + 1);
if (e === 62) {
let s = this.input.charCodeAt(t + 2) === 62 ? 3 : 2;
if (this.input.charCodeAt(t + s) === 61) {
this.finishOp(30, s + 1);
return;
}
this.finishOp(52, s);
return;
}
if (e === 61) {
this.finishOp(49, 2);
return;
}
this.finishOp(48, 1);
}
readToken_eq_excl(t) {
let e = this.input.charCodeAt(this.state.pos + 1);
if (e === 61) {
this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
return;
}
if (t === 61 && e === 62) {
this.state.pos += 2, this.finishToken(19);
return;
}
this.finishOp(t === 61 ? 29 : 35, 1);
}
readToken_question() {
let t = this.input.charCodeAt(this.state.pos + 1), e = this.input.charCodeAt(this.state.pos + 2);
t === 63 ? e === 61 ? this.finishOp(30, 3) : this.finishOp(40, 2) : t === 46 && !(e >= 48 && e <= 57) ? (this.state.pos += 2, this.finishToken(18)) : (++this.state.pos, this.finishToken(17));
}
getTokenFromCode(t) {
switch (t) {
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:
++this.state.pos, this.finishToken(0);
return;
case 93:
++this.state.pos, this.finishToken(3);
return;
case 123:
++this.state.pos, this.finishToken(5);
return;
case 125:
++this.state.pos, this.finishToken(8);
return;
case 58:
this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58 ? this.finishOp(15, 2) : (++this.state.pos, this.finishToken(14));
return;
case 63:
this.readToken_question();
return;
case 96:
this.readTemplateToken();
return;
case 48: {
let e = this.input.charCodeAt(this.state.pos + 1);
if (e === 120 || e === 88) {
this.readRadixNumber(16);
return;
}
if (e === 111 || e === 79) {
this.readRadixNumber(8);
return;
}
if (e === 98 || e === 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(!1);
return;
case 34:
case 39:
this.readString(t);
return;
case 47:
this.readToken_slash();
return;
case 37:
case 42:
this.readToken_mult_modulo(t);
return;
case 124:
case 38:
this.readToken_pipe_amp(t);
return;
case 94:
this.readToken_caret();
return;
case 43:
case 45:
this.readToken_plus_min(t);
return;
case 60:
this.readToken_lt();
return;
case 62:
this.readToken_gt();
return;
case 61:
case 33:
this.readToken_eq_excl(t);
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 (B(t)) {
this.readWord(t);
return;
}
}
throw this.raise(p.InvalidOrUnexpectedToken, this.state.curPosition(), { unexpected: String.fromCodePoint(t) });
}
finishOp(t, e) {
let s = this.input.slice(this.state.pos, this.state.pos + e);
this.state.pos += e, this.finishToken(t, s);
}
readRegexp() {
let t = this.state.startLoc, e = this.state.start + 1, s, i, { pos: r } = this.state;
for (; ; ++r) {
if (r >= this.length) throw this.raise(p.UnterminatedRegExp, D(t, 1));
let l = this.input.charCodeAt(r);
if (G(l)) throw this.raise(p.UnterminatedRegExp, D(t, 1));
if (s) s = !1;
else {
if (l === 91) i = !0;
else if (l === 93 && i) i = !1;
else if (l === 47 && !i) break;
s = l === 92;
}
}
let n = this.input.slice(e, r);
++r;
let o = "", h = () => D(t, r + 2 - e);
for (; r < this.length; ) {
let l = this.codePointAtPos(r), u = String.fromCharCode(l);
if (Vi.has(l)) l === 118 ? o.includes("u") && this.raise(p.IncompatibleRegExpUVFlags, h()) : l === 117 && o.includes("v") && this.raise(p.IncompatibleRegExpUVFlags, h()), o.includes(u) && this.raise(p.DuplicateRegExpFlags, h());
else if (K(l) || l === 92) this.raise(p.MalformedRegExpFlags, h());
else break;
++r, o += u;
}
this.state.pos = r, this.finishToken(138, { pattern: n, flags: o });
}
readInt(t, e, s = !1, i = !0) {
let { n: r, pos: n } = is(this.input, this.state.pos, this.state.lineStart, this.state.curLine, t, e, s, i, this.errorHandlers_readInt, !1);
return this.state.pos = n, r;
}
readRadixNumber(t) {
let e = this.state.pos, s = this.state.curPosition(), i = !1;
this.state.pos += 2;
let r = this.readInt(t);
r == null && this.raise(p.InvalidDigit, D(s, 2), { radix: t });
let n = this.input.charCodeAt(this.state.pos);
if (n === 110) ++this.state.pos, i = !0;
else if (n === 109) throw this.raise(p.InvalidDecimal, s);
if (B(this.codePointAtPos(this.state.pos))) throw this.raise(p.NumberIdentifier, this.state.curPosition());
if (i) {
let o = this.input.slice(e, this.state.pos).replace(/[_n]/g, "");
this.finishToken(136, o);
return;
}
this.finishToken(135, r);
}
readNumber(t) {
let e = this.state.pos, s = this.state.curPosition(), i = !1, r = !1, n = !1;
!t && this.readInt(10) === null && this.raise(p.InvalidNumber, this.state.curPosition());
let o = this.state.pos - e >= 2 && this.input.charCodeAt(e) === 48;
if (o) {
let f = this.input.slice(e, this.state.pos);
if (this.recordStrictModeErrors(p.StrictOctalLiteral, s), !this.state.strict) {
let d = f.indexOf("_");
d > 0 && this.raise(p.ZeroDigitNumericSeparator, D(s, d));
}
n = o && !/[89]/.test(f);
}
let h = this.input.charCodeAt(this.state.pos);
if (h === 46 && !n && (++this.state.pos, this.readInt(10), i = !0, h = this.input.charCodeAt(this.state.pos)), (h === 69 || h === 101) && !n && (h = this.input.charCodeAt(++this.state.pos), (h === 43 || h === 45) && ++this.state.pos, this.readInt(10) === null && this.raise(p.InvalidOrMissingExponent, s), i = !0, h = this.input.charCodeAt(this.state.pos)), h === 110 && ((i || o) && this.raise(p.InvalidBigIntLiteral, s), ++this.state.pos, r = !0), B(this.codePointAtPos(this.state.pos))) throw this.raise(p.NumberIdentifier, this.state.curPosition());
let l = this.input.slice(e, this.state.pos).replace(/[_mn]/g, "");
if (r) {
this.finishToken(136, l);
return;
}
let u = n ? parseInt(l, 8) : parseFloat(l);
this.finishToken(135, u);
}
readCodePoint(t) {
let { code: e, pos: s } = rs(this.input, this.state.pos, this.state.lineStart, this.state.curLine, t, this.errorHandlers_readCodePoint);
return this.state.pos = s, e;
}
readString(t) {
let { str: e, pos: s, curLine: i, lineStart: r } = jt(t === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
this.state.pos = s + 1, this.state.lineStart = r, this.state.curLine = i, this.finishToken(134, e);
}
readTemplateContinuation() {
this.match(8) || this.unexpected(null, 8), this.state.pos--, this.readTemplateToken();
}
readTemplateToken() {
let t = this.input[this.state.pos], { str: e, firstInvalidLoc: s, pos: i, curLine: r, lineStart: n } = jt("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
this.state.pos = i + 1, this.state.lineStart = n, this.state.curLine = r, s && (this.state.firstInvalidTemplateEscapePos = new R(s.curLine, s.pos - s.lineStart, this.sourceToOffsetPos(s.pos))), this.input.codePointAt(i) === 96 ? this.finishToken(24, s ? null : t + e + "`") : (this.state.pos++, this.finishToken(25, s ? null : t + e + "${"));
}
recordStrictModeErrors(t, e) {
let s = e.index;
this.state.strict && !this.state.strictErrors.has(s) ? this.raise(t, e) : this.state.strictErrors.set(s, [t, e]);
}
readWord1(t) {
this.state.containsEsc = !1;
let e = "", s = this.state.pos, i = this.state.pos;
for (t !== void 0 && (this.state.pos += t <= 65535 ? 1 : 2); this.state.pos < this.length; ) {
let r = this.codePointAtPos(this.state.pos);
if (K(r)) this.state.pos += r <= 65535 ? 1 : 2;
else if (r === 92) {
this.state.containsEsc = !0, e += this.input.slice(i, this.state.pos);
let n = this.state.curPosition(), o = this.state.pos === s ? B : K;
if (this.input.charCodeAt(++this.state.pos) !== 117) {
this.raise(p.MissingUnicodeEscape, this.state.curPosition()), i = this.state.pos - 1;
continue;
}
++this.state.pos;
let h = this.readCodePoint(!0);
h !== null && (o(h) || this.raise(p.EscapedCharNotAnIdentifier, n), e += String.fromCodePoint(h)), i = this.state.pos;
} else break;
}
return e + this.input.slice(i, this.state.pos);
}
readWord(t) {
let e = this.readWord1(t), s = ft.get(e);
s !== void 0 ? this.finishToken(s, z(s)) : this.finishToken(132, e);
}
checkKeywordEscapes() {
let { type: t } = this.state;
Tt(t) && this.state.containsEsc && this.raise(p.InvalidEscapedReservedWord, this.state.startLoc, { reservedWord: z(t) });
}
raise(t, e, s = {}) {
let i = e instanceof R ? e : e.loc.start, r = t(i, s);
if (!(this.optionFlags & 2048)) throw r;
return this.isLookahead || this.state.errors.push(r), r;
}
raiseOverwrite(t, e, s = {}) {
let i = e instanceof R ? e : e.loc.start, r = i.index, n = this.state.errors;
for (let o = n.length - 1; o >= 0; o--) {
let h = n[o];
if (h.loc.index === r) return n[o] = t(i, s);
if (h.loc.index < r) break;
}
return this.raise(t, e, s);
}
updateContext(t) {
}
unexpected(t, e) {
throw this.raise(p.UnexpectedToken, t ?? this.state.startLoc, { expected: e ? z(e) : null });
}
expectPlugin(t, e) {
if (this.hasPlugin(t)) return !0;
throw this.raise(p.MissingPlugin, e ?? this.state.startLoc, { missingPlugin: [t] });
}
expectOnePlugin(t) {
if (!t.some((e) => this.hasPlugin(e))) throw this.raise(p.MissingOneOfPlugins, this.state.startLoc, { missingPlugin: t });
}
errorBuilder(t) {
return (e, s, i) => {
this.raise(t, he(e, s, i));
};
}
errorHandlers_readInt = { invalidDigit: (t, e, s, i) => this.optionFlags & 2048 ? (this.raise(p.InvalidDigit, he(t, e, s), { radix: i }), !0) : !1, numericSeparatorInEscapeSequence: this.errorBuilder(p.NumericSeparatorInEscapeSequence), unexpectedNumericSeparator: this.errorBuilder(p.UnexpectedNumericSeparator) };
errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, { invalidEscapeSequence: this.errorBuilder(p.InvalidEscapeSequence), invalidCodePoint: this.errorBuilder(p.InvalidCodePoint) });
errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, { strictNumericEscape: (t, e, s) => {
this.recordStrictModeErrors(p.StrictNumericEscape, he(t, e, s));
}, unterminated: (t, e, s) => {
throw this.raise(p.UnterminatedString, he(t - 1, e, s));
} });
errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, { strictNumericEscape: this.errorBuilder(p.StrictNumericEscape), unterminated: (t, e, s) => {
throw this.raise(p.UnterminatedTemplate, he(t, e, s));
} });
}, it = class {
privateNames = /* @__PURE__ */ new Set();
loneAccessors = /* @__PURE__ */ new Map();
undefinedPrivateNames = /* @__PURE__ */ new Map();
}, rt = class {
parser;
stack = [];
undefinedPrivateNames = /* @__PURE__ */ new Map();
constructor(t) {
this.parser = t;
}
current() {
return this.stack[this.stack.length - 1];
}
enter() {
this.stack.push(new it());
}
exit() {
let t = this.stack.pop(), e = this.current();
for (let [s, i] of Array.from(t.undefinedPrivateNames)) e ? e.undefinedPrivateNames.has(s) || e.undefinedPrivateNames.set(s, i) : this.parser.raise(p.InvalidPrivateFieldResolution, i, { identifierName: s });
}
declarePrivateName(t, e, s) {
let { privateNames: i, loneAccessors: r, undefinedPrivateNames: n } = this.current(), o = i.has(t);
if (e & 3) {
let h = o && r.get(t);
if (h) {
let l = h & 4, u = e & 4, f = h & 3, d = e & 3;
o = f === d || l !== u, o || r.delete(t);
} else o || r.set(t, e);
}
o && this.parser.raise(p.PrivateNameRedeclaration, s, { identifierName: t }), i.add(t), n.delete(t);
}
usePrivateName(t, e) {
let s;
for (s of this.stack) if (s.privateNames.has(t)) return;
s ? s.undefinedPrivateNames.set(t, e) : this.parser.raise(p.InvalidPrivateFieldResolution, e, { identifierName: t });
}
}, Z = class {
constructor(t = 0) {
this.type = t;
}
canBeArrowParameterDeclaration() {
return this.type === 2 || this.type === 1;
}
isCertainlyParameterDeclaration() {
return this.type === 3;
}
}, Ce = class extends Z {
declarationErrors = /* @__PURE__ */ new Map();
constructor(t) {
super(t);
}
recordDeclarationError(t, e) {
let s = e.index;
this.declarationErrors.set(s, [t, e]);
}
clearDeclarationError(t) {
this.declarationErrors.delete(t);
}
iterateErrors(t) {
this.declarationErrors.forEach(t);
}
}, at = class {
parser;
stack = [new Z()];
constructor(t) {
this.parser = t;
}
enter(t) {
this.stack.push(t);
}
exit() {
this.stack.pop();
}
recordParameterInitializerError(t, e) {
let s = e.loc.start, { stack: i } = this, r = i.length - 1, n = i[r];
for (; !n.isCertainlyParameterDeclaration(); ) {
if (n.canBeArrowParameterDeclaration()) n.recordDeclarationError(t, s);
else return;
n = i[--r];
}
this.parser.raise(t, s);
}
recordArrowParameterBindingError(t, e) {
let { stack: s } = this, i = s[s.length - 1], r = e.loc.start;
if (i.isCertainlyParameterDeclaration()) this.parser.raise(t, r);
else if (i.canBeArrowParameterDeclaration()) i.recordDeclarationError(t, r);
else return;
}
recordAsyncArrowParametersError(t) {
let { stack: e } = this, s = e.length - 1, i = e[s];
for (; i.canBeArrowParameterDeclaration(); ) i.type === 2 && i.recordDeclarationError(p.AwaitBindingIdentifier, t), i = e[--s];
}
validateAsPattern() {
let { stack: t } = this, e = t[t.length - 1];
e.canBeArrowParameterDeclaration() && e.iterateErrors(([s, i]) => {
this.parser.raise(s, i);
let r = t.length - 2, n = t[r];
for (; n.canBeArrowParameterDeclaration(); ) n.clearDeclarationError(i.index), n = t[--r];
});
}
};
nt = class extends st {
addExtra(t, e, s, i = !0) {
if (!t) return;
let { extra: r } = t;
r == null && (r = {}, t.extra = r), i ? r[e] = s : Object.defineProperty(r, e, { enumerable: i, value: s });
}
isContextual(t) {
return this.state.type === t && !this.state.containsEsc;
}
isUnparsedContextual(t, e) {
if (this.input.startsWith(e, t)) {
let s = this.input.charCodeAt(t + e.length);
return !(K(s) || (s & 64512) === 55296);
}
return !1;
}
isLookaheadContextual(t) {
let e = this.nextTokenStart();
return this.isUnparsedContextual(e, t);
}
eatContextual(t) {
return this.isContextual(t) ? (this.next(), !0) : !1;
}
expectContextual(t, e) {
if (!this.eatContextual(t)) {
if (e != null) throw this.raise(e, this.state.startLoc);
this.unexpected(null, t);
}
}
canInsertSemicolon() {
return this.match(140) || this.match(8) || this.hasPrecedingLineBreak();
}
hasPrecedingLineBreak() {
return Ut(this.input, this.offsetToSourcePos(this.state.lastTokEndLoc.index), this.state.start);
}
hasFollowingLineBreak() {
return Ut(this.input, this.state.end, this.nextTokenStart());
}
isLineTerminator() {
return this.eat(13) || this.canInsertSemicolon();
}
semicolon(t = !0) {
(t ? this.isLineTerminator() : this.eat(13)) || this.raise(p.MissingSemicolon, this.state.lastTokEndLoc);
}
expect(t, e) {
this.eat(t) || this.unexpected(e, t);
}
tryParse(t, e = this.state.clone()) {
let s = { node: null };
try {
let i = t((r = null) => {
throw s.node = r, s;
});
if (this.state.errors.length > e.errors.length) {
let r = this.state;
return this.state = e, this.state.tokensLength = r.tokensLength, { node: i, error: r.errors[e.errors.length], thrown: !1, aborted: !1, failState: r };
}
return { node: i, error: null, thrown: !1, aborted: !1, failState: null };
} catch (i) {
let r = this.state;
if (this.state = e, i instanceof SyntaxError) return { node: null, error: i, thrown: !0, aborted: !1, failState: r };
if (i === s) return { node: s.node, error: null, thrown: !1, aborted: !0, failState: r };
throw i;
}
}
checkExpressionErrors(t, e) {
if (!t) return !1;
let { shorthandAssignLoc: s, doubleProtoLoc: i, privateKeyLoc: r, optionalParametersLoc: n, voidPatternLoc: o } = t, h = !!s || !!i || !!n || !!r || !!o;
if (!e) return h;
s != null && this.raise(p.InvalidCoverInitializedName, s), i != null && this.raise(p.DuplicateProto, i), r != null && this.raise(p.UnexpectedPrivateField, r), n != null && this.unexpected(n), o != null && this.raise(p.InvalidCoverDiscardElement, o);
}
isLiteralPropertyName() {
return Jt(this.state.type);
}
isPrivateName(t) {
return t.type === "PrivateName";
}
getPrivateNameSV(t) {
return t.id.name;
}
hasPropertyAsPrivateName(t) {
return (t.type === "MemberExpression" || t.type === "OptionalMemberExpression") && this.isPrivateName(t.property);
}
isObjectProperty(t) {
return t.type === "ObjectProperty";
}
isObjectMethod(t) {
return t.type === "ObjectMethod";
}
initializeScopes(t = this.options.sourceType === "module") {
let e = this.state.labels;
this.state.labels = [];
let s = this.exportedIdentifiers;
this.exportedIdentifiers = /* @__PURE__ */ new Set();
let i = this.inModule;
this.inModule = t;
let r = this.scope, n = this.getScopeHandler();
this.scope = new n(this, t);
let o = this.prodParam;
this.prodParam = new Xe();
let h = this.classScope;
this.classScope = new rt(this);
let l = this.expressionScope;
return this.expressionScope = new at(this), () => {
this.state.labels = e, this.exportedIdentifiers = s, this.inModule = i, this.scope = r, this.prodParam = o, this.classScope = h, this.expressionScope = l;
};
}
enterInitialScopes() {
let t = 0;
(this.inModule || this.optionFlags & 1) && (t |= 2), this.optionFlags & 32 && (t |= 1);
let e = !this.inModule && this.options.sourceType === "commonjs";
(e || this.optionFlags & 2) && (t |= 4), this.prodParam.enter(t);
let s = e ? 514 : 1;
this.optionFlags & 4 && (s |= 512), this.optionFlags & 16 && (s |= 48), this.scope.enter(s);
}
checkDestructuringPrivate(t) {
let { privateKeyLoc: e } = t;
e !== null && this.expectPlugin("destructuringPrivate", e);
}
}, Y = class {
shorthandAssignLoc = null;
doubleProtoLoc = null;
privateKeyLoc = null;
optionalParametersLoc = null;
voidPatternLoc = null;
}, de = class {
constructor(t, e, s) {
this.start = e, this.end = 0, this.loc = new Q(s), t?.optionFlags & 128 && (this.range = [e, 0]), t?.filename && (this.loc.filename = t.filename);
}
type = "";
}, Vt = de.prototype, ot = class extends nt {
startNode() {
let t = this.state.startLoc;
return new de(this, t.index, t);
}
startNodeAt(t) {
return new de(this, t.index, t);
}
startNodeAtNode(t) {
return this.startNodeAt(t.loc.start);
}
finishNode(t, e) {
return this.finishNodeAt(t, e, this.state.lastTokEndLoc);
}
finishNodeAt(t, e, s) {
return t.type = e, t.end = s.index, t.loc.end = s, this.optionFlags & 128 && (t.range[1] = s.index), this.optionFlags & 4096 && this.processComment(t), t;
}
resetStartLocation(t, e) {
t.start = e.index, t.loc.start = e, this.optionFlags & 128 && (t.range[0] = e.index);
}
resetEndLocation(t, e = this.state.lastTokEndLoc) {
t.end = e.index, t.loc.end = e, this.optionFlags & 128 && (t.range[1] = e.index);
}
resetStartLocationFromNode(t, e) {
this.resetStartLocation(t, e.loc.start);
}
castNodeTo(t, e) {
return t.type = e, t;
}
cloneIdentifier(t) {
let { type: e, start: s, end: i, loc: r, range: n, name: o } = t, h = Object.create(Vt);
return h.type = e, h.start = s, h.end = i, h.loc = r, h.range = n, h.name = o, t.extra && (h.extra = t.extra), h;
}
cloneStringLiteral(t) {
let { type: e, start: s, end: i, loc: r, range: n, extra: o } = t, h = Object.create(Vt);
return h.type = e, h.start = s, h.end = i, h.loc = r, h.range = n, h.extra = o, h.value = t.value, h;
}
}, ht = (a2) => a2.type === "ParenthesizedExpression" ? ht(a2.expression) : a2, ct = class extends ot {
toAssignable(t, e = !1) {
let s;
switch ((t.type === "ParenthesizedExpression" || t.extra?.parenthesized) && (s = ht(t), e ? s.type === "Identifier" ? this.expressionScope.recordArrowParameterBindingError(p.InvalidParenthesizedAssignment, t) : s.type !== "CallExpression" && s.type !== "MemberExpression" && !this.isOptionalMemberExpression(s) && this.raise(p.InvalidParenthesizedAssignment, t) : this.raise(p.InvalidParenthesizedAssignment, t)), t.type) {
case "Identifier":
case "ObjectPattern":
case "ArrayPattern":
case "AssignmentPattern":
case "RestElement":
case "VoidPattern":
break;
case "ObjectExpression":
this.castNodeTo(t, "ObjectPattern");
for (let i = 0, r = t.properties.length, n = r - 1; i < r; i++) {
let o = t.properties[i], h = i === n;
this.toAssignableObjectExpressionProp(o, h, e), h && o.type === "RestElement" && t.extra?.trailingCommaLoc && this.raise(p.RestTrailingComma, t.extra.trailingCommaLoc);
}
break;
case "ObjectProperty": {
let { key: i, value: r } = t;
this.isPrivateName(i) && this.classScope.usePrivateName(this.getPrivateNameSV(i), i.loc.start), this.toAssignable(r, e);
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(t, "ArrayPattern"), this.toAssignableList(t.elements, t.extra?.trailingCommaLoc, e);
break;
case "AssignmentExpression":
t.operator !== "=" && this.raise(p.MissingEqInAssignment, t.left.loc.end), this.castNodeTo(t, "AssignmentPattern"), delete t.operator, t.left.type === "VoidPattern" && this.raise(p.VoidPatternInitializer, t.left), this.toAssignable(t.left, e);
break;
case "ParenthesizedExpression":
this.toAssignable(s, e);
break;
}
}
toAssignableObjectExpressionProp(t, e, s) {
if (t.type === "ObjectMethod") this.raise(t.kind === "get" || t.kind === "set" ? p.PatternHasAccessor : p.PatternHasMethod, t.key);
else if (t.type === "SpreadElement") {
this.castNodeTo(t, "RestElement");
let i = t.argument;
this.checkToRestConversion(i, !1), this.toAssignable(i, s), e || this.raise(p.RestTrailingComma, t);
} else this.toAssignable(t, s);
}
toAssignableList(t, e, s) {
let i = t.length - 1;
for (let r = 0; r <= i; r++) {
let n = t[r];
n && (this.toAssignableListItem(t, r, s), n.type === "RestElement" && (r < i ? this.raise(p.RestTrailingComma, n) : e && this.raise(p.RestTrailingComma, e)));
}
}
toAssignableListItem(t, e, s) {
let i = t[e];
if (i.type === "SpreadElement") {
this.castNodeTo(i, "RestElement");
let r = i.argument;
this.checkToRestConversion(r, !0), this.toAssignable(r, s);
} else this.toAssignable(i, s);
}
isAssignable(t, e) {
switch (t.type) {
case "Identifier":
case "ObjectPattern":
case "ArrayPattern":
case "AssignmentPattern":
case "RestElement":
case "VoidPattern":
return !0;
case "ObjectExpression": {
let s = t.properties.length - 1;
return t.properties.every((i, r) => i.type !== "ObjectMethod" && (r === s || i.type !== "SpreadElement") && this.isAssignable(i));
}
case "ObjectProperty":
return this.isAssignable(t.value);
case "SpreadElement":
return this.isAssignable(t.argument);
case "ArrayExpression":
return t.elements.every((s) => s === null || this.isAssignable(s));
case "AssignmentExpression":
return t.operator === "=";
case "ParenthesizedExpression":
return this.isAssignable(t.expression);
case "MemberExpression":
case "OptionalMemberExpression":
return !e;
default:
return !1;
}
}
toReferencedList(t, e) {
return t;
}
toReferencedListDeep(t, e) {
this.toReferencedList(t, e);
for (let s of t) s?.type === "ArrayExpression" && this.toReferencedListDeep(s.elements);
}
parseSpread(t) {
let e = this.startNode();
return this.next(), e.argument = this.parseMaybeAssignAllowIn(t, void 0), this.finishNode(e, "SpreadElement");
}
parseRestBinding() {
let t = this.startNode();
this.next();
let e = this.parseBindingAtom();
return e.type === "VoidPattern" && this.raise(p.UnexpectedVoidPattern, e), t.argument = e, this.finishNode(t, "RestElement");
}
parseBindingAtom() {
switch (this.state.type) {
case 0: {
let t = this.startNode();
return this.next(), t.elements = this.parseBindingList(3, 93, 1), this.finishNode(t, "ArrayPattern");
}
case 5:
return this.parseObjectLike(8, !0);
case 88:
return this.parseVoidPattern(null);
}
return this.parseIdentifier();
}
parseBindingList(t, e, s) {
let i = s & 1, r = [], n = !0;
for (; !this.eat(t); ) if (n ? n = !1 : this.expect(12), i && this.match(12)) r.push(null);
else {
if (this.eat(t)) break;
if (this.match(21)) {
let o = this.parseRestBinding();
if (s & 2 && (o = this.parseFunctionParamType(o)), r.push(o), !this.checkCommaAfterRest(e)) {
this.expect(t);
break;
}
} else {
let o = [];
if (s & 2) for (this.match(26) && this.hasPlugin("decorators") && this.raise(p.UnsupportedParameterDecorator, this.state.startLoc); this.match(26); ) o.push(this.parseDecorator());
r.push(this.parseBindingElement(s, o));
}
}
return r;
}
parseBindingRestProperty(t) {
return this.next(), this.hasPlugin("discardBinding") && this.match(88) ? (t.argument = this.parseVoidPattern(null), this.raise(p.UnexpectedVoidPattern, t.argument)) : t.argument = this.parseIdentifier(), this.checkCommaAfterRest(125), this.finishNode(t, "RestElement");
}
parseBindingProperty() {
let { type: t, startLoc: e } = this.state;
if (t === 21) return this.parseBindingRestProperty(this.startNode());
let s = this.startNode();
return t === 139 ? (this.expectPlugin("destructuringPrivate", e), this.classScope.usePrivateName(this.state.value, e), s.key = this.parsePrivateName()) : this.parsePropertyName(s), s.method = !1, this.parseObjPropValue(s, e, !1, !1, !0, !1);
}
parseBindingElement(t, e) {
let s = this.parseMaybeDefault();
return t & 2 && this.parseFunctionParamType(s), e.length && (s.decorators = e, this.resetStartLocationFromNode(s, e[0])), this.parseMaybeDefault(s.loc.start, s);
}
parseFunctionParamType(t) {
return t;
}
parseMaybeDefault(t, e) {
if (t ?? (t = this.state.startLoc), e = e ?? this.parseBindingAtom(), !this.eat(29)) return e;
let s = this.startNodeAt(t);
return e.type === "VoidPattern" && this.raise(p.VoidPatternInitializer, e), s.left = e, s.right = this.parseMaybeAssignAllowIn(), this.finishNode(s, "AssignmentPattern");
}
isValidLVal(t, e, s, i) {
switch (t) {
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 !0;
case "CallExpression":
if (!e && !this.state.strict && this.optionFlags & 8192) return !0;
}
return !1;
}
isOptionalMemberExpression(t) {
return t.type === "OptionalMemberExpression";
}
checkLVal(t, e, s = 64, i = !1, r = !1, n = !1, o = !1) {
let h = t.type;
if (this.isObjectMethod(t)) return;
let l = this.isOptionalMemberExpression(t);
if (l || h === "MemberExpression") {
l && (this.expectPlugin("optionalChainingAssign", t.loc.start), e.type !== "AssignmentExpression" && this.raise(p.InvalidLhsOptionalChaining, t, { ancestor: e })), s !== 64 && this.raise(p.InvalidPropertyBindingPattern, t);
return;
}
if (h === "Identifier") {
this.checkIdentifier(t, s, r);
let { name: N } = t;
i && (i.has(N) ? this.raise(p.ParamDupe, t) : i.add(N));
return;
} else h === "VoidPattern" && e.type === "CatchClause" && this.raise(p.VoidPatternCatchClauseParam, t);
let u = ht(t);
o || (o = u.type === "CallExpression" && (u.callee.type === "Import" || u.callee.type === "Super"));
let f = this.isValidLVal(h, o, !(n || t.extra?.parenthesized) && e.type === "AssignmentExpression", s);
if (f === !0) return;
if (f === !1) {
let N = s === 64 ? p.InvalidLhs : p.InvalidLhsBinding;
this.raise(N, t, { ancestor: e });
return;
}
let d, x;
typeof f == "string" ? (d = f, x = h === "ParenthesizedExpression") : [d, x] = f;
let A = h === "ArrayPattern" || h === "ObjectPattern" ? { type: h } : e, k = t[d];
if (Array.isArray(k)) for (let N of k) N && this.checkLVal(N, A, s, i, r, x, !0);
else k && this.checkLVal(k, A, s, i, r, x, o);
}
checkIdentifier(t, e, s = !1) {
this.state.strict && (s ? ts(t.name, this.inModule) : es(t.name)) && (e === 64 ? this.raise(p.StrictEvalArguments, t, { referenceName: t.name }) : this.raise(p.StrictEvalArgumentsBinding, t, { bindingName: t.name })), e & 8192 && t.name === "let" && this.raise(p.LetInLexicalBinding, t), e & 64 || this.declareNameFromIdentifier(t, e);
}
declareNameFromIdentifier(t, e) {
this.scope.declareName(t.name, e, t.loc.start);
}
checkToRestConversion(t, e) {
switch (t.type) {
case "ParenthesizedExpression":
this.checkToRestConversion(t.expression, e);
break;
case "Identifier":
case "MemberExpression":
break;
case "ArrayExpression":
case "ObjectExpression":
if (e) break;
default:
this.raise(p.InvalidRestAssignmentPattern, t);
}
}
checkCommaAfterRest(t) {
return this.match(12) ? (this.raise(this.lookaheadCharCode() === t ? p.RestTrailingComma : p.ElementAfterRest, this.state.startLoc), !0) : !1;
}
}, Ve = /in(?:stanceof)?|as|satisfies/y;
y = F`typescript`({ AbstractMethodHasImplementation: ({ methodName: a2 }) => `Method '${a2}' cannot have an implementation because it is marked abstract.`, AbstractPropertyHasInitializer: ({ propertyName: a2 }) => `Property '${a2}' 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: a2 }) => `'declare' is not allowed in ${a2}ters.`, DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.", DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.", DuplicateAccessibilityModifier: ({ modifier: a2 }) => `Accessibility modifier already seen: '${a2}'.`, DuplicateModifier: ({ modifier: a2 }) => `Duplicate modifier: '${a2}'.`, EmptyHeritageClauseType: ({ token: a2 }) => `'${a2}' 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: a2 }) => `'${a2[0]}' modifier cannot be used with '${a2[1]}' modifier.`, IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.", IndexSignatureHasAccessibility: ({ modifier: a2 }) => `Index signatures cannot have an accessibility modifier ('${a2}').`, 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: a2 }) => `'${a2}' list can only include identifiers or qualified-names with optional type arguments.`, InvalidModifierOnAwaitUsingDeclaration: (a2) => `'${a2}' modifier cannot appear on an await using declaration.`, InvalidModifierOnTypeMember: ({ modifier: a2 }) => `'${a2}' modifier cannot appear on a type member.`, InvalidModifierOnTypeParameter: ({ modifier: a2 }) => `'${a2}' modifier cannot appear on a type parameter.`, InvalidModifierOnTypeParameterPositions: ({ modifier: a2 }) => `'${a2}' modifier can only appear on a type parameter of a class, interface or type alias.`, InvalidModifierOnUsingDeclaration: (a2) => `'${a2}' modifier cannot appear on a using declaration.`, InvalidModifiersOrder: ({ orderedModifiers: a2 }) => `'${a2[0]}' modifier must precede '${a2[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: a2 }) => `Private elements cannot have an accessibility modifier ('${a2}').`, 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 `<T,>() => ...`.", 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: a2 }) => `Single type parameter ${a2} should have a trailing comma. Example usage: <${a2},>.`, 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: a2 }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${a2}.`, UsingDeclarationInAmbientContext: (a2) => `'${a2}' declarations are not allowed in ambient contexts.` });
Ji = (a2) => class extends a2 {
getScopeHandler() {
return Ge;
}
tsIsIdentifier() {
return w(this.state.type);
}
tsTokenCanFollowModifier() {
return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(139) || this.isLiteralPropertyName();
}
tsNextTokenOnSameLineAndCanFollowModifier() {
return this.next(), this.hasPrecedingLineBreak() ? !1 : this.tsTokenCanFollowModifier();
}
tsNextTokenCanFollowModifier() {
return this.match(106) ? (this.next(), this.tsTokenCanFollowModifier()) : this.tsNextTokenOnSameLineAndCanFollowModifier();
}
tsParseModifier(e, s, i) {
if (!w(this.state.type) && this.state.type !== 58 && this.state.type !== 75) return;
let r = this.state.value;
if (e.includes(r)) {
if (i && this.match(106) || s && this.tsIsStartOfStaticBlocks()) return;
if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) return r;
}
}
tsParseModifiers({ allowedModifiers: e, disallowedModifiers: s, stopOnStartOfClassStaticBlock: i, errorTemplate: r = y.InvalidModifierOnTypeMember }, n) {
let o = (l, u, f, d) => {
u === f && n[d] && this.raise(y.InvalidModifiersOrder, l, { orderedModifiers: [f, d] });
}, h = (l, u, f, d) => {
(n[f] && u === d || n[d] && u === f) && this.raise(y.IncompatibleModifiers, l, { modifiers: [f, d] });
};
for (; ; ) {
let { startLoc: l } = this.state, u = this.tsParseModifier(e.concat(s ?? []), i, n.static);
if (!u) break;
qt(u) ? n.accessibility ? this.raise(y.DuplicateAccessibilityModifier, l, { modifier: u }) : (o(l, u, u, "override"), o(l, u, u, "static"), o(l, u, u, "readonly"), n.accessibility = u) : Wi(u) ? (n[u] && this.raise(y.DuplicateModifier, l, { modifier: u }), n[u] = !0, o(l, u, "in", "out")) : (Object.prototype.hasOwnProperty.call(n, u) ? this.raise(y.DuplicateModifier, l, { modifier: u }) : (o(l, u, "static", "readonly"), o(l, u, "static", "override"), o(l, u, "override", "readonly"), o(l, u, "abstract", "override"), h(l, u, "declare", "override"), h(l, u, "static", "abstract")), n[u] = !0), s?.includes(u) && this.raise(r, l, { modifier: u });
}
}
tsIsListTerminator(e) {
switch (e) {
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(e, s) {
let i = [];
for (; !this.tsIsListTerminator(e); ) i.push(s());
return i;
}
tsParseDelimitedList(e, s, i) {
return Ki(this.tsParseDelimitedListWorker(e, s, !0, i));
}
tsParseDelimitedListWorker(e, s, i, r) {
let n = [], o = -1;
for (; !this.tsIsListTerminator(e); ) {
o = -1;
let h = s();
if (h == null) return;
if (n.push(h), this.eat(12)) {
o = this.state.lastTokStartLoc.index;
continue;
}
if (this.tsIsListTerminator(e)) break;
i && this.expect(12);
return;
}
return r && (r.value = o), n;
}
tsParseBracketedList(e, s, i, r, n) {
r || (i ? this.expect(0) : this.expect(47));
let o = this.tsParseDelimitedList(e, s, n);
return i ? this.expect(3) : this.expect(48), o;
}
tsParseImportType() {
let e = this.startNode();
return this.expect(83), this.expect(10), this.match(134) ? e.argument = this.tsParseLiteralTypeNode() : (this.raise(y.UnsupportedImportTypeArgument, this.state.startLoc), e.argument = this.tsParseNonConditionalType()), this.eat(12) ? e.options = this.tsParseImportTypeOptions() : e.options = null, this.expect(11), this.eat(16) && (e.qualifier = this.tsParseEntityName(3)), this.match(47) && (e.typeArguments = this.tsParseTypeArguments()), this.finishNode(e, "TSImportType");
}
tsParseImportTypeOptions() {
let e = this.startNode();
this.expect(5);
let s = this.startNode();
return this.isContextual(76) ? (s.method = !1, s.key = this.parseIdentifier(!0), s.computed = !1, s.shorthand = !1) : this.unexpected(null, 76), this.expect(14), s.value = this.tsParseImportTypeWithPropertyValue(), e.properties = [this.finishObjectProperty(s)], this.eat(12), this.expect(8), this.finishNode(e, "ObjectExpression");
}
tsParseImportTypeWithPropertyValue() {
let e = this.startNode(), s = [];
for (this.expect(5); !this.match(8); ) {
let i = this.state.type;
w(i) || i === 134 ? s.push(super.parsePropertyDefinition(null)) : this.unexpected(), this.eat(12);
}
return e.properties = s, this.next(), this.finishNode(e, "ObjectExpression");
}
tsParseEntityName(e) {
let s;
if (e & 1 && this.match(78)) if (e & 2) s = this.parseIdentifier(!0);
else {
let i = this.startNode();
this.next(), s = this.finishNode(i, "ThisExpression");
}
else s = this.parseIdentifier(!!(e & 1));
for (; this.eat(16); ) {
let i = this.startNodeAtNode(s);
i.left = s, i.right = this.parseIdentifier(!!(e & 1)), s = this.finishNode(i, "TSQualifiedName");
}
return s;
}
tsParseTypeReference() {
let e = this.startNode();
return e.typeName = this.tsParseEntityName(1), !this.hasPrecedingLineBreak() && this.match(47) && (e.typeArguments = this.tsParseTypeArguments()), this.finishNode(e, "TSTypeReference");
}
tsParseThisTypePredicate(e) {
this.next();
let s = this.startNodeAtNode(e);
return s.parameterName = e, s.typeAnnotation = this.tsParseTypeAnnotation(!1), s.asserts = !1, this.finishNode(s, "TSTypePredicate");
}
tsParseThisTypeNode() {
let e = this.startNode();
return this.next(), this.finishNode(e, "TSThisType");
}
tsParseTypeQuery() {
let e = this.startNode();
return this.expect(87), this.match(83) ? e.exprName = this.tsParseImportType() : e.exprName = this.tsParseEntityName(1), !this.hasPrecedingLineBreak() && this.match(47) && (e.typeArguments = this.tsParseTypeArguments()), this.finishNode(e, "TSTypeQuery");
}
tsParseInOutModifiers = this.tsParseModifiers.bind(this, { allowedModifiers: ["in", "out"], disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"], errorTemplate: y.InvalidModifierOnTypeParameter });
tsParseConstModifier = this.tsParseModifiers.bind(this, { allowedModifiers: ["const"], disallowedModifiers: ["in", "out"], errorTemplate: y.InvalidModifierOnTypeParameterPositions });
tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, { allowedModifiers: ["in", "out", "const"], disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"], errorTemplate: y.InvalidModifierOnTypeParameter });
tsParseTypeParameter(e) {
let s = this.startNode();
return e(s), s.name = this.tsParseTypeParameterName(), s.constraint = this.tsEatThenParseType(81), s.default = this.tsEatThenParseType(29), this.finishNode(s, "TSTypeParameter");
}
tsTryParseTypeParameters(e) {
if (this.match(47)) return this.tsParseTypeParameters(e);
}
tsParseTypeParameters(e) {
let s = this.startNode();
this.match(47) || this.match(143) ? this.next() : this.unexpected();
let i = { value: -1 };
return s.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, e), !1, !0, i), s.params.length === 0 && this.raise(y.EmptyTypeParameters, s), i.value !== -1 && this.addExtra(s, "trailingComma", i.value), this.finishNode(s, "TSTypeParameterDeclaration");
}
tsFillSignature(e, s) {
let i = e === 19, r = "params", n = "returnType";
s.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier), this.expect(10), s[r] = this.tsParseBindingListForSignature(), i ? s[n] = this.tsParseTypeOrTypePredicateAnnotation(e) : this.match(e) && (s[n] = this.tsParseTypeOrTypePredicateAnnotation(e));
}
tsParseBindingListForSignature() {
let e = super.parseBindingList(11, 41, 2);
for (let s of e) {
let { type: i } = s;
(i === "AssignmentPattern" || i === "TSParameterProperty") && this.raise(y.UnsupportedSignatureParameterKind, s, { type: i });
}
return e;
}
tsParseTypeMemberSemicolon() {
!this.eat(12) && !this.isLineTerminator() && this.expect(13);
}
tsParseSignatureMember(e, s) {
return this.tsFillSignature(14, s), this.tsParseTypeMemberSemicolon(), this.finishNode(s, e);
}
tsIsUnambiguouslyIndexSignature() {
return this.next(), w(this.state.type) ? (this.next(), this.match(14)) : !1;
}
tsTryParseIndexSignature(e) {
if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) return;
this.expect(0);
let s = this.parseIdentifier();
s.typeAnnotation = this.tsParseTypeAnnotation(), this.resetEndLocation(s), this.expect(3), e.parameters = [s];
let i = this.tsTryParseTypeAnnotation();
return i && (e.typeAnnotation = i), this.tsParseTypeMemberSemicolon(), this.finishNode(e, "TSIndexSignature");
}
tsParsePropertyOrMethodSignature(e, s) {
if (this.eat(17) && (e.optional = !0), this.match(10) || this.match(47)) {
s && this.raise(y.ReadonlyForMethodSignature, e);
let i = e;
i.kind && this.match(47) && this.raise(y.AccessorCannotHaveTypeParameters, this.state.curPosition()), this.tsFillSignature(14, i), this.tsParseTypeMemberSemicolon();
let r = "params", n = "returnType";
if (i.kind === "get") i[r].length > 0 && (this.raise(p.BadGetterArity, this.state.curPosition()), this.isThisParam(i[r][0]) && this.raise(y.AccessorCannotDeclareThisParameter, this.state.curPosition()));
else if (i.kind === "set") {
if (i[r].length !== 1) this.raise(p.BadSetterArity, this.state.curPosition());
else {
let o = i[r][0];
this.isThisParam(o) && this.raise(y.AccessorCannotDeclareThisParameter, this.state.curPosition()), o.type === "Identifier" && o.optional && this.raise(y.SetAccessorCannotHaveOptionalParameter, this.state.curPosition()), o.type === "RestElement" && this.raise(y.SetAccessorCannotHaveRestParameter, this.state.curPosition());
}
i[n] && this.raise(y.SetAccessorCannotHaveReturnType, i[n]);
} else i.kind = "method";
return this.finishNode(i, "TSMethodSignature");
} else {
let i = e;
s && (i.readonly = !0);
let r = this.tsTryParseTypeAnnotation();
return r && (i.typeAnnotation = r), this.tsParseTypeMemberSemicolon(), this.finishNode(i, "TSPropertySignature");
}
}
tsParseTypeMember() {
let e = this.startNode();
if (this.match(10) || this.match(47)) return this.tsParseSignatureMember("TSCallSignatureDeclaration", e);
if (this.match(77)) {
let i = this.startNode();
return this.next(), this.match(10) || this.match(47) ? this.tsParseSignatureMember("TSConstructSignatureDeclaration", e) : (e.key = this.createIdentifier(i, "new"), this.tsParsePropertyOrMethodSignature(e, !1));
}
return this.tsParseModifiers({ allowedModifiers: ["readonly"], disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"] }, e), this.tsTryParseIndexSignature(e) || (super.parsePropertyName(e), !e.computed && e.key.type === "Identifier" && (e.key.name === "get" || e.key.name === "set") && this.tsTokenCanFollowModifier() && (e.kind = e.key.name, super.parsePropertyName(e), !this.match(10) && !this.match(47) && this.unexpected(null, 10)), this.tsParsePropertyOrMethodSignature(e, !!e.readonly));
}
tsParseTypeLiteral() {
let e = this.startNode();
return e.members = this.tsParseObjectTypeMembers(), this.finishNode(e, "TSTypeLiteral");
}
tsParseObjectTypeMembers() {
this.expect(5);
let e = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
return this.expect(8), e;
}
tsIsStartOfMappedType() {
return this.next(), this.eat(53) ? this.isContextual(122) : (this.isContextual(122) && this.next(), !this.match(0) || (this.next(), !this.tsIsIdentifier()) ? !1 : (this.next(), this.match(58)));
}
tsParseMappedType() {
let e = this.startNode();
return this.expect(5), this.match(53) ? (e.readonly = this.state.value, this.next(), this.expectContextual(122)) : this.eatContextual(122) && (e.readonly = !0), this.expect(0), e.key = this.tsParseTypeParameterName(), e.constraint = this.tsExpectThenParseType(58), e.nameType = this.eatContextual(93) ? this.tsParseType() : null, this.expect(3), this.match(53) ? (e.optional = this.state.value, this.next(), this.expect(17)) : this.eat(17) && (e.optional = !0), e.typeAnnotation = this.tsTryParseType(), this.semicolon(), this.expect(8), this.finishNode(e, "TSMappedType");
}
tsParseTupleType() {
let e = this.startNode();
e.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), !0, !1);
let s = !1;
return e.elementTypes.forEach((i) => {
let { type: r } = i;
s && r !== "TSRestType" && r !== "TSOptionalType" && !(r === "TSNamedTupleMember" && i.optional) && this.raise(y.OptionalTypeBeforeRequired, i), s || (s = r === "TSNamedTupleMember" && i.optional || r === "TSOptionalType");
}), this.finishNode(e, "TSTupleType");
}
tsParseTupleElementType() {
let e = this.state.startLoc, s = this.eat(21), { startLoc: i } = this.state, r, n, o, h, u = O(this.state.type) ? this.lookaheadCharCode() : null;
if (u === 58) r = !0, o = !1, n = this.parseIdentifier(!0), this.expect(14), h = this.tsParseType();
else if (u === 63) {
o = !0;
let f = this.state.value, d = this.tsParseNonArrayType();
this.lookaheadCharCode() === 58 ? (r = !0, n = this.createIdentifier(this.startNodeAt(i), f), this.expect(17), this.expect(14), h = this.tsParseType()) : (r = !1, h = d, this.expect(17));
} else h = this.tsParseType(), o = this.eat(17), r = this.eat(14);
if (r) {
let f;
n ? (f = this.startNodeAt(i), f.optional = o, f.label = n, f.elementType = h, this.eat(17) && (f.optional = !0, this.raise(y.TupleOptionalAfterType, this.state.lastTokStartLoc))) : (f = this.startNodeAt(i), f.optional = o, this.raise(y.InvalidTupleMemberLabel, h), f.label = h, f.elementType = this.tsParseType()), h = this.finishNode(f, "TSNamedTupleMember");
} else if (o) {
let f = this.startNodeAt(i);
f.typeAnnotation = h, h = this.finishNode(f, "TSOptionalType");
}
if (s) {
let f = this.startNodeAt(e);
f.typeAnnotation = h, h = this.finishNode(f, "TSRestType");
}
return h;
}
tsParseParenthesizedType() {
let e = this.startNode();
return this.expect(10), e.typeAnnotation = this.tsParseType(), this.expect(11), this.finishNode(e, "TSParenthesizedType");
}
tsParseFunctionOrConstructorType(e, s) {
let i = this.startNode();
return e === "TSConstructorType" && (i.abstract = !!s, s && this.next(), this.next()), this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, i)), this.finishNode(i, e);
}
tsParseLiteralTypeNode() {
let e = this.startNode();
switch (this.state.type) {
case 135:
case 136:
case 134:
case 85:
case 86:
e.literal = super.parseExprAtom();
break;
default:
this.unexpected();
}
return this.finishNode(e, "TSLiteralType");
}
tsParseTemplateLiteralType() {
{
let e = this.state.startLoc, s = this.parseTemplateElement(!1), i = [s];
if (s.tail) {
let r = this.startNodeAt(e), n = this.startNodeAt(e);
return n.expressions = [], n.quasis = i, r.literal = this.finishNode(n, "TemplateLiteral"), this.finishNode(r, "TSLiteralType");
} else {
let r = [];
for (; !s.tail; ) r.push(this.tsParseType()), this.readTemplateContinuation(), i.push(s = this.parseTemplateElement(!1));
let n = this.startNodeAt(e);
return n.types = r, n.quasis = i, this.finishNode(n, "TSTemplateLiteralType");
}
}
}
parseTemplateSubstitution() {
return this.state.inType ? this.tsParseType() : super.parseTemplateSubstitution();
}
tsParseThisTypeOrThisTypePredicate() {
let e = this.tsParseThisTypeNode();
return this.isContextual(116) && !this.hasPrecedingLineBreak() ? this.tsParseThisTypePredicate(e) : e;
}
tsParseNonArrayType() {
switch (this.state.type) {
case 134:
case 135:
case 136:
case 85:
case 86:
return this.tsParseLiteralTypeNode();
case 53:
if (this.state.value === "-") {
let e = this.startNode(), s = this.lookahead();
return s.type !== 135 && s.type !== 136 && this.unexpected(), e.literal = this.parseMaybeUnary(), this.finishNode(e, "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:
if (!(this.optionFlags & 1024)) {
let e = this.state.startLoc;
this.next();
let s = this.tsParseType();
return this.expect(11), this.addExtra(s, "parenthesized", !0), this.addExtra(s, "parenStart", e.index), s;
}
return this.tsParseParenthesizedType();
case 25:
case 24:
return this.tsParseTemplateLiteralType();
default: {
let { type: e } = this.state;
if (w(e) || e === 88 || e === 84) {
let s = e === 88 ? "TSVoidKeyword" : e === 84 ? "TSNullKeyword" : Hi(this.state.value);
if (s !== void 0 && this.lookaheadCharCode() !== 46) {
let i = this.startNode();
return this.next(), this.finishNode(i, s);
}
return this.tsParseTypeReference();
}
}
}
throw this.unexpected();
}
tsParseArrayTypeOrHigher() {
let { startLoc: e } = this.state, s = this.tsParseNonArrayType();
for (; !this.hasPrecedingLineBreak() && this.eat(0); ) if (this.match(3)) {
let i = this.startNodeAt(e);
i.elementType = s, this.expect(3), s = this.finishNode(i, "TSArrayType");
} else {
let i = this.startNodeAt(e);
i.objectType = s, i.indexType = this.tsParseType(), this.expect(3), s = this.finishNode(i, "TSIndexedAccessType");
}
return s;
}
tsParseTypeOperator() {
let e = this.startNode(), s = this.state.value;
return this.next(), e.operator = s, e.typeAnnotation = this.tsParseTypeOperatorOrHigher(), s === "readonly" && this.tsCheckTypeAnnotationForReadOnly(e), this.finishNode(e, "TSTypeOperator");
}
tsCheckTypeAnnotationForReadOnly(e) {
switch (e.typeAnnotation.type) {
case "TSTupleType":
case "TSArrayType":
return;
default:
this.raise(y.UnexpectedReadonly, e);
}
}
tsParseInferType() {
let e = this.startNode();
this.expectContextual(115);
let s = this.startNode();
return s.name = this.tsParseTypeParameterName(), s.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType()), e.typeParameter = this.finishNode(s, "TSTypeParameter"), this.finishNode(e, "TSInferType");
}
tsParseConstraintForInferType() {
if (this.eat(81)) {
let e = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
if (this.state.inDisallowConditionalTypesContext || !this.match(17)) return e;
}
}
tsParseTypeOperatorOrHigher() {
return mi(this.state.type) && !this.state.containsEsc ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
}
tsParseUnionOrIntersectionType(e, s, i) {
let r = this.startNode(), n = this.eat(i), o = [];
do
o.push(s());
while (this.eat(i));
return o.length === 1 && !n ? o[0] : (r.types = o, this.finishNode(r, e));
}
tsParseIntersectionTypeOrHigher() {
return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
}
tsParseUnionTypeOrHigher() {
return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
}
tsIsStartOfFunctionType() {
return this.match(47) ? !0 : this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
}
tsSkipParameterStart() {
if (w(this.state.type) || this.match(78)) return this.next(), !0;
if (this.match(5)) {
let { errors: e } = this.state, s = e.length;
try {
return this.parseObjectLike(8, !0), e.length === s;
} catch {
return !1;
}
}
if (this.match(0)) {
this.next();
let { errors: e } = this.state, s = e.length;
try {
return super.parseBindingList(3, 93, 1), e.length === s;
} catch {
return !1;
}
}
return !1;
}
tsIsUnambiguouslyStartOfFunctionType() {
return this.next(), !!(this.match(11) || this.match(21) || this.tsSkipParameterStart() && (this.match(14) || this.match(12) || this.match(17) || this.match(29) || this.match(11) && (this.next(), this.match(19))));
}
tsParseTypeOrTypePredicateAnnotation(e) {
return this.tsInType(() => {
let s = this.startNode();
this.expect(e);
let i = this.startNode(), r = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
if (r && this.match(78)) {
let h = this.tsParseThisTypeOrThisTypePredicate();
return h.type === "TSThisType" ? (i.parameterName = h, i.asserts = !0, i.typeAnnotation = null, h = this.finishNode(i, "TSTypePredicate")) : (this.resetStartLocationFromNode(h, i), h.asserts = !0), s.typeAnnotation = h, this.finishNode(s, "TSTypeAnnotation");
}
let n = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
if (!n) return r ? (i.parameterName = this.parseIdentifier(), i.asserts = r, i.typeAnnotation = null, s.typeAnnotation = this.finishNode(i, "TSTypePredicate"), this.finishNode(s, "TSTypeAnnotation")) : this.tsParseTypeAnnotation(!1, s);
let o = this.tsParseTypeAnnotation(!1);
return i.parameterName = n, i.typeAnnotation = o, i.asserts = r, s.typeAnnotation = this.finishNode(i, "TSTypePredicate"), this.finishNode(s, "TSTypeAnnotation");
});
}
tsTryParseTypeOrTypePredicateAnnotation() {
if (this.match(14)) return this.tsParseTypeOrTypePredicateAnnotation(14);
}
tsTryParseTypeAnnotation() {
if (this.match(14)) return this.tsParseTypeAnnotation();
}
tsTryParseType() {
return this.tsEatThenParseType(14);
}
tsParseTypePredicatePrefix() {
let e = this.parseIdentifier();
if (this.isContextual(116) && !this.hasPrecedingLineBreak()) return this.next(), e;
}
tsParseTypePredicateAsserts() {
if (this.state.type !== 109) return !1;
let e = this.state.containsEsc;
return this.next(), !w(this.state.type) && !this.match(78) ? !1 : (e && this.raise(p.InvalidEscapedReservedWord, this.state.lastTokStartLoc, { reservedWord: "asserts" }), !0);
}
tsParseTypeAnnotation(e = !0, s = this.startNode()) {
return this.tsInType(() => {
e && this.expect(14), s.typeAnnotation = this.tsParseType();
}), this.finishNode(s, "TSTypeAnnotation");
}
tsParseType() {
zt(this.state.inType);
let e = this.tsParseNonConditionalType();
if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) return e;
let s = this.startNodeAtNode(e);
return s.checkType = e, s.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType()), this.expect(17), s.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()), this.expect(14), s.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()), this.finishNode(s, "TSConditionalType");
}
isAbstractConstructorSignature() {
return this.isContextual(124) && this.isLookaheadContextual("new");
}
tsParseNonConditionalType() {
return this.tsIsStartOfFunctionType() ? this.tsParseFunctionOrConstructorType("TSFunctionType") : this.match(77) ? this.tsParseFunctionOrConstructorType("TSConstructorType") : this.isAbstractConstructorSignature() ? this.tsParseFunctionOrConstructorType("TSConstructorType", !0) : this.tsParseUnionTypeOrHigher();
}
tsParseTypeAssertion() {
this.getPluginOption("typescript", "disallowAmbiguousJSXLike") && this.raise(y.ReservedTypeAssertion, this.state.startLoc);
let e = this.startNode();
return e.typeAnnotation = this.tsInType(() => (this.next(), this.match(75) ? this.tsParseTypeReference() : this.tsParseType())), this.expect(48), e.expression = this.parseMaybeUnary(), this.finishNode(e, "TSTypeAssertion");
}
tsParseHeritageClause(e) {
let s = this.state.startLoc, i = this.tsParseDelimitedList("HeritageClauseElement", () => {
{
let r = super.parseExprSubscripts();
lt(r) || this.raise(y.InvalidHeritageClauseType, r.loc.start, { token: e });
let n = e === "extends" ? "TSInterfaceHeritage" : "TSClassImplements";
if (r.type === "TSInstantiationExpression") return r.type = n, r;
let o = this.startNodeAtNode(r);
return o.expression = r, (this.match(47) || this.match(51)) && (o.typeArguments = this.tsParseTypeArgumentsInExpression()), this.finishNode(o, n);
}
});
return i.length || this.raise(y.EmptyHeritageClauseType, s, { token: e }), i;
}
tsParseInterfaceDeclaration(e, s = {}) {
if (this.hasFollowingLineBreak()) return null;
this.expectContextual(129), s.declare && (e.declare = !0), w(this.state.type) ? (e.id = this.parseIdentifier(), this.checkIdentifier(e.id, 130)) : (e.id = null, this.raise(y.MissingInterfaceName, this.state.startLoc)), e.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers), this.eat(81) && (e.extends = this.tsParseHeritageClause("extends"));
let i = this.startNode();
return i.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this)), e.body = this.finishNode(i, "TSInterfaceBody"), this.finishNode(e, "TSInterfaceDeclaration");
}
tsParseTypeAliasDeclaration(e) {
return e.id = this.parseIdentifier(), this.checkIdentifier(e.id, 2), e.typeAnnotation = this.tsInType(() => {
if (e.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers), this.expect(29), this.isContextual(114) && this.lookaheadCharCode() !== 46) {
let s = this.startNode();
return this.next(), this.finishNode(s, "TSIntrinsicKeyword");
}
return this.tsParseType();
}), this.semicolon(), this.finishNode(e, "TSTypeAliasDeclaration");
}
tsInTopLevelContext(e) {
if (this.curContext() !== E.brace) {
let s = this.state.context;
this.state.context = [s[0]];
try {
return e();
} finally {
this.state.context = s;
}
} else return e();
}
tsInType(e) {
let s = this.state.inType;
this.state.inType = !0;
try {
return e();
} finally {
this.state.inType = s;
}
}
tsInDisallowConditionalTypesContext(e) {
let s = this.state.inDisallowConditionalTypesContext;
this.state.inDisallowConditionalTypesContext = !0;
try {
return e();
} finally {
this.state.inDisallowConditionalTypesContext = s;
}
}
tsInAllowConditionalTypesContext(e) {
let s = this.state.inDisallowConditionalTypesContext;
this.state.inDisallowConditionalTypesContext = !1;
try {
return e();
} finally {
this.state.inDisallowConditionalTypesContext = s;
}
}
tsEatThenParseType(e) {
if (this.match(e)) return this.tsNextThenParseType();
}
tsExpectThenParseType(e) {
return this.tsInType(() => (this.expect(e), this.tsParseType()));
}
tsNextThenParseType() {
return this.tsInType(() => (this.next(), this.tsParseType()));
}
tsParseEnumMember() {
let e = this.startNode();
return e.id = this.match(134) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(!0), this.eat(29) && (e.initializer = super.parseMaybeAssignAllowIn()), this.finishNode(e, "TSEnumMember");
}
tsParseEnumDeclaration(e, s = {}) {
return s.const && (e.const = !0), s.declare && (e.declare = !0), this.expectContextual(126), e.id = this.parseIdentifier(), this.checkIdentifier(e.id, e.const ? 8971 : 8459), e.body = this.tsParseEnumBody(), this.finishNode(e, "TSEnumDeclaration");
}
tsParseEnumBody() {
let e = this.startNode();
return this.expect(5), e.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)), this.expect(8), this.finishNode(e, "TSEnumBody");
}
tsParseModuleBlock() {
let e = this.startNode();
return this.scope.enter(0), this.expect(5), super.parseBlockOrModuleBlockBody(e.body = [], void 0, !0, 8), this.scope.exit(), this.finishNode(e, "TSModuleBlock");
}
tsParseModuleOrNamespaceDeclaration(e, s = !1) {
return e.id = this.tsParseEntityName(1), e.id.type === "Identifier" && this.checkIdentifier(e.id, 1024), this.scope.enter(1024), this.prodParam.enter(0), e.body = this.tsParseModuleBlock(), this.prodParam.exit(), this.scope.exit(), this.finishNode(e, "TSModuleDeclaration");
}
tsParseAmbientExternalModuleDeclaration(e) {
return this.isContextual(112) ? (e.kind = "global", e.id = this.parseIdentifier()) : this.match(134) ? (e.kind = "module", e.id = super.parseStringLiteral(this.state.value)) : this.unexpected(), this.match(5) ? (this.scope.enter(1024), this.prodParam.enter(0), e.body = this.tsParseModuleBlock(), this.prodParam.exit(), this.scope.exit()) : this.semicolon(), this.finishNode(e, "TSModuleDeclaration");
}
tsParseImportEqualsDeclaration(e, s, i) {
e.id = s || this.parseIdentifier(), this.checkIdentifier(e.id, 4096), this.expect(29);
let r = this.tsParseModuleReference();
return e.importKind === "type" && r.type !== "TSExternalModuleReference" && this.raise(y.ImportAliasHasImportType, r), e.moduleReference = r, this.semicolon(), this.finishNode(e, "TSImportEqualsDeclaration");
}
tsIsExternalModuleReference() {
return this.isContextual(119) && this.lookaheadCharCode() === 40;
}
tsParseModuleReference() {
return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);
}
tsParseExternalModuleReference() {
let e = this.startNode();
return this.expectContextual(119), this.expect(10), this.match(134) || this.unexpected(), e.expression = super.parseExprAtom(), this.expect(11), this.sawUnambiguousESM = !0, this.finishNode(e, "TSExternalModuleReference");
}
tsLookAhead(e) {
let s = this.state.clone(), i = e();
return this.state = s, i;
}
tsTryParseAndCatch(e) {
let s = this.tryParse((i) => e() || i());
if (!(s.aborted || !s.node)) return s.error && (this.state = s.failState), s.node;
}
tsTryParse(e) {
let s = this.state.clone(), i = e();
if (i !== void 0 && i !== !1) return i;
this.state = s;
}
tsTryParseDeclare(e) {
if (this.isLineTerminator()) return;
let s = this.state.type;
return this.tsInAmbientContext(() => {
switch (s) {
case 68:
return e.declare = !0, super.parseFunctionStatement(e, !1, !1);
case 80:
return e.declare = !0, this.parseClass(e, !0, !1);
case 126:
return this.tsParseEnumDeclaration(e, { declare: !0 });
case 112:
return this.tsParseAmbientExternalModuleDeclaration(e);
case 100:
if (this.state.containsEsc) return;
case 75:
case 74:
return !this.match(75) || !this.isLookaheadContextual("enum") ? (e.declare = !0, this.parseVarStatement(e, this.state.value, !0)) : (this.expect(75), this.tsParseEnumDeclaration(e, { const: !0, declare: !0 }));
case 107:
if (this.isUsing()) return this.raise(y.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare"), e.declare = !0, this.parseVarStatement(e, "using", !0);
break;
case 96:
if (this.isAwaitUsing()) return this.raise(y.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare"), e.declare = !0, this.next(), this.parseVarStatement(e, "await using", !0);
break;
case 129: {
let i = this.tsParseInterfaceDeclaration(e, { declare: !0 });
if (i) return i;
}
default:
if (w(s)) return this.tsParseDeclaration(e, this.state.type, !0, null);
}
});
}
tsTryParseExportDeclaration() {
return this.tsParseDeclaration(this.startNode(), this.state.type, !0, null);
}
tsParseDeclaration(e, s, i, r) {
switch (s) {
case 124:
if (this.tsCheckLineTerminator(i) && (this.match(80) || w(this.state.type))) return this.tsParseAbstractDeclaration(e, r);
break;
case 127:
if (this.tsCheckLineTerminator(i)) {
if (this.match(134)) return this.tsParseAmbientExternalModuleDeclaration(e);
if (w(this.state.type)) return e.kind = "module", this.tsParseModuleOrNamespaceDeclaration(e);
}
break;
case 128:
if (this.tsCheckLineTerminator(i) && w(this.state.type)) return e.kind = "namespace", this.tsParseModuleOrNamespaceDeclaration(e);
break;
case 130:
if (this.tsCheckLineTerminator(i) && w(this.state.type)) return this.tsParseTypeAliasDeclaration(e);
break;
}
}
tsCheckLineTerminator(e) {
return e ? this.hasFollowingLineBreak() ? !1 : (this.next(), !0) : !this.isLineTerminator();
}
tsTryParseGenericAsyncArrowFunction(e) {
if (!this.match(47)) return;
let s = this.state.maybeInArrowParameters;
this.state.maybeInArrowParameters = !0;
let i = this.tsTryParseAndCatch(() => {
let r = this.startNodeAt(e);
return r.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier), super.parseFunctionParams(r), r.returnType = this.tsTryParseTypeOrTypePredicateAnnotation(), this.expect(19), r;
});
if (this.state.maybeInArrowParameters = s, !!i) return super.parseArrowExpression(i, null, !0);
}
tsParseTypeArgumentsInExpression() {
if (this.reScan_lt() === 47) return this.tsParseTypeArguments();
}
tsParseTypeArguments() {
let e = this.startNode();
return e.params = this.tsInType(() => this.tsInTopLevelContext(() => (this.expect(47), this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this))))), e.params.length === 0 ? this.raise(y.EmptyTypeArguments, e) : !this.state.inType && this.curContext() === E.brace && this.reScan_lt_gt(), this.expect(48), this.finishNode(e, "TSTypeParameterInstantiation");
}
tsIsDeclarationStart() {
return yi(this.state.type);
}
isExportDefaultSpecifier() {
return this.tsIsDeclarationStart() ? !1 : super.isExportDefaultSpecifier();
}
parseBindingElement(e, s) {
let i = s.length ? s[0].loc.start : this.state.startLoc, r = {};
this.tsParseModifiers({ allowedModifiers: ["public", "private", "protected", "override", "readonly"] }, r);
let n = r.accessibility, o = r.override, h = r.readonly;
!(e & 4) && (n || h || o) && this.raise(y.UnexpectedParameterModifier, i);
let l = this.parseMaybeDefault();
e & 2 && this.parseFunctionParamType(l);
let u = this.parseMaybeDefault(l.loc.start, l);
if (n || h || o) {
let f = this.startNodeAt(i);
return s.length && (f.decorators = s), n && (f.accessibility = n), h && (f.readonly = h), o && (f.override = o), u.type !== "Identifier" && u.type !== "AssignmentPattern" && this.raise(y.UnsupportedParameterPropertyKind, f), f.parameter = u, this.finishNode(f, "TSParameterProperty");
}
return s.length && (l.decorators = s), u;
}
isSimpleParameter(e) {
return e.type === "TSParameterProperty" && super.isSimpleParameter(e.parameter) || super.isSimpleParameter(e);
}
tsDisallowOptionalPattern(e) {
for (let s of e.params) s.type !== "Identifier" && s.optional && !this.state.isAmbientContext && this.raise(y.PatternIsOptional, s);
}
setArrowFunctionParameters(e, s, i) {
super.setArrowFunctionParameters(e, s, i), this.tsDisallowOptionalPattern(e);
}
parseFunctionBodyAndFinish(e, s, i = !1) {
this.match(14) && (e.returnType = this.tsParseTypeOrTypePredicateAnnotation(14));
let r = s === "FunctionDeclaration" ? "TSDeclareFunction" : s === "ClassMethod" || s === "ClassPrivateMethod" ? "TSDeclareMethod" : void 0;
return r && !this.match(5) && this.isLineTerminator() ? this.finishNode(e, r) : r === "TSDeclareFunction" && this.state.isAmbientContext && (this.raise(y.DeclareFunctionHasImplementation, e), e.declare) ? super.parseFunctionBodyAndFinish(e, r, i) : (this.tsDisallowOptionalPattern(e), super.parseFunctionBodyAndFinish(e, s, i));
}
registerFunctionStatementId(e) {
!e.body && e.id ? this.checkIdentifier(e.id, 1024) : super.registerFunctionStatementId(e);
}
tsCheckForInvalidTypeCasts(e) {
e.forEach((s) => {
s?.type === "TSTypeCastExpression" && this.raise(y.UnexpectedTypeAnnotation, s.typeAnnotation);
});
}
toReferencedList(e, s) {
return this.tsCheckForInvalidTypeCasts(e), e;
}
parseArrayLike(e, s, i) {
let r = super.parseArrayLike(e, s, i);
return r.type === "ArrayExpression" && this.tsCheckForInvalidTypeCasts(r.elements), r;
}
parseSubscript(e, s, i, r) {
if (!this.hasPrecedingLineBreak() && this.match(35)) {
this.state.canStartJSXElement = !1, this.next();
let o = this.startNodeAt(s);
return o.expression = e, this.finishNode(o, "TSNonNullExpression");
}
let n = !1;
if (this.match(18) && this.lookaheadCharCode() === 60) {
if (i) return r.stop = !0, e;
r.optionalChainMember = n = !0, this.next();
}
if (this.match(47) || this.match(51)) {
let o, h = this.tsTryParseAndCatch(() => {
if (!i && this.atPossibleAsyncArrow(e)) {
let d = this.tsTryParseGenericAsyncArrowFunction(s);
if (d) return r.stop = !0, d;
}
let l = this.tsParseTypeArgumentsInExpression();
if (!l) return;
if (n && !this.match(10)) {
o = this.state.curPosition();
return;
}
if ($e(this.state.type)) {
let d = super.parseTaggedTemplateExpression(e, s, r);
return d.typeArguments = l, d;
}
if (!i && this.eat(10)) {
let d = this.startNodeAt(s);
return d.callee = e, d.arguments = this.parseCallExpressionArguments(), this.tsCheckForInvalidTypeCasts(d.arguments), d.typeArguments = l, r.optionalChainMember && (d.optional = n), this.finishCallExpression(d, r.optionalChainMember);
}
let u = this.state.type;
if (u === 48 || u === 52 || u !== 10 && ce(u) && !this.hasPrecedingLineBreak()) return;
let f = this.startNodeAt(s);
return f.expression = e, f.typeArguments = l, this.finishNode(f, "TSInstantiationExpression");
});
if (o && this.unexpected(o, 10), h) return h.type === "TSInstantiationExpression" && ((this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40) && this.raise(y.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc), !this.match(16) && !this.match(18) && (h.expression = super.stopParseSubscript(e, r))), h;
}
return super.parseSubscript(e, s, i, r);
}
parseNewCallee(e) {
super.parseNewCallee(e);
let { callee: s } = e;
s.type === "TSInstantiationExpression" && !s.extra?.parenthesized && (e.typeArguments = s.typeArguments, e.callee = s.expression);
}
parseExprOp(e, s, i) {
let r;
if (Ae(58) > i && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (r = this.isContextual(120)))) {
let n = this.startNodeAt(s);
return n.expression = e, n.typeAnnotation = this.tsInType(() => (this.next(), this.match(75) ? (r && this.raise(p.UnexpectedKeyword, this.state.startLoc, { keyword: "const" }), this.tsParseTypeReference()) : this.tsParseType())), this.finishNode(n, r ? "TSSatisfiesExpression" : "TSAsExpression"), this.reScan_lt_gt(), this.parseExprOp(n, s, i);
}
return super.parseExprOp(e, s, i);
}
checkReservedWord(e, s, i, r) {
this.state.isAmbientContext || super.checkReservedWord(e, s, i, r);
}
checkImportReflection(e) {
super.checkImportReflection(e), e.module && e.importKind !== "value" && this.raise(y.ImportReflectionHasImportType, e.specifiers[0].loc.start);
}
checkDuplicateExports() {
}
isPotentialImportPhase(e) {
if (super.isPotentialImportPhase(e)) return !0;
if (this.isContextual(130)) {
let s = this.lookaheadCharCode();
return e ? s === 123 || s === 42 : s !== 61;
}
return !e && this.isContextual(87);
}
applyImportPhase(e, s, i, r) {
super.applyImportPhase(e, s, i, r), s ? e.exportKind = i === "type" ? "type" : "value" : e.importKind = i === "type" || i === "typeof" ? i : "value";
}
parseImport(e) {
if (this.match(134)) return e.importKind = "value", super.parseImport(e);
let s;
if (w(this.state.type) && this.lookaheadCharCode() === 61) return e.importKind = "value", this.tsParseImportEqualsDeclaration(e);
if (this.isContextual(130)) {
let i = this.parseMaybeImportPhase(e, !1);
if (this.lookaheadCharCode() === 61) return this.tsParseImportEqualsDeclaration(e, i);
s = super.parseImportSpecifiersAndAfter(e, i);
} else s = super.parseImport(e);
return s.importKind === "type" && s.specifiers.length > 1 && s.specifiers[0].type === "ImportDefaultSpecifier" && this.raise(y.TypeImportCannotSpecifyDefaultAndNamed, s), s;
}
parseExport(e, s) {
if (this.match(83)) {
let i = this.startNode();
this.next();
let r = null;
this.isContextual(130) && this.isPotentialImportPhase(!1) ? r = this.parseMaybeImportPhase(i, !1) : i.importKind = "value";
let n = this.tsParseImportEqualsDeclaration(i, r, !0);
return e.attributes = [], e.declaration = n, e.exportKind = "value", e.source = null, e.specifiers = [], this.finishNode(e, "ExportNamedDeclaration");
} else if (this.eat(29)) {
let i = e;
return i.expression = super.parseExpression(), this.semicolon(), this.sawUnambiguousESM = !0, this.finishNode(i, "TSExportAssignment");
} else if (this.eatContextual(93)) {
let i = e;
return this.expectContextual(128), i.id = this.parseIdentifier(), this.semicolon(), this.finishNode(i, "TSNamespaceExportDeclaration");
} else return super.parseExport(e, s);
}
isAbstractClass() {
return this.isContextual(124) && this.isLookaheadContextual("class");
}
parseExportDefaultExpression() {
if (this.isAbstractClass()) {
let e = this.startNode();
return this.next(), e.abstract = !0, this.parseClass(e, !0, !0);
}
if (this.match(129)) {
let e = this.tsParseInterfaceDeclaration(this.startNode());
if (e) return e;
}
return super.parseExportDefaultExpression();
}
parseVarStatement(e, s, i = !1) {
let { isAmbientContext: r } = this.state, n = super.parseVarStatement(e, s, i || r);
if (!r) return n;
if (!e.declare && (s === "using" || s === "await using")) return this.raiseOverwrite(y.UsingDeclarationInAmbientContext, e, s), n;
for (let { id: o, init: h } of n.declarations) h && (s === "var" || s === "let" || o.typeAnnotation ? this.raise(y.InitializerNotAllowedInAmbientContext, h) : Xi(h, this.hasPlugin("estree")) || this.raise(y.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, h));
return n;
}
parseStatementContent(e, s) {
if (!this.state.containsEsc) switch (this.state.type) {
case 75: {
if (this.isLookaheadContextual("enum")) {
let i = this.startNode();
return this.expect(75), this.tsParseEnumDeclaration(i, { const: !0 });
}
break;
}
case 124:
case 125: {
if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) {
let i = this.state.type, r = this.startNode();
this.next();
let n = i === 125 ? this.tsTryParseDeclare(r) : this.tsParseAbstractDeclaration(r, s);
return n ? (i === 125 && (n.declare = !0), n) : (r.expression = this.createIdentifier(this.startNodeAt(r.loc.start), i === 125 ? "declare" : "abstract"), this.semicolon(!1), this.finishNode(r, "ExpressionStatement"));
}
break;
}
case 126:
return this.tsParseEnumDeclaration(this.startNode());
case 112: {
if (this.lookaheadCharCode() === 123) {
let r = this.startNode();
return this.tsParseAmbientExternalModuleDeclaration(r);
}
break;
}
case 129: {
let i = this.tsParseInterfaceDeclaration(this.startNode());
if (i) return i;
break;
}
case 127: {
if (this.nextTokenIsIdentifierOrStringLiteralOnSameLine()) {
let i = this.startNode();
return this.next(), this.tsParseDeclaration(i, 127, !1, s);
}
break;
}
case 128: {
if (this.nextTokenIsIdentifierOnSameLine()) {
let i = this.startNode();
return this.next(), this.tsParseDeclaration(i, 128, !1, s);
}
break;
}
case 130: {
if (this.nextTokenIsIdentifierOnSameLine()) {
let i = this.startNode();
return this.next(), this.tsParseTypeAliasDeclaration(i);
}
break;
}
}
return super.parseStatementContent(e, s);
}
parseAccessModifier() {
return this.tsParseModifier(["public", "protected", "private"]);
}
tsHasSomeModifiers(e, s) {
return s.some((i) => qt(i) ? e.accessibility === i : !!e[i]);
}
tsIsStartOfStaticBlocks() {
return this.isContextual(106) && this.lookaheadCharCode() === 123;
}
parseClassMember(e, s, i) {
let r = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
this.tsParseModifiers({ allowedModifiers: r, disallowedModifiers: ["in", "out"], stopOnStartOfClassStaticBlock: !0, errorTemplate: y.InvalidModifierOnTypeParameterPositions }, s);
let n = () => {
this.tsIsStartOfStaticBlocks() ? (this.next(), this.next(), this.tsHasSomeModifiers(s, r) && this.raise(y.StaticBlockCannotHaveModifier, this.state.curPosition()), super.parseClassStaticBlock(e, s)) : this.parseClassMemberWithIsStatic(e, s, i, !!s.static);
};
s.declare ? this.tsInAmbientContext(n) : n();
}
parseClassMemberWithIsStatic(e, s, i, r) {
let n = this.tsTryParseIndexSignature(s);
if (n) {
e.body.push(n), s.abstract && this.raise(y.IndexSignatureHasAbstract, s), s.accessibility && this.raise(y.IndexSignatureHasAccessibility, s, { modifier: s.accessibility }), s.declare && this.raise(y.IndexSignatureHasDeclare, s), s.override && this.raise(y.IndexSignatureHasOverride, s);
return;
}
!this.state.inAbstractClass && s.abstract && this.raise(y.NonAbstractClassHasAbstractMethod, s), s.override && (i.hadSuperClass || this.raise(y.OverrideNotInSubClass, s)), super.parseClassMemberWithIsStatic(e, s, i, r);
}
parsePostMemberNameModifiers(e) {
this.eat(17) && (e.optional = !0), e.readonly && this.match(10) && this.raise(y.ClassMethodHasReadonly, e), e.declare && this.match(10) && this.raise(y.ClassMethodHasDeclare, e);
}
shouldParseExportDeclaration() {
return this.tsIsDeclarationStart() ? !0 : super.shouldParseExportDeclaration();
}
parseConditional(e, s, i) {
if (!this.match(17)) return e;
if (this.state.maybeInArrowParameters) {
let r = this.lookaheadCharCode();
if (r === 44 || r === 61 || r === 58 || r === 41) return this.setOptionalParametersError(i), e;
}
return super.parseConditional(e, s, i);
}
parseParenItem(e, s) {
let i = super.parseParenItem(e, s);
if (this.eat(17) && (i.optional = !0, this.resetEndLocation(e)), this.match(14)) {
let r = this.startNodeAt(s);
return r.expression = e, r.typeAnnotation = this.tsParseTypeAnnotation(), this.finishNode(r, "TSTypeCastExpression");
}
return e;
}
parseExportDeclaration(e) {
if (!this.state.isAmbientContext && this.isContextual(125)) return this.tsInAmbientContext(() => this.parseExportDeclaration(e));
let s = this.state.startLoc, i = this.eatContextual(125);
if (i && (this.isContextual(125) || !this.shouldParseExportDeclaration())) throw this.raise(y.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
let n = w(this.state.type) && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(e);
return n ? ((n.type === "TSInterfaceDeclaration" || n.type === "TSTypeAliasDeclaration" || i) && (e.exportKind = "type"), i && n.type !== "TSImportEqualsDeclaration" && (this.resetStartLocation(n, s), n.declare = !0), n) : null;
}
parseClassId(e, s, i, r) {
if ((!s || i) && this.isContextual(113)) return;
super.parseClassId(e, s, i, e.declare ? 1024 : 8331);
let n = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
n && (e.typeParameters = n);
}
parseClassPropertyAnnotation(e) {
e.optional || (this.eat(35) ? e.definite = !0 : this.eat(17) && (e.optional = !0));
let s = this.tsTryParseTypeAnnotation();
s && (e.typeAnnotation = s);
}
parseClassProperty(e) {
if (this.parseClassPropertyAnnotation(e), this.state.isAmbientContext && !(e.readonly && !e.typeAnnotation) && this.match(29) && this.raise(y.DeclareClassFieldHasInitializer, this.state.startLoc), e.abstract && this.match(29)) {
let { key: s } = e;
this.raise(y.AbstractPropertyHasInitializer, this.state.startLoc, { propertyName: s.type === "Identifier" && !e.computed ? s.name : `[${this.input.slice(this.offsetToSourcePos(s.start), this.offsetToSourcePos(s.end))}]` });
}
return super.parseClassProperty(e);
}
parseClassPrivateProperty(e) {
return e.abstract && this.raise(y.PrivateElementHasAbstract, e), e.accessibility && this.raise(y.PrivateElementHasAccessibility, e, { modifier: e.accessibility }), this.parseClassPropertyAnnotation(e), super.parseClassPrivateProperty(e);
}
parseClassAccessorProperty(e) {
return this.parseClassPropertyAnnotation(e), e.optional && this.raise(y.AccessorCannotBeOptional, e), super.parseClassAccessorProperty(e);
}
pushClassMethod(e, s, i, r, n, o) {
let h = this.tsTryParseTypeParameters(this.tsParseConstModifier);
h && n && this.raise(y.ConstructorHasTypeParameters, h);
let { declare: l = !1, kind: u } = s;
l && (u === "get" || u === "set") && this.raise(y.DeclareAccessor, s, { kind: u }), h && (s.typeParameters = h), super.pushClassMethod(e, s, i, r, n, o);
}
pushClassPrivateMethod(e, s, i, r) {
let n = this.tsTryParseTypeParameters(this.tsParseConstModifier);
n && (s.typeParameters = n), super.pushClassPrivateMethod(e, s, i, r);
}
declareClassPrivateMethodInScope(e, s) {
e.type !== "TSDeclareMethod" && (e.type === "MethodDefinition" && e.value.body == null || super.declareClassPrivateMethodInScope(e, s));
}
parseClassSuper(e) {
super.parseClassSuper(e), e.superClass && (this.match(47) || this.match(51)) && (e.superTypeArguments = this.tsParseTypeArgumentsInExpression()), this.eatContextual(113) && (e.implements = this.tsParseHeritageClause("implements"));
}
parseObjPropValue(e, s, i, r, n, o, h) {
let l = this.tsTryParseTypeParameters(this.tsParseConstModifier);
return l && (e.typeParameters = l), super.parseObjPropValue(e, s, i, r, n, o, h);
}
parseFunctionParams(e, s) {
let i = this.tsTryParseTypeParameters(this.tsParseConstModifier);
i && (e.typeParameters = i), super.parseFunctionParams(e, s);
}
parseVarId(e, s) {
super.parseVarId(e, s), e.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35) && (e.definite = !0);
let i = this.tsTryParseTypeAnnotation();
i && (e.id.typeAnnotation = i, this.resetEndLocation(e.id));
}
parseAsyncArrowFromCallExpression(e, s) {
return this.match(14) && (e.returnType = this.tsParseTypeAnnotation()), super.parseAsyncArrowFromCallExpression(e, s);
}
parseMaybeAssign(e, s) {
let i, r, n;
if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
if (i = this.state.clone(), r = this.tryParse(() => super.parseMaybeAssign(e, s), i), !r.error) return r.node;
let { context: l } = this.state, u = l[l.length - 1];
(u === E.j_oTag || u === E.j_expr) && l.pop();
}
if (!r?.error && !this.match(47)) return super.parseMaybeAssign(e, s);
(!i || i === this.state) && (i = this.state.clone());
let o, h = this.tryParse((l) => {
o = this.tsParseTypeParameters(this.tsParseConstModifier);
let u = super.parseMaybeAssign(e, s);
if ((u.type !== "ArrowFunctionExpression" || u.extra?.parenthesized) && l(), o?.params.length !== 0 && this.resetStartLocationFromNode(u, o), u.typeParameters = o, this.hasPlugin("jsx") && u.typeParameters.params.length === 1 && !u.typeParameters.extra?.trailingComma) {
let f = u.typeParameters.params[0];
f.constraint || this.raise(y.SingleTypeParameterWithoutTrailingComma, D(f.loc.end, 1), { typeParameterName: f.name.name });
}
return u;
}, i);
if (!h.error && !h.aborted) return o && this.reportReservedArrowTypeParam(o), h.node;
if (!r && (zt(!this.hasPlugin("jsx")), n = this.tryParse(() => super.parseMaybeAssign(e, s), i), !n.error)) return n.node;
if (r?.node) return this.state = r.failState, r.node;
if (h.node) return this.state = h.failState, o && this.reportReservedArrowTypeParam(o), h.node;
if (n?.node) return this.state = n.failState, n.node;
throw r?.error || h.error || n?.error;
}
reportReservedArrowTypeParam(e) {
e.params.length === 1 && !e.params[0].constraint && !e.extra?.trailingComma && this.getPluginOption("typescript", "disallowAmbiguousJSXLike") && this.raise(y.ReservedArrowTypeParam, e);
}
parseMaybeUnary(e, s) {
return !this.hasPlugin("jsx") && this.match(47) ? this.tsParseTypeAssertion() : super.parseMaybeUnary(e, s);
}
parseArrow(e) {
if (this.match(14)) {
let s = this.tryParse((i) => {
let r = this.tsParseTypeOrTypePredicateAnnotation(14);
return (this.canInsertSemicolon() || !this.match(19)) && i(), r;
});
if (s.aborted) return;
s.thrown || (s.error && (this.state = s.failState), e.returnType = s.node);
}
return super.parseArrow(e);
}
parseFunctionParamType(e) {
this.eat(17) && (e.optional = !0);
let s = this.tsTryParseTypeAnnotation();
return s && (e.typeAnnotation = s), this.resetEndLocation(e), e;
}
isAssignable(e, s) {
switch (e.type) {
case "TSTypeCastExpression":
return this.isAssignable(e.expression, s);
case "TSParameterProperty":
return !0;
default:
return super.isAssignable(e, s);
}
}
toAssignable(e, s = !1) {
switch (e.type) {
case "ParenthesizedExpression":
this.toAssignableParenthesizedExpression(e, s);
break;
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSNonNullExpression":
case "TSTypeAssertion":
s ? this.expressionScope.recordArrowParameterBindingError(y.UnexpectedTypeCastInParameter, e) : this.raise(y.UnexpectedTypeCastInParameter, e), this.toAssignable(e.expression, s);
break;
case "AssignmentExpression":
!s && e.left.type === "TSTypeCastExpression" && (e.left = this.typeCastToParameter(e.left));
default:
super.toAssignable(e, s);
}
}
toAssignableParenthesizedExpression(e, s) {
switch (e.expression.type) {
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSNonNullExpression":
case "TSTypeAssertion":
case "ParenthesizedExpression":
this.toAssignable(e.expression, s);
break;
default:
super.toAssignable(e, s);
}
}
checkToRestConversion(e, s) {
switch (e.type) {
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSNonNullExpression":
this.checkToRestConversion(e.expression, !1);
break;
default:
super.checkToRestConversion(e, s);
}
}
isValidLVal(e, s, i, r) {
switch (e) {
case "TSTypeCastExpression":
return !0;
case "TSParameterProperty":
return "parameter";
case "TSNonNullExpression":
return "expression";
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
return (r !== 64 || !i) && ["expression", !0];
default:
return super.isValidLVal(e, s, i, r);
}
}
parseBindingAtom() {
return this.state.type === 78 ? this.parseIdentifier(!0) : super.parseBindingAtom();
}
parseMaybeDecoratorArguments(e, s) {
if (this.match(47) || this.match(51)) {
let i = this.tsParseTypeArgumentsInExpression();
if (this.match(10)) {
let r = super.parseMaybeDecoratorArguments(e, s);
return r.typeArguments = i, r;
}
this.unexpected(null, 10);
}
return super.parseMaybeDecoratorArguments(e, s);
}
checkCommaAfterRest(e) {
return this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === e ? (this.next(), !1) : super.checkCommaAfterRest(e);
}
isClassMethod() {
return this.match(47) || super.isClassMethod();
}
isClassProperty() {
return this.match(35) || this.match(14) || super.isClassProperty();
}
parseMaybeDefault(e, s) {
let i = super.parseMaybeDefault(e, s);
return i.type === "AssignmentPattern" && i.typeAnnotation && i.right.start < i.typeAnnotation.start && this.raise(y.TypeAnnotationAfterAssign, i.typeAnnotation), i;
}
getTokenFromCode(e) {
if (this.state.inType) {
if (e === 62) {
this.finishOp(48, 1);
return;
}
if (e === 60) {
this.finishOp(47, 1);
return;
}
}
super.getTokenFromCode(e);
}
reScan_lt_gt() {
let { type: e } = this.state;
e === 47 ? (this.state.pos -= 1, this.readToken_lt()) : e === 48 && (this.state.pos -= 1, this.readToken_gt());
}
reScan_lt() {
let { type: e } = this.state;
return e === 51 ? (this.state.pos -= 2, this.finishOp(47, 1), 47) : e;
}
toAssignableListItem(e, s, i) {
let r = e[s];
r.type === "TSTypeCastExpression" && (e[s] = this.typeCastToParameter(r)), super.toAssignableListItem(e, s, i);
}
typeCastToParameter(e) {
return e.expression.typeAnnotation = e.typeAnnotation, this.resetEndLocation(e.expression, e.typeAnnotation.loc.end), e.expression;
}
shouldParseArrow(e) {
return this.match(14) ? e.every((s) => this.isAssignable(s, !0)) : super.shouldParseArrow(e);
}
shouldParseAsyncArrow() {
return this.match(14) || super.shouldParseAsyncArrow();
}
canHaveLeadingDecorator() {
return super.canHaveLeadingDecorator() || this.isAbstractClass();
}
jsxParseOpeningElementAfterName(e) {
if (this.match(47) || this.match(51)) {
let s = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
s && (e.typeArguments = s);
}
return super.jsxParseOpeningElementAfterName(e);
}
getGetterSetterExpectedParamCount(e) {
let s = super.getGetterSetterExpectedParamCount(e), r = this.getObjectOrClassMethodParams(e)[0];
return r && this.isThisParam(r) ? s + 1 : s;
}
parseCatchClauseParam() {
let e = super.parseCatchClauseParam(), s = this.tsTryParseTypeAnnotation();
return s && (e.typeAnnotation = s, this.resetEndLocation(e)), e;
}
tsInAmbientContext(e) {
let { isAmbientContext: s, strict: i } = this.state;
this.state.isAmbientContext = !0, this.state.strict = !1;
try {
return e();
} finally {
this.state.isAmbientContext = s, this.state.strict = i;
}
}
parseClass(e, s, i) {
let r = this.state.inAbstractClass;
this.state.inAbstractClass = !!e.abstract;
try {
return super.parseClass(e, s, i);
} finally {
this.state.inAbstractClass = r;
}
}
tsParseAbstractDeclaration(e, s) {
if (this.match(80)) return e.abstract = !0, this.maybeTakeDecorators(s, this.parseClass(e, !0, !1));
if (this.isContextual(129)) return this.hasFollowingLineBreak() ? null : (e.abstract = !0, this.raise(y.NonClassMethodPropertyHasAbstractModifier, e), this.tsParseInterfaceDeclaration(e));
throw this.unexpected(null, 80);
}
parseMethod(e, s, i, r, n, o, h) {
let l = super.parseMethod(e, s, i, r, n, o, h);
if ((l.abstract || l.type === "TSAbstractMethodDefinition") && (this.hasPlugin("estree") ? l.value : l).body) {
let { key: d } = l;
this.raise(y.AbstractMethodHasImplementation, l, { methodName: d.type === "Identifier" && !l.computed ? d.name : `[${this.input.slice(this.offsetToSourcePos(d.start), this.offsetToSourcePos(d.end))}]` });
}
return l;
}
tsParseTypeParameterName() {
return this.parseIdentifier();
}
shouldParseAsAmbientContext() {
return !!this.getPluginOption("typescript", "dts");
}
parse() {
return this.shouldParseAsAmbientContext() && (this.state.isAmbientContext = !0), super.parse();
}
getExpression() {
return this.shouldParseAsAmbientContext() && (this.state.isAmbientContext = !0), super.getExpression();
}
parseExportSpecifier(e, s, i, r) {
return !s && r ? (this.parseTypeOnlyImportExportSpecifier(e, !1, i), this.finishNode(e, "ExportSpecifier")) : (e.exportKind = "value", super.parseExportSpecifier(e, s, i, r));
}
parseImportSpecifier(e, s, i, r, n) {
return !s && r ? (this.parseTypeOnlyImportExportSpecifier(e, !0, i), this.finishNode(e, "ImportSpecifier")) : (e.importKind = "value", super.parseImportSpecifier(e, s, i, r, i ? 4098 : 4096));
}
parseTypeOnlyImportExportSpecifier(e, s, i) {
let r = s ? "imported" : "local", n = s ? "local" : "exported", o = e[r], h, l = !1, u = !0, f = o.loc.start;
if (this.isContextual(93)) {
let x = this.parseIdentifier();
if (this.isContextual(93)) {
let A = this.parseIdentifier();
O(this.state.type) ? (l = !0, o = x, h = s ? this.parseIdentifier() : this.parseModuleExportName(), u = !1) : (h = A, u = !1);
} else O(this.state.type) ? (u = !1, h = s ? this.parseIdentifier() : this.parseModuleExportName()) : (l = !0, o = x);
} else O(this.state.type) && (l = !0, s ? (o = this.parseIdentifier(!0), this.isContextual(93) || this.checkReservedWord(o.name, o.loc.start, !0, !0)) : o = this.parseModuleExportName());
l && i && this.raise(s ? y.TypeModifierIsUsedInTypeImports : y.TypeModifierIsUsedInTypeExports, f), e[r] = o, e[n] = h;
let d = s ? "importKind" : "exportKind";
e[d] = l ? "type" : "value", u && this.eatContextual(93) && (e[n] = s ? this.parseIdentifier() : this.parseModuleExportName()), e[n] || (e[n] = this.cloneIdentifier(e[r])), s && this.checkIdentifier(e[n], l ? 4098 : 4096);
}
fillOptionalPropertiesForTSESLint(e) {
switch (e.type) {
case "ExpressionStatement":
e.directive ?? (e.directive = void 0);
return;
case "RestElement":
e.value = void 0;
case "Identifier":
case "ArrayPattern":
case "AssignmentPattern":
case "ObjectPattern":
e.decorators ?? (e.decorators = []), e.optional ?? (e.optional = !1), e.typeAnnotation ?? (e.typeAnnotation = void 0);
return;
case "TSParameterProperty":
e.accessibility ?? (e.accessibility = void 0), e.decorators ?? (e.decorators = []), e.override ?? (e.override = !1), e.readonly ?? (e.readonly = !1), e.static ?? (e.static = !1);
return;
case "TSEmptyBodyFunctionExpression":
e.body = null;
case "TSDeclareFunction":
case "FunctionDeclaration":
case "FunctionExpression":
case "ClassMethod":
case "ClassPrivateMethod":
e.declare ?? (e.declare = !1), e.returnType ?? (e.returnType = void 0), e.typeParameters ?? (e.typeParameters = void 0);
return;
case "Property":
e.optional ?? (e.optional = !1);
return;
case "TSMethodSignature":
case "TSPropertySignature":
e.optional ?? (e.optional = !1);
case "TSIndexSignature":
e.accessibility ?? (e.accessibility = void 0), e.readonly ?? (e.readonly = !1), e.static ?? (e.static = !1);
return;
case "TSAbstractPropertyDefinition":
case "PropertyDefinition":
case "TSAbstractAccessorProperty":
case "AccessorProperty":
e.declare ?? (e.declare = !1), e.definite ?? (e.definite = !1), e.readonly ?? (e.readonly = !1), e.typeAnnotation ?? (e.typeAnnotation = void 0);
case "TSAbstractMethodDefinition":
case "MethodDefinition":
e.accessibility ?? (e.accessibility = void 0), e.decorators ?? (e.decorators = []), e.override ?? (e.override = !1), e.optional ?? (e.optional = !1);
return;
case "ClassExpression":
e.id ?? (e.id = null);
case "ClassDeclaration":
e.abstract ?? (e.abstract = !1), e.declare ?? (e.declare = !1), e.decorators ?? (e.decorators = []), e.implements ?? (e.implements = []), e.superTypeArguments ?? (e.superTypeArguments = void 0), e.typeParameters ?? (e.typeParameters = void 0);
return;
case "TSTypeAliasDeclaration":
case "VariableDeclaration":
e.declare ?? (e.declare = !1);
return;
case "VariableDeclarator":
e.definite ?? (e.definite = !1);
return;
case "TSEnumDeclaration":
e.const ?? (e.const = !1), e.declare ?? (e.declare = !1);
return;
case "TSEnumMember":
e.computed ?? (e.computed = !1);
return;
case "TSImportType":
e.qualifier ?? (e.qualifier = null), e.options ?? (e.options = null), e.typeArguments ?? (e.typeArguments = null);
return;
case "TSInterfaceDeclaration":
e.declare ?? (e.declare = !1), e.extends ?? (e.extends = []);
return;
case "TSMappedType":
e.optional ?? (e.optional = !1), e.readonly ?? (e.readonly = void 0);
return;
case "TSModuleDeclaration":
e.declare ?? (e.declare = !1), e.global ?? (e.global = e.kind === "global");
return;
case "TSTypeParameter":
e.const ?? (e.const = !1), e.in ?? (e.in = !1), e.out ?? (e.out = !1);
return;
}
}
chStartsBindingIdentifierAndNotRelationalOperator(e, s) {
if (B(e)) {
if (Ve.lastIndex = s, Ve.test(this.input)) {
let i = this.codePointAtPos(Ve.lastIndex);
if (!K(i) && i !== 92) return !1;
}
return !0;
} else return e === 92;
}
nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine() {
let e = this.nextTokenInLineStart(), s = this.codePointAtPos(e);
return this.chStartsBindingIdentifierAndNotRelationalOperator(s, e);
}
nextTokenIsIdentifierOrStringLiteralOnSameLine() {
let e = this.nextTokenInLineStart(), s = this.codePointAtPos(e);
return this.chStartsBindingIdentifier(s, e) || s === 34 || s === 39;
}
};
$t = F`placeholders`({ ClassNameIsRequired: "A class name is required.", UnexpectedSpace: "Unexpected space in placeholder." }), Qi = (a2) => class extends a2 {
parsePlaceholder(e) {
if (this.match(133)) {
let s = this.startNode();
return this.next(), this.assertNoSpace(), s.name = super.parseIdentifier(!0), this.assertNoSpace(), this.expect(133), this.finishPlaceholder(s, e);
}
}
finishPlaceholder(e, s) {
let i = e;
return (!i.expectedNode || !i.type) && (i = this.finishNode(i, "Placeholder")), i.expectedNode = s, i;
}
getTokenFromCode(e) {
e === 37 && this.input.charCodeAt(this.state.pos + 1) === 37 ? this.finishOp(133, 2) : super.getTokenFromCode(e);
}
parseExprAtom(e) {
return this.parsePlaceholder("Expression") || super.parseExprAtom(e);
}
parseIdentifier(e) {
return this.parsePlaceholder("Identifier") || super.parseIdentifier(e);
}
checkReservedWord(e, s, i, r) {
e !== void 0 && super.checkReservedWord(e, s, i, r);
}
cloneIdentifier(e) {
let s = super.cloneIdentifier(e);
return s.type === "Placeholder" && (s.expectedNode = e.expectedNode), s;
}
cloneStringLiteral(e) {
return e.type === "Placeholder" ? this.cloneIdentifier(e) : super.cloneStringLiteral(e);
}
parseBindingAtom() {
return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
}
isValidLVal(e, s, i, r) {
return e === "Placeholder" || super.isValidLVal(e, s, i, r);
}
toAssignable(e, s) {
e && e.type === "Placeholder" && e.expectedNode === "Expression" ? e.expectedNode = "Pattern" : super.toAssignable(e, s);
}
chStartsBindingIdentifier(e, s) {
if (super.chStartsBindingIdentifier(e, s)) return !0;
let i = this.nextTokenStart();
return this.input.charCodeAt(i) === 37 && this.input.charCodeAt(i + 1) === 37;
}
verifyBreakContinue(e, s) {
e.label && e.label.type === "Placeholder" || super.verifyBreakContinue(e, s);
}
parseExpressionStatement(e, s) {
if (s.type !== "Placeholder" || s.extra?.parenthesized) return super.parseExpressionStatement(e, s);
if (this.match(14)) {
let r = e;
return r.label = this.finishPlaceholder(s, "Identifier"), this.next(), r.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration(), this.finishNode(r, "LabeledStatement");
}
this.semicolon();
let i = e;
return i.name = s.name, this.finishPlaceholder(i, "Statement");
}
parseBlock(e, s, i) {
return this.parsePlaceholder("BlockStatement") || super.parseBlock(e, s, i);
}
parseFunctionId(e) {
return this.parsePlaceholder("Identifier") || super.parseFunctionId(e);
}
parseClass(e, s, i) {
let r = s ? "ClassDeclaration" : "ClassExpression";
this.next();
let n = this.state.strict, o = this.parsePlaceholder("Identifier");
if (o) if (this.match(81) || this.match(133) || this.match(5)) e.id = o;
else {
if (i || !s) return e.id = null, e.body = this.finishPlaceholder(o, "ClassBody"), this.finishNode(e, r);
throw this.raise($t.ClassNameIsRequired, this.state.startLoc);
}
else this.parseClassId(e, s, i);
return super.parseClassSuper(e), e.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!e.superClass, n), this.finishNode(e, r);
}
parseExport(e, s) {
let i = this.parsePlaceholder("Identifier");
if (!i) return super.parseExport(e, s);
let r = e;
if (!this.isContextual(98) && !this.match(12)) return r.specifiers = [], r.source = null, r.declaration = this.finishPlaceholder(i, "Declaration"), this.finishNode(r, "ExportNamedDeclaration");
this.expectPlugin("exportDefaultFrom");
let n = this.startNode();
return n.exported = i, r.specifiers = [this.finishNode(n, "ExportDefaultSpecifier")], super.parseExport(r, s);
}
isExportDefaultSpecifier() {
if (this.match(65)) {
let e = this.nextTokenStart();
if (this.isUnparsedContextual(e, "from") && this.input.startsWith(z(133), this.nextTokenStartSince(e + 4))) return !0;
}
return super.isExportDefaultSpecifier();
}
maybeParseExportDefaultSpecifier(e, s) {
return e.specifiers?.length ? !0 : super.maybeParseExportDefaultSpecifier(e, s);
}
checkExport(e) {
let { specifiers: s } = e;
s?.length && (e.specifiers = s.filter((i) => i.exported.type === "Placeholder")), super.checkExport(e), e.specifiers = s;
}
parseImport(e) {
let s = this.parsePlaceholder("Identifier");
if (!s) return super.parseImport(e);
if (e.specifiers = [], !this.isContextual(98) && !this.match(12)) return e.source = this.finishPlaceholder(s, "StringLiteral"), this.semicolon(), this.finishNode(e, "ImportDeclaration");
let i = this.startNodeAtNode(s);
return i.local = s, e.specifiers.push(this.finishNode(i, "ImportDefaultSpecifier")), this.eat(12) && (this.maybeParseStarImportSpecifier(e) || this.parseNamedImportSpecifiers(e)), this.expectContextual(98), e.source = this.parseImportSource(), this.semicolon(), this.finishNode(e, "ImportDeclaration");
}
parseImportSource() {
return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
}
assertNoSpace() {
this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index) && this.raise($t.UnexpectedSpace, this.state.lastTokEndLoc);
}
}, Zi = (a2) => class extends a2 {
parseV8Intrinsic() {
if (this.match(54)) {
let e = this.state.startLoc, s = this.startNode();
if (this.next(), w(this.state.type)) {
let i = this.parseIdentifierName(), r = this.createIdentifier(s, i);
if (this.castNodeTo(r, "V8IntrinsicIdentifier"), this.match(10)) return r;
}
this.unexpected(e);
}
}
parseExprAtom(e) {
return this.parseV8Intrinsic() || super.parseExprAtom(e);
}
}, Kt = ["fsharp", "hack"], Ht = ["^^", "@@", "^", "%", "#"];
hs = { estree: ai, jsx: Bi, flow: Mi, typescript: Ji, v8intrinsic: Zi, placeholders: Qi }, tr = Object.keys(hs), pt = class extends ct {
checkProto(t, e, s, i) {
if (t.type === "SpreadElement" || this.isObjectMethod(t) || t.computed || t.shorthand) return s;
let r = t.key;
return (r.type === "Identifier" ? r.name : r.value) === "__proto__" ? e ? (this.raise(p.RecordNoProto, r), !0) : (s && (i ? i.doubleProtoLoc === null && (i.doubleProtoLoc = r.loc.start) : this.raise(p.DuplicateProto, r)), !0) : s;
}
shouldExitDescending(t, e) {
return t.type === "ArrowFunctionExpression" && this.offsetToSourcePos(t.start) === e;
}
getExpression() {
if (this.enterInitialScopes(), this.nextToken(), this.match(140)) throw this.raise(p.ParseExpressionEmptyInput, this.state.startLoc);
let t = this.parseExpression();
if (!this.match(140)) throw this.raise(p.ParseExpressionExpectsEOF, this.state.startLoc, { unexpected: this.input.codePointAt(this.state.start) });
return this.finalizeRemainingComments(), t.comments = this.comments, t.errors = this.state.errors, this.optionFlags & 256 && (t.tokens = this.tokens), t;
}
parseExpression(t, e) {
return t ? this.disallowInAnd(() => this.parseExpressionBase(e)) : this.allowInAnd(() => this.parseExpressionBase(e));
}
parseExpressionBase(t) {
let e = this.state.startLoc, s = this.parseMaybeAssign(t);
if (this.match(12)) {
let i = this.startNodeAt(e);
for (i.expressions = [s]; this.eat(12); ) i.expressions.push(this.parseMaybeAssign(t));
return this.toReferencedList(i.expressions), this.finishNode(i, "SequenceExpression");
}
return s;
}
parseMaybeAssignDisallowIn(t, e) {
return this.disallowInAnd(() => this.parseMaybeAssign(t, e));
}
parseMaybeAssignAllowIn(t, e) {
return this.allowInAnd(() => this.parseMaybeAssign(t, e));
}
setOptionalParametersError(t) {
t.optionalParametersLoc = this.state.startLoc;
}
parseMaybeAssign(t, e) {
let s = this.state.startLoc, i = this.isContextual(108);
if (i && this.prodParam.hasYield) {
this.next();
let h = this.parseYield(s);
return e && (h = e.call(this, h, s)), h;
}
let r;
t ? r = !1 : (t = new Y(), r = !0);
let { type: n } = this.state;
(n === 10 || w(n)) && (this.state.potentialArrowAt = this.state.start);
let o = this.parseMaybeConditional(t);
if (e && (o = e.call(this, o, s)), li(this.state.type)) {
let h = this.startNodeAt(s), l = this.state.value;
if (h.operator = l, this.match(29)) {
this.toAssignable(o, !0), h.left = o;
let u = s.index;
t.doubleProtoLoc != null && t.doubleProtoLoc.index >= u && (t.doubleProtoLoc = null), t.shorthandAssignLoc != null && t.shorthandAssignLoc.index >= u && (t.shorthandAssignLoc = null), t.privateKeyLoc != null && t.privateKeyLoc.index >= u && (this.checkDestructuringPrivate(t), t.privateKeyLoc = null), t.voidPatternLoc != null && t.voidPatternLoc.index >= u && (t.voidPatternLoc = null);
} else h.left = o;
return this.next(), h.right = this.parseMaybeAssign(), this.checkLVal(o, this.finishNode(h, "AssignmentExpression"), void 0, void 0, void 0, void 0, l === "||=" || l === "&&=" || l === "??="), h;
} else r && this.checkExpressionErrors(t, !0);
if (i) {
let { type: h } = this.state;
if ((this.hasPlugin("v8intrinsic") ? ce(h) : ce(h) && !this.match(54)) && !this.isAmbiguousPrefixOrIdentifier()) return this.raiseOverwrite(p.YieldNotInGeneratorFunction, s), this.parseYield(s);
}
return o;
}
parseMaybeConditional(t) {
let e = this.state.startLoc, s = this.state.potentialArrowAt, i = this.parseExprOps(t);
return this.shouldExitDescending(i, s) ? i : this.parseConditional(i, e, t);
}
parseConditional(t, e, s) {
if (this.eat(17)) {
let i = this.startNodeAt(e);
return i.test = t, i.consequent = this.parseMaybeAssignAllowIn(), this.expect(14), i.alternate = this.parseMaybeAssign(), this.finishNode(i, "ConditionalExpression");
}
return t;
}
parseMaybeUnaryOrPrivate(t) {
return this.match(139) ? this.parsePrivateName() : this.parseMaybeUnary(t);
}
parseExprOps(t) {
let e = this.state.startLoc, s = this.state.potentialArrowAt, i = this.parseMaybeUnaryOrPrivate(t);
return this.shouldExitDescending(i, s) ? i : this.parseExprOp(i, e, -1);
}
parseExprOp(t, e, s) {
if (this.isPrivateName(t)) {
let r = this.getPrivateNameSV(t);
(s >= Ae(58) || !this.prodParam.hasIn || !this.match(58)) && this.raise(p.PrivateInExpectedIn, t, { identifierName: r }), this.classScope.usePrivateName(r, t.loc.start);
}
let i = this.state.type;
if (ui(i) && (this.prodParam.hasIn || !this.match(58))) {
let r = Ae(i);
if (r > s) {
if (i === 39) {
if (this.expectPlugin("pipelineOperator"), this.state.inFSharpPipelineDirectBody) return t;
this.checkPipelineAtInfixOperator(t, e);
}
let n = this.startNodeAt(e);
n.left = t, n.operator = this.state.value;
let o = i === 41 || i === 42, h = i === 40;
h && (r = Ae(42)), this.next(), n.right = this.parseExprOpRightExpr(i, r);
let l = this.finishNode(n, o || h ? "LogicalExpression" : "BinaryExpression"), u = this.state.type;
if (h && (u === 41 || u === 42) || o && u === 40) throw this.raise(p.MixingCoalesceWithLogical, this.state.startLoc);
return this.parseExprOp(l, e, s);
}
}
return t;
}
parseExprOpRightExpr(t, e) {
switch (this.state.startLoc, t) {
case 39:
switch (this.getPluginOption("pipelineOperator", "proposal")) {
case "hack":
return this.withTopicBindingContext(() => this.parseHackPipeBody());
case "fsharp":
return this.withSoloAwaitPermittingContext(() => this.parseFSharpPipelineBody(e));
}
default:
return this.parseExprOpBaseRightExpr(t, e);
}
}
parseExprOpBaseRightExpr(t, e) {
let s = this.state.startLoc;
return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), s, xi(t) ? e - 1 : e);
}
parseHackPipeBody() {
let { startLoc: t } = this.state, e = this.parseMaybeAssign();
return Qs.has(e.type) && !e.extra?.parenthesized && this.raise(p.PipeUnparenthesizedBody, t, { type: e.type }), this.topicReferenceWasUsedInCurrentContext() || this.raise(p.PipeTopicUnused, t), e;
}
checkExponentialAfterUnary(t) {
this.match(57) && this.raise(p.UnexpectedTokenUnaryExponentiation, t.argument);
}
parseMaybeUnary(t, e) {
let s = this.state.startLoc, i = this.isContextual(96);
if (i && this.recordAwaitIfAllowed()) {
this.next();
let h = this.parseAwait(s);
return e || this.checkExponentialAfterUnary(h), h;
}
let r = this.match(34), n = this.startNode();
if (di(this.state.type)) {
n.operator = this.state.value, n.prefix = !0, this.match(72) && this.expectPlugin("throwExpressions");
let h = this.match(89);
if (this.next(), n.argument = this.parseMaybeUnary(null, !0), this.checkExpressionErrors(t, !0), this.state.strict && h) {
let l = n.argument;
l.type === "Identifier" ? this.raise(p.StrictDelete, n) : this.hasPropertyAsPrivateName(l) && this.raise(p.DeletePrivateField, n);
}
if (!r) return e || this.checkExponentialAfterUnary(n), this.finishNode(n, "UnaryExpression");
}
let o = this.parseUpdate(n, r, t);
if (i) {
let { type: h } = this.state;
if ((this.hasPlugin("v8intrinsic") ? ce(h) : ce(h) && !this.match(54)) && !this.isAmbiguousPrefixOrIdentifier()) return this.raiseOverwrite(p.AwaitNotInAsyncContext, s), this.parseAwait(s);
}
return o;
}
parseUpdate(t, e, s) {
if (e) {
let n = t;
return this.checkLVal(n.argument, this.finishNode(n, "UpdateExpression")), t;
}
let i = this.state.startLoc, r = this.parseExprSubscripts(s);
if (this.checkExpressionErrors(s, !1)) return r;
for (; fi(this.state.type) && !this.canInsertSemicolon(); ) {
let n = this.startNodeAt(i);
n.operator = this.state.value, n.prefix = !1, n.argument = r, this.next(), this.checkLVal(r, r = this.finishNode(n, "UpdateExpression"));
}
return r;
}
parseExprSubscripts(t) {
let e = this.state.startLoc, s = this.state.potentialArrowAt, i = this.parseExprAtom(t);
return this.shouldExitDescending(i, s) ? i : this.parseSubscripts(i, e);
}
parseSubscripts(t, e, s) {
let i = { optionalChainMember: !1, maybeAsyncArrow: this.atPossibleAsyncArrow(t), stop: !1 };
do
t = this.parseSubscript(t, e, s, i), i.maybeAsyncArrow = !1;
while (!i.stop);
return t;
}
parseSubscript(t, e, s, i) {
let { type: r } = this.state;
if (!s && r === 15) return this.parseBind(t, e, s, i);
if ($e(r)) return this.parseTaggedTemplateExpression(t, e, i);
let n = !1;
if (r === 18) {
if (s && (this.raise(p.OptionalChainingNoNew, this.state.startLoc), this.lookaheadCharCode() === 40)) return this.stopParseSubscript(t, i);
i.optionalChainMember = n = !0, this.next();
}
if (!s && this.match(10)) return this.parseCoverCallAndAsyncArrowHead(t, e, i, n);
{
let o = this.eat(0);
return o || n || this.eat(16) ? this.parseMember(t, e, i, o, n) : this.stopParseSubscript(t, i);
}
}
stopParseSubscript(t, e) {
return e.stop = !0, t;
}
parseMember(t, e, s, i, r) {
let n = this.startNodeAt(e);
return n.object = t, n.computed = i, i ? (n.property = this.parseExpression(), this.expect(3)) : this.match(139) ? (t.type === "Super" && this.raise(p.SuperPrivateField, e), this.classScope.usePrivateName(this.state.value, this.state.startLoc), n.property = this.parsePrivateName()) : n.property = this.parseIdentifier(!0), s.optionalChainMember ? (n.optional = r, this.finishNode(n, "OptionalMemberExpression")) : this.finishNode(n, "MemberExpression");
}
parseBind(t, e, s, i) {
let r = this.startNodeAt(e);
return r.object = t, this.next(), r.callee = this.parseNoCallExpr(), i.stop = !0, this.parseSubscripts(this.finishNode(r, "BindExpression"), e, s);
}
parseCoverCallAndAsyncArrowHead(t, e, s, i) {
let r = this.state.maybeInArrowParameters, n = null;
this.state.maybeInArrowParameters = !0, this.next();
let o = this.startNodeAt(e);
o.callee = t;
let { maybeAsyncArrow: h, optionalChainMember: l } = s;
h && (this.expressionScope.enter($i()), n = new Y()), l && (o.optional = i), i ? o.arguments = this.parseCallExpressionArguments() : o.arguments = this.parseCallExpressionArguments(t.type !== "Super", o, n);
let u = this.finishCallExpression(o, l);
return h && this.shouldParseAsyncArrow() && !i ? (s.stop = !0, this.checkDestructuringPrivate(n), this.expressionScope.validateAsPattern(), this.expressionScope.exit(), u = this.parseAsyncArrowFromCallExpression(this.startNodeAt(e), u)) : (h && (this.checkExpressionErrors(n, !0), this.expressionScope.exit()), this.toReferencedArguments(u)), this.state.maybeInArrowParameters = r, u;
}
toReferencedArguments(t, e) {
this.toReferencedListDeep(t.arguments, e);
}
parseTaggedTemplateExpression(t, e, s) {
let i = this.startNodeAt(e);
return i.tag = t, i.quasi = this.parseTemplate(!0), s.optionalChainMember && this.raise(p.OptionalChainingNoTemplate, e), this.finishNode(i, "TaggedTemplateExpression");
}
atPossibleAsyncArrow(t) {
return t.type === "Identifier" && t.name === "async" && this.state.lastTokEndLoc.index === t.end && !this.canInsertSemicolon() && t.end - t.start === 5 && this.offsetToSourcePos(t.start) === this.state.potentialArrowAt;
}
finishCallExpression(t, e) {
if (t.callee.type === "Import") if (t.arguments.length === 0 || t.arguments.length > 2) this.raise(p.ImportCallArity, t);
else for (let s of t.arguments) s.type === "SpreadElement" && this.raise(p.ImportCallSpreadArgument, s);
return this.finishNode(t, e ? "OptionalCallExpression" : "CallExpression");
}
parseCallExpressionArguments(t, e, s) {
let i = [], r = !0, n = this.state.inFSharpPipelineDirectBody;
for (this.state.inFSharpPipelineDirectBody = !1; !this.eat(11); ) {
if (r) r = !1;
else if (this.expect(12), this.match(11)) {
e && this.addTrailingCommaExtraToNode(e), this.next();
break;
}
i.push(this.parseExprListItem(11, !1, s, t));
}
return this.state.inFSharpPipelineDirectBody = n, i;
}
shouldParseAsyncArrow() {
return this.match(19) && !this.canInsertSemicolon();
}
parseAsyncArrowFromCallExpression(t, e) {
return this.resetPreviousNodeTrailingComments(e), this.expect(19), this.parseArrowExpression(t, e.arguments, !0, e.extra?.trailingCommaLoc), e.innerComments && X(t, e.innerComments), e.callee.trailingComments && X(t, e.callee.trailingComments), t;
}
parseNoCallExpr() {
let t = this.state.startLoc;
return this.parseSubscripts(this.parseExprAtom(), t, !0);
}
parseExprAtom(t) {
let e, s = null, { type: i } = this.state;
switch (i) {
case 79:
return this.parseSuper();
case 83:
return e = this.startNode(), this.next(), this.match(16) ? this.parseImportMetaPropertyOrPhaseCall(e) : this.match(10) ? this.optionFlags & 512 ? this.parseImportCall(e) : this.finishNode(e, "Import") : (this.raise(p.UnsupportedImport, this.state.lastTokStartLoc), this.finishNode(e, "Import"));
case 78:
return e = this.startNode(), this.next(), this.finishNode(e, "ThisExpression");
case 90:
return this.parseDo(this.startNode(), !1);
case 56:
case 31:
return this.readRegexp(), 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(!0);
case 86:
return this.parseBooleanLiteral(!1);
case 10: {
let r = this.state.potentialArrowAt === this.state.start;
return this.parseParenAndDistinguishExpression(r);
}
case 0:
return this.parseArrayLike(3, !1, t);
case 5:
return this.parseObjectLike(8, !1, !1, t);
case 68:
return this.parseFunctionOrFunctionSent();
case 26:
s = this.parseDecorators();
case 80:
return this.parseClass(this.maybeTakeDecorators(s, this.startNode()), !1);
case 77:
return this.parseNewOrNewTarget();
case 25:
case 24:
return this.parseTemplate(!1);
case 15: {
e = this.startNode(), this.next(), e.object = null;
let r = e.callee = this.parseNoCallExpr();
if (r.type === "MemberExpression") return this.finishNode(e, "BindExpression");
throw this.raise(p.UnsupportedBind, r);
}
case 139:
return this.raise(p.PrivateInExpectedIn, this.state.startLoc, { identifierName: this.state.value }), 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: {
let r = this.getPluginOption("pipelineOperator", "proposal");
if (r) return this.parseTopicReference(r);
throw this.unexpected();
}
case 47: {
let r = this.input.codePointAt(this.nextTokenStart());
throw B(r) || r === 62 ? this.expectOnePlugin(["jsx", "flow", "typescript"]) : this.unexpected();
}
default:
if (w(i)) {
if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) return this.parseModuleExpression();
let r = this.state.potentialArrowAt === this.state.start, n = this.state.containsEsc, o = this.parseIdentifier();
if (!n && o.name === "async" && !this.canInsertSemicolon()) {
let { type: h } = this.state;
if (h === 68) return this.resetPreviousNodeTrailingComments(o), this.next(), this.parseAsyncFunctionExpression(this.startNodeAtNode(o));
if (w(h)) return this.lookaheadCharCode() === 61 ? this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(o)) : o;
if (h === 90) return this.resetPreviousNodeTrailingComments(o), this.parseDo(this.startNodeAtNode(o), !0);
}
return r && this.match(19) && !this.canInsertSemicolon() ? (this.next(), this.parseArrowExpression(this.startNodeAtNode(o), [o], !1)) : o;
} else throw this.unexpected();
}
}
parseTopicReferenceThenEqualsSign(t, e) {
let s = this.getPluginOption("pipelineOperator", "proposal");
if (s) return this.state.type = t, this.state.value = e, this.state.pos--, this.state.end--, this.state.endLoc = D(this.state.endLoc, -1), this.parseTopicReference(s);
throw this.unexpected();
}
parseTopicReference(t) {
let e = this.startNode(), s = this.state.startLoc, i = this.state.type;
return this.next(), this.finishTopicReference(e, s, t, i);
}
finishTopicReference(t, e, s, i) {
if (this.testTopicReferenceConfiguration(s, e, i)) return this.topicReferenceIsAllowedInCurrentContext() || this.raise(p.PipeTopicUnbound, e), this.registerTopicReference(), this.finishNode(t, "TopicReference");
throw this.raise(p.PipeTopicUnconfiguredToken, e, { token: z(i) });
}
testTopicReferenceConfiguration(t, e, s) {
switch (t) {
case "hack":
return this.hasPlugin(["pipelineOperator", { topicToken: z(s) }]);
case "smart":
return s === 27;
default:
throw this.raise(p.PipeTopicRequiresHackPipes, e);
}
}
parseAsyncArrowUnaryFunction(t) {
this.prodParam.enter(Se(!0, this.prodParam.hasYield));
let e = [this.parseIdentifier()];
return this.prodParam.exit(), this.hasPrecedingLineBreak() && this.raise(p.LineTerminatorBeforeArrow, this.state.curPosition()), this.expect(19), this.parseArrowExpression(t, e, !0);
}
parseDo(t, e) {
this.expectPlugin("doExpressions"), e && this.expectPlugin("asyncDoExpressions"), t.async = e, this.next();
let s = this.state.labels;
return this.state.labels = [], e ? (this.prodParam.enter(2), t.body = this.parseBlock(), this.prodParam.exit()) : t.body = this.parseBlock(), this.state.labels = s, this.finishNode(t, "DoExpression");
}
parseSuper() {
let t = this.startNode();
return this.next(), this.match(10) && !this.scope.allowDirectSuper ? this.raise(p.SuperNotAllowed, t) : this.scope.allowSuper || this.raise(p.UnexpectedSuper, t), !this.match(10) && !this.match(0) && !this.match(16) && this.raise(p.UnsupportedSuper, t), this.finishNode(t, "Super");
}
parsePrivateName() {
let t = this.startNode(), e = this.startNodeAt(D(this.state.startLoc, 1)), s = this.state.value;
return this.next(), t.id = this.createIdentifier(e, s), this.finishNode(t, "PrivateName");
}
parseFunctionOrFunctionSent() {
let t = this.startNode();
if (this.next(), this.prodParam.hasYield && this.match(16)) {
let e = this.createIdentifier(this.startNodeAtNode(t), "function");
return this.next(), this.match(103) ? this.expectPlugin("functionSent") : this.hasPlugin("functionSent") || this.unexpected(), this.parseMetaProperty(t, e, "sent");
}
return this.parseFunction(t);
}
parseMetaProperty(t, e, s) {
t.meta = e;
let i = this.state.containsEsc;
return t.property = this.parseIdentifier(!0), (t.property.name !== s || i) && this.raise(p.UnsupportedMetaProperty, t.property, { target: e.name, onlyValidPropertyName: s }), this.finishNode(t, "MetaProperty");
}
parseImportMetaPropertyOrPhaseCall(t) {
if (this.next(), this.isContextual(105) || this.isContextual(97)) {
let e = this.isContextual(105);
return this.expectPlugin(e ? "sourcePhaseImports" : "deferredImportEvaluation"), this.next(), t.phase = e ? "source" : "defer", this.parseImportCall(t);
} else {
let e = this.createIdentifierAt(this.startNodeAtNode(t), "import", this.state.lastTokStartLoc);
return this.isContextual(101) && (this.inModule || this.raise(p.ImportMetaOutsideModule, e), this.sawUnambiguousESM = !0), this.parseMetaProperty(t, e, "meta");
}
}
parseLiteralAtNode(t, e, s) {
return this.addExtra(s, "rawValue", t), this.addExtra(s, "raw", this.input.slice(this.offsetToSourcePos(s.start), this.state.end)), s.value = t, this.next(), this.finishNode(s, e);
}
parseLiteral(t, e) {
let s = this.startNode();
return this.parseLiteralAtNode(t, e, s);
}
parseStringLiteral(t) {
return this.parseLiteral(t, "StringLiteral");
}
parseNumericLiteral(t) {
return this.parseLiteral(t, "NumericLiteral");
}
parseBigIntLiteral(t) {
{
let e;
try {
e = BigInt(t);
} catch {
e = null;
}
return this.parseLiteral(e, "BigIntLiteral");
}
}
parseDecimalLiteral(t) {
return this.parseLiteral(t, "DecimalLiteral");
}
parseRegExpLiteral(t) {
let e = this.startNode();
return this.addExtra(e, "raw", this.input.slice(this.offsetToSourcePos(e.start), this.state.end)), e.pattern = t.pattern, e.flags = t.flags, this.next(), this.finishNode(e, "RegExpLiteral");
}
parseBooleanLiteral(t) {
let e = this.startNode();
return e.value = t, this.next(), this.finishNode(e, "BooleanLiteral");
}
parseNullLiteral() {
let t = this.startNode();
return this.next(), this.finishNode(t, "NullLiteral");
}
parseParenAndDistinguishExpression(t) {
let e = this.state.startLoc, s;
this.next(), this.expressionScope.enter(qi());
let i = this.state.maybeInArrowParameters, r = this.state.inFSharpPipelineDirectBody;
this.state.maybeInArrowParameters = !0, this.state.inFSharpPipelineDirectBody = !1;
let n = this.state.startLoc, o = [], h = new Y(), l = !0, u, f;
for (; !this.match(11); ) {
if (l) l = !1;
else if (this.expect(12, h.optionalParametersLoc === null ? null : h.optionalParametersLoc), this.match(11)) {
f = this.state.startLoc;
break;
}
if (this.match(21)) {
let A = this.state.startLoc;
if (u = this.state.startLoc, o.push(this.parseParenItem(this.parseRestBinding(), A)), !this.checkCommaAfterRest(41)) break;
} else o.push(this.parseMaybeAssignAllowInOrVoidPattern(11, h, this.parseParenItem));
}
let d = this.state.lastTokEndLoc;
this.expect(11), this.state.maybeInArrowParameters = i, this.state.inFSharpPipelineDirectBody = r;
let x = this.startNodeAt(e);
return t && this.shouldParseArrow(o) && (x = this.parseArrow(x)) ? (this.checkDestructuringPrivate(h), this.expressionScope.validateAsPattern(), this.expressionScope.exit(), this.parseArrowExpression(x, o, !1), x) : (this.expressionScope.exit(), o.length || this.unexpected(this.state.lastTokStartLoc), f && this.unexpected(f), u && this.unexpected(u), this.checkExpressionErrors(h, !0), this.toReferencedListDeep(o, !0), o.length > 1 ? (s = this.startNodeAt(n), s.expressions = o, this.finishNode(s, "SequenceExpression"), this.resetEndLocation(s, d)) : s = o[0], this.wrapParenthesis(e, s));
}
wrapParenthesis(t, e) {
if (!(this.optionFlags & 1024)) return this.addExtra(e, "parenthesized", !0), this.addExtra(e, "parenStart", t.index), this.takeSurroundingComments(e, t.index, this.state.lastTokEndLoc.index), e;
let s = this.startNodeAt(t);
return s.expression = e, this.finishNode(s, "ParenthesizedExpression");
}
shouldParseArrow(t) {
return !this.canInsertSemicolon();
}
parseArrow(t) {
if (this.eat(19)) return t;
}
parseParenItem(t, e) {
return t;
}
parseNewOrNewTarget() {
let t = this.startNode();
if (this.next(), this.match(16)) {
let e = this.createIdentifier(this.startNodeAtNode(t), "new");
this.next();
let s = this.parseMetaProperty(t, e, "target");
return this.scope.allowNewTarget || this.raise(p.UnexpectedNewTarget, s), s;
}
return this.parseNew(t);
}
parseNew(t) {
if (this.parseNewCallee(t), this.eat(10)) {
let e = this.parseExprList(11);
this.toReferencedList(e), t.arguments = e;
} else t.arguments = [];
return this.finishNode(t, "NewExpression");
}
parseNewCallee(t) {
let e = this.match(83), s = this.parseNoCallExpr();
t.callee = s, e && (s.type === "Import" || s.type === "ImportExpression") && this.raise(p.ImportCallNotNewExpression, s);
}
parseTemplateElement(t) {
let { start: e, startLoc: s, end: i, value: r } = this.state, n = e + 1, o = this.startNodeAt(D(s, 1));
r === null && (t || this.raise(p.InvalidEscapeSequenceTemplate, D(this.state.firstInvalidTemplateEscapePos, 1)));
let h = this.match(24), l = h ? -1 : -2, u = i + l;
o.value = { raw: this.input.slice(n, u).replace(/\r\n?/g, `
`), cooked: r === null ? null : r.slice(1, l) }, o.tail = h, this.next();
let f = this.finishNode(o, "TemplateElement");
return this.resetEndLocation(f, D(this.state.lastTokEndLoc, l)), f;
}
parseTemplate(t) {
let e = this.startNode(), s = this.parseTemplateElement(t), i = [s], r = [];
for (; !s.tail; ) r.push(this.parseTemplateSubstitution()), this.readTemplateContinuation(), i.push(s = this.parseTemplateElement(t));
return e.expressions = r, e.quasis = i, this.finishNode(e, "TemplateLiteral");
}
parseTemplateSubstitution() {
return this.parseExpression();
}
parseObjectLike(t, e, s, i) {
s && this.expectPlugin("recordAndTuple");
let r = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = !1;
let n = !1, o = !0, h = this.startNode();
for (h.properties = [], this.next(); !this.match(t); ) {
if (o) o = !1;
else if (this.expect(12), this.match(t)) {
this.addTrailingCommaExtraToNode(h);
break;
}
let u;
e ? u = this.parseBindingProperty() : (u = this.parsePropertyDefinition(i), n = this.checkProto(u, s, n, i)), s && !this.isObjectProperty(u) && u.type !== "SpreadElement" && this.raise(p.InvalidRecordProperty, u), h.properties.push(u);
}
this.next(), this.state.inFSharpPipelineDirectBody = r;
let l = "ObjectExpression";
return e ? l = "ObjectPattern" : s && (l = "RecordExpression"), this.finishNode(h, l);
}
addTrailingCommaExtraToNode(t) {
this.addExtra(t, "trailingComma", this.state.lastTokStartLoc.index), this.addExtra(t, "trailingCommaLoc", this.state.lastTokStartLoc, !1);
}
maybeAsyncOrAccessorProp(t) {
return !t.computed && t.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
}
parsePropertyDefinition(t) {
let e = [];
if (this.match(26)) for (this.hasPlugin("decorators") && this.raise(p.UnsupportedPropertyDecorator, this.state.startLoc); this.match(26); ) e.push(this.parseDecorator());
let s = this.startNode(), i = !1, r = !1, n;
if (this.match(21)) return e.length && this.unexpected(), this.parseSpread();
e.length && (s.decorators = e, e = []), s.method = !1, t && (n = this.state.startLoc);
let o = this.eat(55);
this.parsePropertyNamePrefixOperator(s);
let h = this.state.containsEsc;
if (this.parsePropertyName(s, t), !o && !h && this.maybeAsyncOrAccessorProp(s)) {
let { key: l } = s, u = l.name;
u === "async" && !this.hasPrecedingLineBreak() && (i = !0, this.resetPreviousNodeTrailingComments(l), o = this.eat(55), this.parsePropertyName(s)), (u === "get" || u === "set") && (r = !0, this.resetPreviousNodeTrailingComments(l), s.kind = u, this.match(55) && (o = !0, this.raise(p.AccessorIsGenerator, this.state.curPosition(), { kind: u }), this.next()), this.parsePropertyName(s));
}
return this.parseObjPropValue(s, n, o, i, !1, r, t);
}
getGetterSetterExpectedParamCount(t) {
return t.kind === "get" ? 0 : 1;
}
getObjectOrClassMethodParams(t) {
return t.params;
}
checkGetterSetterParams(t) {
let e = this.getGetterSetterExpectedParamCount(t), s = this.getObjectOrClassMethodParams(t);
s.length !== e && this.raise(t.kind === "get" ? p.BadGetterArity : p.BadSetterArity, t), t.kind === "set" && s[s.length - 1]?.type === "RestElement" && this.raise(p.BadSetterRestParameter, t);
}
parseObjectMethod(t, e, s, i, r) {
if (r) {
let n = this.parseMethod(t, e, !1, !1, !1, "ObjectMethod");
return this.checkGetterSetterParams(n), n;
}
if (s || e || this.match(10)) return i && this.unexpected(), t.kind = "method", t.method = !0, this.parseMethod(t, e, s, !1, !1, "ObjectMethod");
}
parseObjectProperty(t, e, s, i) {
if (t.shorthand = !1, this.eat(14)) return t.value = s ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, i), this.finishObjectProperty(t);
if (!t.computed && t.key.type === "Identifier") {
if (this.checkReservedWord(t.key.name, t.key.loc.start, !0, !1), s) t.value = this.parseMaybeDefault(e, this.cloneIdentifier(t.key));
else if (this.match(29)) {
let r = this.state.startLoc;
i != null ? i.shorthandAssignLoc === null && (i.shorthandAssignLoc = r) : this.raise(p.InvalidCoverInitializedName, r), t.value = this.parseMaybeDefault(e, this.cloneIdentifier(t.key));
} else t.value = this.cloneIdentifier(t.key);
return t.shorthand = !0, this.finishObjectProperty(t);
}
}
finishObjectProperty(t) {
return this.finishNode(t, "ObjectProperty");
}
parseObjPropValue(t, e, s, i, r, n, o) {
let h = this.parseObjectMethod(t, s, i, r, n) || this.parseObjectProperty(t, e, r, o);
return h || this.unexpected(), h;
}
parsePropertyName(t, e) {
if (this.eat(0)) t.computed = !0, t.key = this.parseMaybeAssignAllowIn(), this.expect(3);
else {
let { type: s, value: i } = this.state, r;
if (O(s)) r = this.parseIdentifier(!0);
else switch (s) {
case 135:
r = this.parseNumericLiteral(i);
break;
case 134:
r = this.parseStringLiteral(i);
break;
case 136:
r = this.parseBigIntLiteral(i);
break;
case 139: {
let n = this.state.startLoc;
e != null ? e.privateKeyLoc === null && (e.privateKeyLoc = n) : this.raise(p.UnexpectedPrivateField, n), r = this.parsePrivateName();
break;
}
default:
this.unexpected();
}
t.key = r, s !== 139 && (t.computed = !1);
}
}
initFunction(t, e) {
t.id = null, t.generator = !1, t.async = e;
}
parseMethod(t, e, s, i, r, n, o = !1) {
this.initFunction(t, s), t.generator = e, this.scope.enter(530 | (o ? 576 : 0) | (r ? 32 : 0)), this.prodParam.enter(Se(s, t.generator)), this.parseFunctionParams(t, i);
let h = this.parseFunctionBodyAndFinish(t, n, !0);
return this.prodParam.exit(), this.scope.exit(), h;
}
parseArrayLike(t, e, s) {
e && this.expectPlugin("recordAndTuple");
let i = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = !1;
let r = this.startNode();
return this.next(), r.elements = this.parseExprList(t, !e, s, r), this.state.inFSharpPipelineDirectBody = i, this.finishNode(r, e ? "TupleExpression" : "ArrayExpression");
}
parseArrowExpression(t, e, s, i) {
this.scope.enter(518);
let r = Se(s, !1);
!this.match(5) && this.prodParam.hasIn && (r |= 8), this.prodParam.enter(r), this.initFunction(t, s);
let n = this.state.maybeInArrowParameters;
return e && (this.state.maybeInArrowParameters = !0, this.setArrowFunctionParameters(t, e, i)), this.state.maybeInArrowParameters = !1, this.parseFunctionBody(t, !0), this.prodParam.exit(), this.scope.exit(), this.state.maybeInArrowParameters = n, this.finishNode(t, "ArrowFunctionExpression");
}
setArrowFunctionParameters(t, e, s) {
this.toAssignableList(e, s, !1), t.params = e;
}
parseFunctionBodyAndFinish(t, e, s = !1) {
return this.parseFunctionBody(t, !1, s), this.finishNode(t, e);
}
parseFunctionBody(t, e, s = !1) {
let i = e && !this.match(5);
if (this.expressionScope.enter(as()), i) t.body = this.parseMaybeAssign(), this.checkParams(t, !1, e, !1);
else {
let r = this.state.strict, n = this.state.labels;
this.state.labels = [], this.prodParam.enter(this.prodParam.currentFlags() | 4), t.body = this.parseBlock(!0, !1, (o) => {
let h = !this.isSimpleParamList(t.params);
o && h && this.raise(p.IllegalLanguageModeDirective, (t.kind === "method" || t.kind === "constructor") && t.key ? t.key.loc.end : t);
let l = !r && this.state.strict;
this.checkParams(t, !this.state.strict && !e && !s && !h, e, l), this.state.strict && t.id && this.checkIdentifier(t.id, 65, l);
}), this.prodParam.exit(), this.state.labels = n;
}
this.expressionScope.exit();
}
isSimpleParameter(t) {
return t.type === "Identifier";
}
isSimpleParamList(t) {
for (let e = 0, s = t.length; e < s; e++) if (!this.isSimpleParameter(t[e])) return !1;
return !0;
}
checkParams(t, e, s, i = !0) {
let r = !e && /* @__PURE__ */ new Set(), n = { type: "FormalParameters" };
for (let o of t.params) this.checkLVal(o, n, 5, r, i);
}
parseExprList(t, e, s, i) {
let r = [], n = !0;
for (; !this.eat(t); ) {
if (n) n = !1;
else if (this.expect(12), this.match(t)) {
i && this.addTrailingCommaExtraToNode(i), this.next();
break;
}
r.push(this.parseExprListItem(t, e, s));
}
return r;
}
parseExprListItem(t, e, s, i) {
let r;
if (this.match(12)) e || this.raise(p.UnexpectedToken, this.state.curPosition(), { unexpected: "," }), r = null;
else if (this.match(21)) {
let n = this.state.startLoc;
r = this.parseParenItem(this.parseSpread(s), n);
} else if (this.match(17)) {
this.expectPlugin("partialApplication"), i || this.raise(p.UnexpectedArgumentPlaceholder, this.state.startLoc);
let n = this.startNode();
this.next(), r = this.finishNode(n, "ArgumentPlaceholder");
} else r = this.parseMaybeAssignAllowInOrVoidPattern(t, s, this.parseParenItem);
return r;
}
parseIdentifier(t) {
let e = this.startNode(), s = this.parseIdentifierName(t);
return this.createIdentifier(e, s);
}
createIdentifier(t, e) {
return t.name = e, t.loc.identifierName = e, this.finishNode(t, "Identifier");
}
createIdentifierAt(t, e, s) {
return t.name = e, t.loc.identifierName = e, this.finishNodeAt(t, "Identifier", s);
}
parseIdentifierName(t) {
let e, { startLoc: s, type: i } = this.state;
O(i) ? e = this.state.value : this.unexpected();
let r = hi(i);
return t ? r && this.replaceToken(132) : this.checkReservedWord(e, s, r, !1), this.next(), e;
}
checkReservedWord(t, e, s, i) {
if (!(t.length > 10 || !Ii(t))) {
if (s && wi(t)) {
this.raise(p.UnexpectedKeyword, e, { keyword: t });
return;
}
if ((this.state.strict ? i ? ts : Zt : Qt)(t, this.inModule)) {
this.raise(p.UnexpectedReservedWord, e, { reservedWord: t });
return;
} else if (t === "yield") {
if (this.prodParam.hasYield) {
this.raise(p.YieldBindingIdentifier, e);
return;
}
} else if (t === "await") {
if (this.prodParam.hasAwait) {
this.raise(p.AwaitBindingIdentifier, e);
return;
}
if (this.scope.inStaticBlock) {
this.raise(p.AwaitBindingIdentifierInStaticBlock, e);
return;
}
this.expressionScope.recordAsyncArrowParametersError(e);
} else if (t === "arguments" && this.scope.inClassAndNotInNonArrowFunction) {
this.raise(p.ArgumentsInClass, e);
return;
}
}
}
recordAwaitIfAllowed() {
let t = this.prodParam.hasAwait;
return t && !this.scope.inFunction && (this.state.hasTopLevelAwait = !0), t;
}
parseAwait(t) {
let e = this.startNodeAt(t);
return this.expressionScope.recordParameterInitializerError(p.AwaitExpressionFormalParameter, e), this.eat(55) && this.raise(p.ObsoleteAwaitStar, e), !this.scope.inFunction && !(this.optionFlags & 1) && (this.isAmbiguousPrefixOrIdentifier() ? this.ambiguousScriptDifferentAst = !0 : this.sawUnambiguousESM = !0), this.state.soloAwait || (e.argument = this.parseMaybeUnary(null, !0)), this.finishNode(e, "AwaitExpression");
}
isAmbiguousPrefixOrIdentifier() {
if (this.hasPrecedingLineBreak()) return !0;
let { type: t } = this.state;
return t === 53 || t === 10 || t === 0 || $e(t) || t === 102 && !this.state.containsEsc || t === 138 || t === 56 || this.hasPlugin("v8intrinsic") && t === 54;
}
parseYield(t) {
let e = this.startNodeAt(t);
this.expressionScope.recordParameterInitializerError(p.YieldInParameter, e);
let s = !1, i = null;
if (!this.hasPrecedingLineBreak()) switch (s = this.eat(55), this.state.type) {
case 13:
case 140:
case 8:
case 11:
case 3:
case 9:
case 14:
case 12:
if (!s) break;
default:
i = this.parseMaybeAssign();
}
return e.delegate = s, e.argument = i, this.finishNode(e, "YieldExpression");
}
parseImportCall(t) {
if (this.next(), t.source = this.parseMaybeAssignAllowIn(), t.options = null, this.eat(12)) {
if (this.match(11)) this.addTrailingCommaExtraToNode(t.source);
else if (t.options = this.parseMaybeAssignAllowIn(), this.eat(12) && (this.addTrailingCommaExtraToNode(t.options), !this.match(11))) {
do
this.parseMaybeAssignAllowIn();
while (this.eat(12) && !this.match(11));
this.raise(p.ImportCallArity, t);
}
}
return this.expect(11), this.finishNode(t, "ImportExpression");
}
checkPipelineAtInfixOperator(t, e) {
this.hasPlugin(["pipelineOperator", { proposal: "smart" }]) && t.type === "SequenceExpression" && this.raise(p.PipelineHeadSequenceExpression, e);
}
parseSmartPipelineBodyInStyle(t, e) {
if (this.isSimpleReference(t)) {
let s = this.startNodeAt(e);
return s.callee = t, this.finishNode(s, "PipelineBareFunction");
} else {
let s = this.startNodeAt(e);
return this.checkSmartPipeTopicBodyEarlyErrors(e), s.expression = t, this.finishNode(s, "PipelineTopicExpression");
}
}
isSimpleReference(t) {
switch (t.type) {
case "MemberExpression":
return !t.computed && this.isSimpleReference(t.object);
case "Identifier":
return !0;
default:
return !1;
}
}
checkSmartPipeTopicBodyEarlyErrors(t) {
if (this.match(19)) throw this.raise(p.PipelineBodyNoArrow, this.state.startLoc);
this.topicReferenceWasUsedInCurrentContext() || this.raise(p.PipelineTopicUnused, t);
}
withTopicBindingContext(t) {
let e = this.state.topicContext;
this.state.topicContext = { maxNumOfResolvableTopics: 1, maxTopicIndex: null };
try {
return t();
} finally {
this.state.topicContext = e;
}
}
withSmartMixTopicForbiddingContext(t) {
return t();
}
withSoloAwaitPermittingContext(t) {
let e = this.state.soloAwait;
this.state.soloAwait = !0;
try {
return t();
} finally {
this.state.soloAwait = e;
}
}
allowInAnd(t) {
let e = this.prodParam.currentFlags();
if (8 & ~e) {
this.prodParam.enter(e | 8);
try {
return t();
} finally {
this.prodParam.exit();
}
}
return t();
}
disallowInAnd(t) {
let e = this.prodParam.currentFlags();
if (8 & e) {
this.prodParam.enter(e & -9);
try {
return t();
} finally {
this.prodParam.exit();
}
}
return t();
}
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(t) {
let e = this.state.startLoc;
this.state.potentialArrowAt = this.state.start;
let s = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = !0;
let i = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), e, t);
return this.state.inFSharpPipelineDirectBody = s, i;
}
parseModuleExpression() {
this.expectPlugin("moduleBlocks");
let t = this.startNode();
this.next(), this.match(5) || this.unexpected(null, 5);
let e = this.startNodeAt(this.state.endLoc);
this.next();
let s = this.initializeScopes(!0);
this.enterInitialScopes();
try {
t.body = this.parseProgram(e, 8, "module");
} finally {
s();
}
return this.finishNode(t, "ModuleExpression");
}
parseVoidPattern(t) {
this.expectPlugin("discardBinding");
let e = this.startNode();
return t != null && (t.voidPatternLoc = this.state.startLoc), this.next(), this.finishNode(e, "VoidPattern");
}
parseMaybeAssignAllowInOrVoidPattern(t, e, s) {
if (e != null && this.match(88)) {
let i = this.lookaheadCharCode();
if (i === 44 || i === (t === 3 ? 93 : t === 8 ? 125 : 41) || i === 61) return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(e));
}
return this.parseMaybeAssignAllowIn(e, s);
}
parsePropertyNamePrefixOperator(t) {
}
}, ze = { kind: 1 }, sr = { kind: 2 }, ir = /[\uD800-\uDFFF]/u, qe = /in(?:stanceof)?/y;
ut = class extends pt {
parseTopLevel(t, e) {
return t.program = this.parseProgram(e, 140, this.options.sourceType === "module" ? "module" : "script"), t.comments = this.comments, this.optionFlags & 256 && (t.tokens = rr(this.tokens, this.input, this.startIndex)), this.finishNode(t, "File");
}
parseProgram(t, e, s) {
if (t.sourceType = s, t.interpreter = this.parseInterpreterDirective(), this.parseBlockBody(t, !0, !0, e), this.inModule) {
if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) for (let [r, n] of Array.from(this.scope.undefinedExports)) this.raise(p.ModuleExportUndefined, n, { localName: r });
this.addExtra(t, "topLevelAwait", this.state.hasTopLevelAwait);
}
let i;
return e === 140 ? i = this.finishNode(t, "Program") : i = this.finishNodeAt(t, "Program", D(this.state.startLoc, -1)), i;
}
stmtToDirective(t) {
let e = this.castNodeTo(t, "Directive"), s = this.castNodeTo(t.expression, "DirectiveLiteral"), i = s.value, r = this.input.slice(this.offsetToSourcePos(s.start), this.offsetToSourcePos(s.end)), n = s.value = r.slice(1, -1);
return this.addExtra(s, "raw", r), this.addExtra(s, "rawValue", n), this.addExtra(s, "expressionValue", i), e.value = s, delete t.expression, e;
}
parseInterpreterDirective() {
if (!this.match(28)) return null;
let t = this.startNode();
return t.value = this.state.value, this.next(), this.finishNode(t, "InterpreterDirective");
}
isLet() {
return this.isContextual(100) ? this.hasFollowingBindingAtom() : !1;
}
isUsing() {
return this.isContextual(107) ? this.nextTokenIsIdentifierOnSameLine() : !1;
}
isForUsing() {
if (!this.isContextual(107)) return !1;
let t = this.nextTokenInLineStart(), e = this.codePointAtPos(t);
if (this.isUnparsedContextual(t, "of")) {
let s = this.lookaheadCharCodeSince(t + 2);
if (s !== 61 && s !== 58 && s !== 59) return !1;
}
return !!(this.chStartsBindingIdentifier(e, t) || this.isUnparsedContextual(t, "void"));
}
nextTokenIsIdentifierOnSameLine() {
let t = this.nextTokenInLineStart(), e = this.codePointAtPos(t);
return this.chStartsBindingIdentifier(e, t);
}
isAwaitUsing() {
if (!this.isContextual(96)) return !1;
let t = this.nextTokenInLineStart();
if (this.isUnparsedContextual(t, "using")) {
t = this.nextTokenInLineStartSince(t + 5);
let e = this.codePointAtPos(t);
if (this.chStartsBindingIdentifier(e, t)) return !0;
}
return !1;
}
chStartsBindingIdentifier(t, e) {
if (B(t)) {
if (qe.lastIndex = e, qe.test(this.input)) {
let s = this.codePointAtPos(qe.lastIndex);
if (!K(s) && s !== 92) return !1;
}
return !0;
} else return t === 92;
}
chStartsBindingPattern(t) {
return t === 91 || t === 123;
}
hasFollowingBindingAtom() {
let t = this.nextTokenStart(), e = this.codePointAtPos(t);
return this.chStartsBindingPattern(e) || this.chStartsBindingIdentifier(e, t);
}
hasInLineFollowingBindingIdentifierOrBrace() {
let t = this.nextTokenInLineStart(), e = this.codePointAtPos(t);
return e === 123 || this.chStartsBindingIdentifier(e, t);
}
allowsUsing() {
return (this.scope.inModule || !this.scope.inTopLevel) && !this.scope.inBareCaseStatement;
}
parseModuleItem() {
return this.parseStatementLike(15);
}
parseStatementListItem() {
return this.parseStatementLike(6 | (!this.options.annexB || this.state.strict ? 0 : 8));
}
parseStatementOrSloppyAnnexBFunctionDeclaration(t = !1) {
let e = 0;
return this.options.annexB && !this.state.strict && (e |= 4, t && (e |= 8)), this.parseStatementLike(e);
}
parseStatement() {
return this.parseStatementLike(0);
}
parseStatementLike(t) {
let e = null;
return this.match(26) && (e = this.parseDecorators(!0)), this.parseStatementContent(t, e);
}
parseStatementContent(t, e) {
let s = this.state.type, i = this.startNode(), r = !!(t & 2), n = !!(t & 4), o = t & 1;
switch (s) {
case 60:
return this.parseBreakContinueStatement(i, !0);
case 63:
return this.parseBreakContinueStatement(i, !1);
case 64:
return this.parseDebuggerStatement(i);
case 90:
return this.parseDoWhileStatement(i);
case 91:
return this.parseForStatement(i);
case 68:
if (this.lookaheadCharCode() === 46) break;
return n || this.raise(this.state.strict ? p.StrictFunction : this.options.annexB ? p.SloppyFunctionAnnexB : p.SloppyFunction, this.state.startLoc), this.parseFunctionStatement(i, !1, !r && n);
case 80:
return r || this.unexpected(), this.parseClass(this.maybeTakeDecorators(e, i), !0);
case 69:
return this.parseIfStatement(i);
case 70:
return this.parseReturnStatement(i);
case 71:
return this.parseSwitchStatement(i);
case 72:
return this.parseThrowStatement(i);
case 73:
return this.parseTryStatement(i);
case 96:
if (this.isAwaitUsing()) return this.allowsUsing() ? r ? this.recordAwaitIfAllowed() || this.raise(p.AwaitUsingNotInAsyncContext, i) : this.raise(p.UnexpectedLexicalDeclaration, i) : this.raise(p.UnexpectedUsingDeclaration, i), this.next(), this.parseVarStatement(i, "await using");
break;
case 107:
if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) break;
return this.allowsUsing() ? r || this.raise(p.UnexpectedLexicalDeclaration, this.state.startLoc) : this.raise(p.UnexpectedUsingDeclaration, this.state.startLoc), this.parseVarStatement(i, "using");
case 100: {
if (this.state.containsEsc) break;
let u = this.nextTokenStart(), f = this.codePointAtPos(u);
if (f !== 91 && (!r && this.hasFollowingLineBreak() || !this.chStartsBindingIdentifier(f, u) && f !== 123)) break;
}
case 75:
r || this.raise(p.UnexpectedLexicalDeclaration, this.state.startLoc);
case 74: {
let u = this.state.value;
return this.parseVarStatement(i, u);
}
case 92:
return this.parseWhileStatement(i);
case 76:
return this.parseWithStatement(i);
case 5:
return this.parseBlock();
case 13:
return this.parseEmptyStatement(i);
case 83: {
let u = this.lookaheadCharCode();
if (u === 40 || u === 46) break;
}
case 82: {
!(this.optionFlags & 8) && !o && this.raise(p.UnexpectedImportExport, this.state.startLoc), this.next();
let u;
return s === 83 ? u = this.parseImport(i) : u = this.parseExport(i, e), this.assertModuleNodeAllowed(u), u;
}
default:
if (this.isAsyncFunction()) return r || this.raise(p.AsyncFunctionInSingleStatementContext, this.state.startLoc), this.next(), this.parseFunctionStatement(i, !0, !r && n);
}
let h = this.state.value, l = this.parseExpression();
return w(s) && l.type === "Identifier" && this.eat(14) ? this.parseLabeledStatement(i, h, l, t) : this.parseExpressionStatement(i, l, e);
}
assertModuleNodeAllowed(t) {
!(this.optionFlags & 8) && !this.inModule && this.raise(p.ImportOutsideModule, t);
}
decoratorsEnabledBeforeExport() {
return this.hasPlugin("decorators-legacy") ? !0 : this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== !1;
}
maybeTakeDecorators(t, e, s) {
return t && (e.decorators?.length ? (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") != "boolean" && this.raise(p.DecoratorsBeforeAfterExport, e.decorators[0]), e.decorators.unshift(...t)) : e.decorators = t, this.resetStartLocationFromNode(e, t[0]), s && this.resetStartLocationFromNode(s, e)), e;
}
canHaveLeadingDecorator() {
return this.match(80);
}
parseDecorators(t) {
let e = [];
do
e.push(this.parseDecorator());
while (this.match(26));
if (this.match(82)) t || this.unexpected(), this.decoratorsEnabledBeforeExport() || this.raise(p.DecoratorExportClass, this.state.startLoc);
else if (!this.canHaveLeadingDecorator()) throw this.raise(p.UnexpectedLeadingDecorator, this.state.startLoc);
return e;
}
parseDecorator() {
this.expectOnePlugin(["decorators", "decorators-legacy"]);
let t = this.startNode();
if (this.next(), this.hasPlugin("decorators")) {
let e = this.state.startLoc, s;
if (this.match(10)) {
let i = this.state.startLoc;
this.next(), s = this.parseExpression(), this.expect(11), s = this.wrapParenthesis(i, s);
let r = this.state.startLoc;
t.expression = this.parseMaybeDecoratorArguments(s, i), this.getPluginOption("decorators", "allowCallParenthesized") === !1 && t.expression !== s && this.raise(p.DecoratorArgumentsOutsideParentheses, r);
} else {
for (s = this.parseIdentifier(!1); this.eat(16); ) {
let i = this.startNodeAt(e);
i.object = s, this.match(139) ? (this.classScope.usePrivateName(this.state.value, this.state.startLoc), i.property = this.parsePrivateName()) : i.property = this.parseIdentifier(!0), i.computed = !1, s = this.finishNode(i, "MemberExpression");
}
t.expression = this.parseMaybeDecoratorArguments(s, e);
}
} else t.expression = this.parseExprSubscripts();
return this.finishNode(t, "Decorator");
}
parseMaybeDecoratorArguments(t, e) {
if (this.eat(10)) {
let s = this.startNodeAt(e);
return s.callee = t, s.arguments = this.parseCallExpressionArguments(), this.toReferencedList(s.arguments), this.finishNode(s, "CallExpression");
}
return t;
}
parseBreakContinueStatement(t, e) {
return this.next(), this.isLineTerminator() ? t.label = null : (t.label = this.parseIdentifier(), this.semicolon()), this.verifyBreakContinue(t, e), this.finishNode(t, e ? "BreakStatement" : "ContinueStatement");
}
verifyBreakContinue(t, e) {
let s;
for (s = 0; s < this.state.labels.length; ++s) {
let i = this.state.labels[s];
if ((t.label == null || i.name === t.label.name) && (i.kind != null && (e || i.kind === 1) || t.label && e)) break;
}
if (s === this.state.labels.length) {
let i = e ? "BreakStatement" : "ContinueStatement";
this.raise(p.IllegalBreakContinue, t, { type: i });
}
}
parseDebuggerStatement(t) {
return this.next(), this.semicolon(), this.finishNode(t, "DebuggerStatement");
}
parseHeaderExpression() {
this.expect(10);
let t = this.parseExpression();
return this.expect(11), t;
}
parseDoWhileStatement(t) {
return this.next(), this.state.labels.push(ze), t.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()), this.state.labels.pop(), this.expect(92), t.test = this.parseHeaderExpression(), this.eat(13), this.finishNode(t, "DoWhileStatement");
}
parseForStatement(t) {
this.next(), this.state.labels.push(ze);
let e = null;
if (this.isContextual(96) && this.recordAwaitIfAllowed() && (e = this.state.startLoc, this.next()), this.scope.enter(0), this.expect(10), this.match(13)) return e !== null && this.unexpected(e), this.parseFor(t, null);
let s = this.isContextual(100);
{
let h = this.isAwaitUsing(), l = h || this.isForUsing(), u = s && this.hasFollowingBindingAtom() || l;
if (this.match(74) || this.match(75) || u) {
let f = this.startNode(), d;
h ? (d = "await using", this.recordAwaitIfAllowed() || this.raise(p.AwaitUsingNotInAsyncContext, this.state.startLoc), this.next()) : d = this.state.value, this.next(), this.parseVar(f, !0, d);
let x = this.finishNode(f, "VariableDeclaration"), A = this.match(58);
return A && l && this.raise(p.ForInUsing, x), (A || this.isContextual(102)) && x.declarations.length === 1 ? this.parseForIn(t, x, e) : (e !== null && this.unexpected(e), this.parseFor(t, x));
}
}
let i = this.isContextual(95), r = new Y(), n = this.parseExpression(!0, r), o = this.isContextual(102);
if (o && (s && this.raise(p.ForOfLet, n), e === null && i && n.type === "Identifier" && this.raise(p.ForOfAsync, n)), o || this.match(58)) {
this.checkDestructuringPrivate(r), this.toAssignable(n, !0);
let h = o ? "ForOfStatement" : "ForInStatement";
return this.checkLVal(n, { type: h }), this.parseForIn(t, n, e);
} else this.checkExpressionErrors(r, !0);
return e !== null && this.unexpected(e), this.parseFor(t, n);
}
parseFunctionStatement(t, e, s) {
return this.next(), this.parseFunction(t, 1 | (s ? 2 : 0) | (e ? 8 : 0));
}
parseIfStatement(t) {
return this.next(), t.test = this.parseHeaderExpression(), t.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration(), t.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null, this.finishNode(t, "IfStatement");
}
parseReturnStatement(t) {
return this.prodParam.hasReturn || this.raise(p.IllegalReturn, this.state.startLoc), this.next(), this.isLineTerminator() ? t.argument = null : (t.argument = this.parseExpression(), this.semicolon()), this.finishNode(t, "ReturnStatement");
}
parseSwitchStatement(t) {
this.next(), t.discriminant = this.parseHeaderExpression();
let e = t.cases = [];
this.expect(5), this.state.labels.push(sr), this.scope.enter(256);
let s;
for (let i; !this.match(8); ) if (this.match(61) || this.match(65)) {
let r = this.match(61);
s && this.finishNode(s, "SwitchCase"), e.push(s = this.startNode()), s.consequent = [], this.next(), r ? s.test = this.parseExpression() : (i && this.raise(p.MultipleDefaultsInSwitch, this.state.lastTokStartLoc), i = !0, s.test = null), this.expect(14);
} else s ? s.consequent.push(this.parseStatementListItem()) : this.unexpected();
return this.scope.exit(), s && this.finishNode(s, "SwitchCase"), this.next(), this.state.labels.pop(), this.finishNode(t, "SwitchStatement");
}
parseThrowStatement(t) {
return this.next(), this.hasPrecedingLineBreak() && this.raise(p.NewlineAfterThrow, this.state.lastTokEndLoc), t.argument = this.parseExpression(), this.semicolon(), this.finishNode(t, "ThrowStatement");
}
parseCatchClauseParam() {
let t = this.parseBindingAtom();
return this.scope.enter(this.options.annexB && t.type === "Identifier" ? 8 : 0), this.checkLVal(t, { type: "CatchClause" }, 9), t;
}
parseTryStatement(t) {
if (this.next(), t.block = this.parseBlock(), t.handler = null, this.match(62)) {
let e = this.startNode();
this.next(), this.match(10) ? (this.expect(10), e.param = this.parseCatchClauseParam(), this.expect(11)) : (e.param = null, this.scope.enter(0)), e.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(!1, !1)), this.scope.exit(), t.handler = this.finishNode(e, "CatchClause");
}
return t.finalizer = this.eat(67) ? this.parseBlock() : null, !t.handler && !t.finalizer && this.raise(p.NoCatchOrFinally, t), this.finishNode(t, "TryStatement");
}
parseVarStatement(t, e, s = !1) {
return this.next(), this.parseVar(t, !1, e, s), this.semicolon(), this.finishNode(t, "VariableDeclaration");
}
parseWhileStatement(t) {
return this.next(), t.test = this.parseHeaderExpression(), this.state.labels.push(ze), t.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()), this.state.labels.pop(), this.finishNode(t, "WhileStatement");
}
parseWithStatement(t) {
return this.state.strict && this.raise(p.StrictWith, this.state.startLoc), this.next(), t.object = this.parseHeaderExpression(), t.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()), this.finishNode(t, "WithStatement");
}
parseEmptyStatement(t) {
return this.next(), this.finishNode(t, "EmptyStatement");
}
parseLabeledStatement(t, e, s, i) {
for (let n of this.state.labels) n.name === e && this.raise(p.LabelRedeclaration, s, { labelName: e });
let r = pi(this.state.type) ? 1 : this.match(71) ? 2 : null;
for (let n = this.state.labels.length - 1; n >= 0; n--) {
let o = this.state.labels[n];
if (o.statementStart === t.start) o.statementStart = this.sourceToOffsetPos(this.state.start), o.kind = r;
else break;
}
return this.state.labels.push({ name: e, kind: r, statementStart: this.sourceToOffsetPos(this.state.start) }), t.body = i & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(!0) : this.parseStatement(), this.state.labels.pop(), t.label = s, this.finishNode(t, "LabeledStatement");
}
parseExpressionStatement(t, e, s) {
return t.expression = e, this.semicolon(), this.finishNode(t, "ExpressionStatement");
}
parseBlock(t = !1, e = !0, s) {
let i = this.startNode();
return t && this.state.strictErrors.clear(), this.expect(5), e && this.scope.enter(0), this.parseBlockBody(i, t, !1, 8, s), e && this.scope.exit(), this.finishNode(i, "BlockStatement");
}
isValidDirective(t) {
return t.type === "ExpressionStatement" && t.expression.type === "StringLiteral" && !t.expression.extra.parenthesized;
}
parseBlockBody(t, e, s, i, r) {
let n = t.body = [], o = t.directives = [];
this.parseBlockOrModuleBlockBody(n, e ? o : void 0, s, i, r);
}
parseBlockOrModuleBlockBody(t, e, s, i, r) {
let n = this.state.strict, o = !1, h = !1;
for (; !this.match(i); ) {
let l = s ? this.parseModuleItem() : this.parseStatementListItem();
if (e && !h) {
if (this.isValidDirective(l)) {
let u = this.stmtToDirective(l);
e.push(u), !o && u.value.value === "use strict" && (o = !0, this.setStrict(!0));
continue;
}
h = !0, this.state.strictErrors.clear();
}
t.push(l);
}
r?.call(this, o), n || this.setStrict(!1), this.next();
}
parseFor(t, e) {
return t.init = e, this.semicolon(!1), t.test = this.match(13) ? null : this.parseExpression(), this.semicolon(!1), t.update = this.match(11) ? null : this.parseExpression(), this.expect(11), t.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()), this.scope.exit(), this.state.labels.pop(), this.finishNode(t, "ForStatement");
}
parseForIn(t, e, s) {
let i = this.match(58);
return this.next(), i ? s !== null && this.unexpected(s) : t.await = s !== null, e.type === "VariableDeclaration" && e.declarations[0].init != null && (!i || !this.options.annexB || this.state.strict || e.kind !== "var" || e.declarations[0].id.type !== "Identifier") && this.raise(p.ForInOfLoopInitializer, e, { type: i ? "ForInStatement" : "ForOfStatement" }), e.type === "AssignmentPattern" && this.raise(p.InvalidLhs, e, { ancestor: { type: "ForStatement" } }), t.left = e, t.right = i ? this.parseExpression() : this.parseMaybeAssignAllowIn(), this.expect(11), t.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement()), this.scope.exit(), this.state.labels.pop(), this.finishNode(t, i ? "ForInStatement" : "ForOfStatement");
}
parseVar(t, e, s, i = !1) {
let r = t.declarations = [];
for (t.kind = s; ; ) {
let n = this.startNode();
if (this.parseVarId(n, s), n.init = this.eat(29) ? e ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn() : null, n.init === null && !i && (n.id.type !== "Identifier" && !(e && (this.match(58) || this.isContextual(102))) ? this.raise(p.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind: "destructuring" }) : (s === "const" || s === "using" || s === "await using") && !(this.match(58) || this.isContextual(102)) && this.raise(p.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind: s })), r.push(this.finishNode(n, "VariableDeclarator")), !this.eat(12)) break;
}
return t;
}
parseVarId(t, e) {
let s = this.parseBindingAtom();
e === "using" || e === "await using" ? (s.type === "ArrayPattern" || s.type === "ObjectPattern") && this.raise(p.UsingDeclarationHasBindingPattern, s.loc.start) : s.type === "VoidPattern" && this.raise(p.UnexpectedVoidPattern, s.loc.start), this.checkLVal(s, { type: "VariableDeclarator" }, e === "var" ? 5 : 8201), t.id = s;
}
parseAsyncFunctionExpression(t) {
return this.parseFunction(t, 8);
}
parseFunction(t, e = 0) {
let s = e & 2, i = !!(e & 1), r = i && !(e & 4), n = !!(e & 8);
this.initFunction(t, n), this.match(55) && (s && this.raise(p.GeneratorInSingleStatementContext, this.state.startLoc), this.next(), t.generator = !0), i && (t.id = this.parseFunctionId(r));
let o = this.state.maybeInArrowParameters;
return this.state.maybeInArrowParameters = !1, this.scope.enter(514), this.prodParam.enter(Se(n, t.generator)), i || (t.id = this.parseFunctionId()), this.parseFunctionParams(t, !1), this.withSmartMixTopicForbiddingContext(() => {
this.parseFunctionBodyAndFinish(t, i ? "FunctionDeclaration" : "FunctionExpression");
}), this.prodParam.exit(), this.scope.exit(), i && !s && this.registerFunctionStatementId(t), this.state.maybeInArrowParameters = o, t;
}
parseFunctionId(t) {
return t || w(this.state.type) ? this.parseIdentifier() : null;
}
parseFunctionParams(t, e) {
this.expect(10), this.expressionScope.enter(zi()), t.params = this.parseBindingList(11, 41, 2 | (e ? 4 : 0)), this.expressionScope.exit();
}
registerFunctionStatementId(t) {
t.id && this.scope.declareName(t.id.name, !this.options.annexB || this.state.strict || t.generator || t.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, t.id.loc.start);
}
parseClass(t, e, s) {
this.next();
let i = this.state.strict;
return this.state.strict = !0, this.parseClassId(t, e, s), this.parseClassSuper(t), t.body = this.parseClassBody(!!t.superClass, i), this.finishNode(t, e ? "ClassDeclaration" : "ClassExpression");
}
isClassProperty() {
return this.match(29) || this.match(13) || this.match(8);
}
isClassMethod() {
return this.match(10);
}
nameIsConstructor(t) {
return t.type === "Identifier" && t.name === "constructor" || t.type === "StringLiteral" && t.value === "constructor";
}
isNonstaticConstructor(t) {
return !t.computed && !t.static && this.nameIsConstructor(t.key);
}
parseClassBody(t, e) {
this.classScope.enter();
let s = { hadConstructor: !1, hadSuperClass: t }, i = [], r = this.startNode();
if (r.body = [], this.expect(5), this.withSmartMixTopicForbiddingContext(() => {
for (; !this.match(8); ) {
if (this.eat(13)) {
if (i.length > 0) throw this.raise(p.DecoratorSemicolon, this.state.lastTokEndLoc);
continue;
}
if (this.match(26)) {
i.push(this.parseDecorator());
continue;
}
let n = this.startNode();
i.length && (n.decorators = i, this.resetStartLocationFromNode(n, i[0]), i = []), this.parseClassMember(r, n, s), n.kind === "constructor" && n.decorators && n.decorators.length > 0 && this.raise(p.DecoratorConstructor, n);
}
}), this.state.strict = e, this.next(), i.length) throw this.raise(p.TrailingDecorator, this.state.startLoc);
return this.classScope.exit(), this.finishNode(r, "ClassBody");
}
parseClassMemberFromModifier(t, e) {
let s = this.parseIdentifier(!0);
if (this.isClassMethod()) {
let i = e;
return i.kind = "method", i.computed = !1, i.key = s, i.static = !1, this.pushClassMethod(t, i, !1, !1, !1, !1), !0;
} else if (this.isClassProperty()) {
let i = e;
return i.computed = !1, i.key = s, i.static = !1, t.body.push(this.parseClassProperty(i)), !0;
}
return this.resetPreviousNodeTrailingComments(s), !1;
}
parseClassMember(t, e, s) {
let i = this.isContextual(106);
if (i) {
if (this.parseClassMemberFromModifier(t, e)) return;
if (this.eat(5)) {
this.parseClassStaticBlock(t, e);
return;
}
}
this.parseClassMemberWithIsStatic(t, e, s, i);
}
parseClassMemberWithIsStatic(t, e, s, i) {
let r = e, n = e, o = e, h = e, l = e, u = r, f = r;
if (e.static = i, this.parsePropertyNamePrefixOperator(e), this.eat(55)) {
u.kind = "method";
let C = this.match(139);
if (this.parseClassElementName(u), this.parsePostMemberNameModifiers(u), C) {
this.pushClassPrivateMethod(t, n, !0, !1);
return;
}
this.isNonstaticConstructor(r) && this.raise(p.ConstructorIsGenerator, r.key), this.pushClassMethod(t, r, !0, !1, !1, !1);
return;
}
let d = !this.state.containsEsc && w(this.state.type), x = this.parseClassElementName(e), A = d ? x.name : null, k = this.isPrivateName(x), N = this.state.startLoc;
if (this.parsePostMemberNameModifiers(f), this.isClassMethod()) {
if (u.kind = "method", k) {
this.pushClassPrivateMethod(t, n, !1, !1);
return;
}
let C = this.isNonstaticConstructor(r), I = !1;
C && (r.kind = "constructor", s.hadConstructor && !this.hasPlugin("typescript") && this.raise(p.DuplicateConstructor, x), C && this.hasPlugin("typescript") && e.override && this.raise(p.OverrideOnConstructor, x), s.hadConstructor = !0, I = s.hadSuperClass), this.pushClassMethod(t, r, !1, !1, C, I);
} else if (this.isClassProperty()) k ? this.pushClassPrivateProperty(t, h) : this.pushClassProperty(t, o);
else if (A === "async" && !this.isLineTerminator()) {
this.resetPreviousNodeTrailingComments(x);
let C = this.eat(55);
f.optional && this.unexpected(N), u.kind = "method";
let I = this.match(139);
this.parseClassElementName(u), this.parsePostMemberNameModifiers(f), I ? this.pushClassPrivateMethod(t, n, C, !0) : (this.isNonstaticConstructor(r) && this.raise(p.ConstructorIsAsync, r.key), this.pushClassMethod(t, r, C, !0, !1, !1));
} else if ((A === "get" || A === "set") && !(this.match(55) && this.isLineTerminator())) {
this.resetPreviousNodeTrailingComments(x), u.kind = A;
let C = this.match(139);
this.parseClassElementName(r), C ? this.pushClassPrivateMethod(t, n, !1, !1) : (this.isNonstaticConstructor(r) && this.raise(p.ConstructorIsAccessor, r.key), this.pushClassMethod(t, r, !1, !1, !1, !1)), this.checkGetterSetterParams(r);
} else if (A === "accessor" && !this.isLineTerminator()) {
this.expectPlugin("decoratorAutoAccessors"), this.resetPreviousNodeTrailingComments(x);
let C = this.match(139);
this.parseClassElementName(o), this.pushClassAccessorProperty(t, l, C);
} else this.isLineTerminator() ? k ? this.pushClassPrivateProperty(t, h) : this.pushClassProperty(t, o) : this.unexpected();
}
parseClassElementName(t) {
let { type: e, value: s } = this.state;
if ((e === 132 || e === 134) && t.static && s === "prototype" && this.raise(p.StaticPrototype, this.state.startLoc), e === 139) {
s === "constructor" && this.raise(p.ConstructorClassPrivateField, this.state.startLoc);
let i = this.parsePrivateName();
return t.key = i, i;
}
return this.parsePropertyName(t), t.key;
}
parseClassStaticBlock(t, e) {
this.scope.enter(720);
let s = this.state.labels;
this.state.labels = [], this.prodParam.enter(0);
let i = e.body = [];
this.parseBlockOrModuleBlockBody(i, void 0, !1, 8), this.prodParam.exit(), this.scope.exit(), this.state.labels = s, t.body.push(this.finishNode(e, "StaticBlock")), e.decorators?.length && this.raise(p.DecoratorStaticBlock, e);
}
pushClassProperty(t, e) {
!e.computed && this.nameIsConstructor(e.key) && this.raise(p.ConstructorClassField, e.key), t.body.push(this.parseClassProperty(e));
}
pushClassPrivateProperty(t, e) {
let s = this.parseClassPrivateProperty(e);
t.body.push(s), this.classScope.declarePrivateName(this.getPrivateNameSV(s.key), 0, s.key.loc.start);
}
pushClassAccessorProperty(t, e, s) {
!s && !e.computed && this.nameIsConstructor(e.key) && this.raise(p.ConstructorClassField, e.key);
let i = this.parseClassAccessorProperty(e);
t.body.push(i), s && this.classScope.declarePrivateName(this.getPrivateNameSV(i.key), 0, i.key.loc.start);
}
pushClassMethod(t, e, s, i, r, n) {
t.body.push(this.parseMethod(e, s, i, r, n, "ClassMethod", !0));
}
pushClassPrivateMethod(t, e, s, i) {
let r = this.parseMethod(e, s, i, !1, !1, "ClassPrivateMethod", !0);
t.body.push(r);
let n = r.kind === "get" ? r.static ? 6 : 2 : r.kind === "set" ? r.static ? 5 : 1 : 0;
this.declareClassPrivateMethodInScope(r, n);
}
declareClassPrivateMethodInScope(t, e) {
this.classScope.declarePrivateName(this.getPrivateNameSV(t.key), e, t.key.loc.start);
}
parsePostMemberNameModifiers(t) {
}
parseClassPrivateProperty(t) {
return this.parseInitializer(t), this.semicolon(), this.finishNode(t, "ClassPrivateProperty");
}
parseClassProperty(t) {
return this.parseInitializer(t), this.semicolon(), this.finishNode(t, "ClassProperty");
}
parseClassAccessorProperty(t) {
return this.parseInitializer(t), this.semicolon(), this.finishNode(t, "ClassAccessorProperty");
}
parseInitializer(t) {
this.scope.enter(592), this.expressionScope.enter(as()), this.prodParam.enter(0), t.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null, this.expressionScope.exit(), this.prodParam.exit(), this.scope.exit();
}
parseClassId(t, e, s, i = 8331) {
if (w(this.state.type)) t.id = this.parseIdentifier(), e && this.declareNameFromIdentifier(t.id, i);
else if (s || !e) t.id = null;
else throw this.raise(p.MissingClassName, this.state.startLoc);
}
parseClassSuper(t) {
t.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
}
parseExport(t, e) {
let s = this.parseMaybeImportPhase(t, !0), i = this.maybeParseExportDefaultSpecifier(t, s), r = !i || this.eat(12), n = r && this.eatExportStar(t), o = n && this.maybeParseExportNamespaceSpecifier(t), h = r && (!o || this.eat(12)), l = i || n;
if (n && !o) {
if (i && this.unexpected(), e) throw this.raise(p.UnsupportedDecoratorExport, t);
return this.parseExportFrom(t, !0), this.sawUnambiguousESM = !0, this.finishNode(t, "ExportAllDeclaration");
}
let u = this.maybeParseExportNamedSpecifiers(t);
i && r && !n && !u && this.unexpected(null, 5), o && h && this.unexpected(null, 98);
let f;
if (l || u) {
if (f = !1, e) throw this.raise(p.UnsupportedDecoratorExport, t);
this.parseExportFrom(t, l);
} else f = this.maybeParseExportDeclaration(t);
if (l || u || f) {
let d = t;
if (this.checkExport(d, !0, !1, !!d.source), d.declaration?.type === "ClassDeclaration") this.maybeTakeDecorators(e, d.declaration, d);
else if (e) throw this.raise(p.UnsupportedDecoratorExport, t);
return this.sawUnambiguousESM = !0, this.finishNode(d, "ExportNamedDeclaration");
}
if (this.eat(65)) {
let d = t, x = this.parseExportDefaultExpression();
if (d.declaration = x, x.type === "ClassDeclaration") this.maybeTakeDecorators(e, x, d);
else if (e) throw this.raise(p.UnsupportedDecoratorExport, t);
return this.checkExport(d, !0, !0), this.sawUnambiguousESM = !0, this.finishNode(d, "ExportDefaultDeclaration");
}
throw this.unexpected(null, 5);
}
eatExportStar(t) {
return this.eat(55);
}
maybeParseExportDefaultSpecifier(t, e) {
if (e || this.isExportDefaultSpecifier()) {
this.expectPlugin("exportDefaultFrom", e?.loc.start);
let s = e || this.parseIdentifier(!0), i = this.startNodeAtNode(s);
return i.exported = s, t.specifiers = [this.finishNode(i, "ExportDefaultSpecifier")], !0;
}
return !1;
}
maybeParseExportNamespaceSpecifier(t) {
if (this.isContextual(93)) {
t.specifiers ?? (t.specifiers = []);
let e = this.startNodeAt(this.state.lastTokStartLoc);
return this.next(), e.exported = this.parseModuleExportName(), t.specifiers.push(this.finishNode(e, "ExportNamespaceSpecifier")), !0;
}
return !1;
}
maybeParseExportNamedSpecifiers(t) {
if (this.match(5)) {
let e = t;
e.specifiers || (e.specifiers = []);
let s = e.exportKind === "type";
return e.specifiers.push(...this.parseExportSpecifiers(s)), e.source = null, e.attributes = [], e.declaration = null, !0;
}
return !1;
}
maybeParseExportDeclaration(t) {
return this.shouldParseExportDeclaration() ? (t.specifiers = [], t.source = null, t.attributes = [], t.declaration = this.parseExportDeclaration(t), !0) : !1;
}
isAsyncFunction() {
if (!this.isContextual(95)) return !1;
let t = this.nextTokenInLineStart();
return this.isUnparsedContextual(t, "function");
}
parseExportDefaultExpression() {
let t = this.startNode();
if (this.match(68)) return this.next(), this.parseFunction(t, 5);
if (this.isAsyncFunction()) return this.next(), this.next(), this.parseFunction(t, 13);
if (this.match(80)) return this.parseClass(t, !0, !0);
if (this.match(26)) return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === !0 && this.raise(p.DecoratorBeforeExport, this.state.startLoc), this.parseClass(this.maybeTakeDecorators(this.parseDecorators(!1), this.startNode()), !0, !0);
if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) throw this.raise(p.UnsupportedDefaultExport, this.state.startLoc);
let e = this.parseMaybeAssignAllowIn();
return this.semicolon(), e;
}
parseExportDeclaration(t) {
return this.match(80) ? this.parseClass(this.startNode(), !0, !1) : this.parseStatementListItem();
}
isExportDefaultSpecifier() {
let { type: t } = this.state;
if (w(t)) {
if (t === 95 && !this.state.containsEsc || t === 100) return !1;
if ((t === 130 || t === 129) && !this.state.containsEsc) {
let i = this.nextTokenStart(), r = this.input.charCodeAt(i);
if (r === 123 || this.chStartsBindingIdentifier(r, i) && !this.input.startsWith("from", i)) return this.expectOnePlugin(["flow", "typescript"]), !1;
}
} else if (!this.match(65)) return !1;
let e = this.nextTokenStart(), s = this.isUnparsedContextual(e, "from");
if (this.input.charCodeAt(e) === 44 || w(this.state.type) && s) return !0;
if (this.match(65) && s) {
let i = this.input.charCodeAt(this.nextTokenStartSince(e + 4));
return i === 34 || i === 39;
}
return !1;
}
parseExportFrom(t, e) {
this.eatContextual(98) ? (t.source = this.parseImportSource(), this.checkExport(t), this.maybeParseImportAttributes(t), this.checkJSONModuleImport(t)) : e && this.unexpected(), this.semicolon();
}
shouldParseExportDeclaration() {
let { type: t } = this.state;
return t === 26 && (this.expectOnePlugin(["decorators", "decorators-legacy"]), this.hasPlugin("decorators")) ? (this.getPluginOption("decorators", "decoratorsBeforeExport") === !0 && this.raise(p.DecoratorBeforeExport, this.state.startLoc), !0) : this.isUsing() ? (this.raise(p.UsingDeclarationExport, this.state.startLoc), !0) : this.isAwaitUsing() ? (this.raise(p.UsingDeclarationExport, this.state.startLoc), !0) : t === 74 || t === 75 || t === 68 || t === 80 || this.isLet() || this.isAsyncFunction();
}
checkExport(t, e, s, i) {
if (e) {
if (s) {
if (this.checkDuplicateExports(t, "default"), this.hasPlugin("exportDefaultFrom")) {
let r = t.declaration;
r.type === "Identifier" && r.name === "from" && r.end - r.start === 4 && !r.extra?.parenthesized && this.raise(p.ExportDefaultFromAsIdentifier, r);
}
} else if (t.specifiers?.length) for (let r of t.specifiers) {
let { exported: n } = r, o = n.type === "Identifier" ? n.name : n.value;
if (this.checkDuplicateExports(r, o), !i && r.local) {
let { local: h } = r;
h.type !== "Identifier" ? this.raise(p.ExportBindingIsString, r, { localName: h.value, exportName: o }) : (this.checkReservedWord(h.name, h.loc.start, !0, !1), this.scope.checkLocalExport(h));
}
}
else if (t.declaration) {
let r = t.declaration;
if (r.type === "FunctionDeclaration" || r.type === "ClassDeclaration") {
let { id: n } = r;
if (!n) throw new Error("Assertion failure");
this.checkDuplicateExports(t, n.name);
} else if (r.type === "VariableDeclaration") for (let n of r.declarations) this.checkDeclaration(n.id);
}
}
}
checkDeclaration(t) {
if (t.type === "Identifier") this.checkDuplicateExports(t, t.name);
else if (t.type === "ObjectPattern") for (let e of t.properties) this.checkDeclaration(e);
else if (t.type === "ArrayPattern") for (let e of t.elements) e && this.checkDeclaration(e);
else t.type === "ObjectProperty" ? this.checkDeclaration(t.value) : t.type === "RestElement" ? this.checkDeclaration(t.argument) : t.type === "AssignmentPattern" && this.checkDeclaration(t.left);
}
checkDuplicateExports(t, e) {
this.exportedIdentifiers.has(e) && (e === "default" ? this.raise(p.DuplicateDefaultExport, t) : this.raise(p.DuplicateExport, t, { exportName: e })), this.exportedIdentifiers.add(e);
}
parseExportSpecifiers(t) {
let e = [], s = !0;
for (this.expect(5); !this.eat(8); ) {
if (s) s = !1;
else if (this.expect(12), this.eat(8)) break;
let i = this.isContextual(130), r = this.match(134), n = this.startNode();
n.local = this.parseModuleExportName(), e.push(this.parseExportSpecifier(n, r, t, i));
}
return e;
}
parseExportSpecifier(t, e, s, i) {
return this.eatContextual(93) ? t.exported = this.parseModuleExportName() : e ? t.exported = this.cloneStringLiteral(t.local) : t.exported || (t.exported = this.cloneIdentifier(t.local)), this.finishNode(t, "ExportSpecifier");
}
parseModuleExportName() {
if (this.match(134)) {
let t = this.parseStringLiteral(this.state.value), e = ir.exec(t.value);
return e && this.raise(p.ModuleExportNameHasLoneSurrogate, t, { surrogateCharCode: e[0].charCodeAt(0) }), t;
}
return this.parseIdentifier(!0);
}
isJSONModuleImport(t) {
return t.assertions != null ? t.assertions.some(({ key: e, value: s }) => s.value === "json" && (e.type === "Identifier" ? e.name === "type" : e.value === "type")) : !1;
}
checkImportReflection(t) {
let { specifiers: e } = t, s = e.length === 1 ? e[0].type : null;
t.phase === "source" ? s !== "ImportDefaultSpecifier" && this.raise(p.SourcePhaseImportRequiresDefault, e[0].loc.start) : t.phase === "defer" ? s !== "ImportNamespaceSpecifier" && this.raise(p.DeferImportRequiresNamespace, e[0].loc.start) : t.module && (s !== "ImportDefaultSpecifier" && this.raise(p.ImportReflectionNotBinding, e[0].loc.start), t.assertions?.length > 0 && this.raise(p.ImportReflectionHasAssertion, e[0].loc.start));
}
checkJSONModuleImport(t) {
if (this.isJSONModuleImport(t) && t.type !== "ExportAllDeclaration") {
let { specifiers: e } = t;
if (e != null) {
let s = e.find((i) => {
let r;
if (i.type === "ExportSpecifier" ? r = i.local : i.type === "ImportSpecifier" && (r = i.imported), r !== void 0) return r.type === "Identifier" ? r.name !== "default" : r.value !== "default";
});
s !== void 0 && this.raise(p.ImportJSONBindingNotDefault, s.loc.start);
}
}
}
isPotentialImportPhase(t) {
return t ? !1 : this.isContextual(105) || this.isContextual(97);
}
applyImportPhase(t, e, s, i) {
e || (this.hasPlugin("importReflection") && (t.module = !1), s === "source" ? (this.expectPlugin("sourcePhaseImports", i), t.phase = "source") : s === "defer" ? (this.expectPlugin("deferredImportEvaluation", i), t.phase = "defer") : this.hasPlugin("sourcePhaseImports") && (t.phase = null));
}
parseMaybeImportPhase(t, e) {
if (!this.isPotentialImportPhase(e)) return this.applyImportPhase(t, e, null), null;
let s = this.startNode(), i = this.parseIdentifierName(!0), { type: r } = this.state;
return (O(r) ? r !== 98 || this.lookaheadCharCode() === 102 : r !== 12) ? (this.applyImportPhase(t, e, i, s.loc.start), null) : (this.applyImportPhase(t, e, null), this.createIdentifier(s, i));
}
isPrecedingIdImportPhase(t) {
let { type: e } = this.state;
return w(e) ? e !== 98 || this.lookaheadCharCode() === 102 : e !== 12;
}
parseImport(t) {
return this.match(134) ? this.parseImportSourceAndAttributes(t) : this.parseImportSpecifiersAndAfter(t, this.parseMaybeImportPhase(t, !1));
}
parseImportSpecifiersAndAfter(t, e) {
t.specifiers = [];
let i = !this.maybeParseDefaultImportSpecifier(t, e) || this.eat(12), r = i && this.maybeParseStarImportSpecifier(t);
return i && !r && this.parseNamedImportSpecifiers(t), this.expectContextual(98), this.parseImportSourceAndAttributes(t);
}
parseImportSourceAndAttributes(t) {
return t.specifiers ?? (t.specifiers = []), t.source = this.parseImportSource(), this.maybeParseImportAttributes(t), this.checkImportReflection(t), this.checkJSONModuleImport(t), this.semicolon(), this.sawUnambiguousESM = !0, this.finishNode(t, "ImportDeclaration");
}
parseImportSource() {
return this.match(134) || this.unexpected(), this.parseExprAtom();
}
parseImportSpecifierLocal(t, e, s) {
e.local = this.parseIdentifier(), t.specifiers.push(this.finishImportSpecifier(e, s));
}
finishImportSpecifier(t, e, s = 8201) {
return this.checkLVal(t.local, { type: e }, s), this.finishNode(t, e);
}
parseImportAttributes() {
this.expect(5);
let t = [], e = /* @__PURE__ */ new Set();
do {
if (this.match(8)) break;
let s = this.startNode(), i = this.state.value;
if (e.has(i) && this.raise(p.ModuleAttributesWithDuplicateKeys, this.state.startLoc, { key: i }), e.add(i), this.match(134) ? s.key = this.parseStringLiteral(i) : s.key = this.parseIdentifier(!0), this.expect(14), !this.match(134)) throw this.raise(p.ModuleAttributeInvalidValue, this.state.startLoc);
s.value = this.parseStringLiteral(this.state.value), t.push(this.finishNode(s, "ImportAttribute"));
} while (this.eat(12));
return this.expect(8), t;
}
parseModuleAttributes() {
let t = [], e = /* @__PURE__ */ new Set();
do {
let s = this.startNode();
if (s.key = this.parseIdentifier(!0), s.key.name !== "type" && this.raise(p.ModuleAttributeDifferentFromType, s.key), e.has(s.key.name) && this.raise(p.ModuleAttributesWithDuplicateKeys, s.key, { key: s.key.name }), e.add(s.key.name), this.expect(14), !this.match(134)) throw this.raise(p.ModuleAttributeInvalidValue, this.state.startLoc);
s.value = this.parseStringLiteral(this.state.value), t.push(this.finishNode(s, "ImportAttribute"));
} while (this.eat(12));
return t;
}
maybeParseImportAttributes(t) {
let e;
if (this.match(76)) {
if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) return;
this.next(), e = this.parseImportAttributes();
} else this.isContextual(94) && !this.hasPrecedingLineBreak() ? (this.hasPlugin("deprecatedImportAssert") || this.raise(p.ImportAttributesUseAssert, this.state.startLoc), this.addExtra(t, "deprecatedAssertSyntax", !0), this.next(), e = this.parseImportAttributes()) : e = [];
t.attributes = e;
}
maybeParseDefaultImportSpecifier(t, e) {
if (e) {
let s = this.startNodeAtNode(e);
return s.local = e, t.specifiers.push(this.finishImportSpecifier(s, "ImportDefaultSpecifier")), !0;
} else if (O(this.state.type)) return this.parseImportSpecifierLocal(t, this.startNode(), "ImportDefaultSpecifier"), !0;
return !1;
}
maybeParseStarImportSpecifier(t) {
if (this.match(55)) {
let e = this.startNode();
return this.next(), this.expectContextual(93), this.parseImportSpecifierLocal(t, e, "ImportNamespaceSpecifier"), !0;
}
return !1;
}
parseNamedImportSpecifiers(t) {
let e = !0;
for (this.expect(5); !this.eat(8); ) {
if (e) e = !1;
else {
if (this.eat(14)) throw this.raise(p.DestructureNamedImport, this.state.startLoc);
if (this.expect(12), this.eat(8)) break;
}
let s = this.startNode(), i = this.match(134), r = this.isContextual(130);
s.imported = this.parseModuleExportName();
let n = this.parseImportSpecifier(s, i, t.importKind === "type" || t.importKind === "typeof", r, void 0);
t.specifiers.push(n);
}
}
parseImportSpecifier(t, e, s, i, r) {
if (this.eatContextual(93)) t.local = this.parseIdentifier();
else {
let { imported: n } = t;
if (e) throw this.raise(p.ImportBindingIsString, t, { importName: n.value });
this.checkReservedWord(n.name, t.loc.start, !0, !0), t.local || (t.local = this.cloneIdentifier(n));
}
return this.finishImportSpecifier(t, "ImportSpecifier", r);
}
isThisParam(t) {
return t.type === "Identifier" && t.name === "this";
}
}, Ee = class extends ut {
constructor(t, e, s) {
let i = ii(t);
super(i, e), this.options = i, this.initializeScopes(), this.plugins = s, this.filename = i.sourceFilename, this.startIndex = i.startIndex;
let r = 0;
i.allowAwaitOutsideFunction && (r |= 1), i.allowReturnOutsideFunction && (r |= 2), i.allowImportExportEverywhere && (r |= 8), i.allowSuperOutsideMethod && (r |= 16), i.allowUndeclaredExports && (r |= 64), i.allowNewTargetOutsideFunction && (r |= 4), i.allowYieldOutsideFunction && (r |= 32), i.ranges && (r |= 128), i.tokens && (r |= 256), i.createImportExpressions && (r |= 512), i.createParenthesizedExpressions && (r |= 1024), i.errorRecovery && (r |= 2048), i.attachComment && (r |= 4096), i.annexB && (r |= 8192), this.optionFlags = r;
}
getScopeHandler() {
return fe;
}
parse() {
this.enterInitialScopes();
let t = this.startNode(), e = this.startNode();
this.nextToken(), t.errors = null;
let s = this.parseTopLevel(t, e);
return s.errors = this.state.errors, s.comments.length = this.state.commentsLen, s;
}
};
ua = ar(oi);
Wt = /* @__PURE__ */ new Map();
da = ke(/\s/u), cs = ke(" "), ma = ke(",; "), ls = ke(/[^\n\r]/u);
ps = or, us = (a2) => a2 === `
` || a2 === "\r" || a2 === "\u2028" || a2 === "\u2029";
fs = hr;
ds = cr;
ms = lr;
ve = pr, ee = (a2, t) => (e, s, ...i) => e | 1 && s == null ? void 0 : (t.call(s) ?? s[a2]).apply(s, i), ur = Array.prototype.findLast ?? function(a2) {
for (let t = this.length - 1; t >= 0; t--) {
let e = this[t];
if (a2(e, t, this)) return e;
}
}, fr = ee("findLast", function() {
if (Array.isArray(this)) return ur;
}), xs = fr;
mr = ee("at", function() {
if (Array.isArray(this) || typeof this == "string") return dr;
}), Ps = mr;
te = yr, xr = te(["Block", "CommentBlock", "MultiLine"]), se = xr, Pr = te(["Line", "CommentLine", "SingleLine", "HashbangComment", "HTMLOpen", "HTMLClose", "Hashbang", "InterpreterDirective"]), gs = Pr, St = /* @__PURE__ */ new WeakMap();
Ts = gr;
wt = /* @__PURE__ */ new WeakMap();
Ct = br;
bs = Ar;
As = Sr, me = null;
wr = 10;
for (let a2 = 0; a2 <= wr; a2++) ye();
Ss = Cr, c = [["decorators", "key", "typeAnnotation", "value"], [], ["elementType"], ["expression"], ["expression", "typeAnnotation"], ["left", "right"], ["argument"], ["directives", "body"], ["label"], ["callee", "typeArguments", "arguments"], ["body"], ["decorators", "id", "typeParameters", "superClass", "superTypeArguments", "mixins", "implements", "body", "superTypeParameters"], ["id", "typeParameters"], ["decorators", "key", "typeParameters", "params", "returnType", "body"], ["decorators", "variance", "key", "typeAnnotation", "value"], ["name", "typeAnnotation"], ["test", "consequent", "alternate"], ["checkType", "extendsType", "trueType", "falseType"], ["value"], ["id", "body"], ["declaration", "specifiers", "source", "attributes"], ["id"], ["id", "typeParameters", "extends", "body"], ["typeAnnotation"], ["id", "typeParameters", "right"], ["body", "test"], ["members"], ["id", "init"], ["exported"], ["left", "right", "body"], ["id", "typeParameters", "params", "predicate", "returnType", "body"], ["id", "params", "body", "typeParameters", "returnType"], ["key", "value"], ["local"], ["objectType", "indexType"], ["typeParameter"], ["types"], ["node"], ["object", "property"], ["argument", "cases"], ["pattern", "body", "guard"], ["literal"], ["decorators", "key", "value"], ["expressions"], ["qualification", "id"], ["decorators", "key", "typeAnnotation"], ["typeParameters", "params", "returnType"], ["expression", "typeArguments"], ["params"], ["parameterName", "typeAnnotation"]], ws = { AccessorProperty: c[0], AnyTypeAnnotation: c[1], ArgumentPlaceholder: c[1], ArrayExpression: ["elements"], ArrayPattern: ["elements", "typeAnnotation", "decorators"], ArrayTypeAnnotation: c[2], ArrowFunctionExpression: ["typeParameters", "params", "predicate", "returnType", "body"], AsConstExpression: c[3], AsExpression: c[4], AssignmentExpression: c[5], AssignmentPattern: ["left", "right", "decorators", "typeAnnotation"], AwaitExpression: c[6], BigIntLiteral: c[1], BigIntLiteralTypeAnnotation: c[1], BigIntTypeAnnotation: c[1], BinaryExpression: c[5], BindExpression: ["object", "callee"], BlockStatement: c[7], BooleanLiteral: c[1], BooleanLiteralTypeAnnotation: c[1], BooleanTypeAnnotation: c[1], BreakStatement: c[8], CallExpression: c[9], CatchClause: ["param", "body"], ChainExpression: c[3], ClassAccessorProperty: c[0], ClassBody: c[10], ClassDeclaration: c[11], ClassExpression: c[11], ClassImplements: c[12], ClassMethod: c[13], ClassPrivateMethod: c[13], ClassPrivateProperty: c[14], ClassProperty: c[14], ComponentDeclaration: ["id", "params", "body", "typeParameters", "rendersType"], ComponentParameter: ["name", "local"], ComponentTypeAnnotation: ["params", "rest", "typeParameters", "rendersType"], ComponentTypeParameter: c[15], ConditionalExpression: c[16], ConditionalTypeAnnotation: c[17], ContinueStatement: c[8], DebuggerStatement: c[1], DeclareClass: ["id", "typeParameters", "extends", "mixins", "implements", "body"], DeclareComponent: ["id", "params", "rest", "typeParameters", "rendersType"], DeclaredPredicate: c[18], DeclareEnum: c[19], DeclareExportAllDeclaration: ["source", "attributes"], DeclareExportDeclaration: c[20], DeclareFunction: ["id", "predicate"], DeclareHook: c[21], DeclareInterface: c[22], DeclareModule: c[19], DeclareModuleExports: c[23], DeclareNamespace: c[19], DeclareOpaqueType: ["id", "typeParameters", "supertype", "lowerBound", "upperBound"], DeclareTypeAlias: c[24], DeclareVariable: c[21], Decorator: c[3], Directive: c[18], DirectiveLiteral: c[1], DoExpression: c[10], DoWhileStatement: c[25], EmptyStatement: c[1], EmptyTypeAnnotation: c[1], EnumBigIntBody: c[26], EnumBigIntMember: c[27], EnumBooleanBody: c[26], EnumBooleanMember: c[27], EnumDeclaration: c[19], EnumDefaultedMember: c[21], EnumNumberBody: c[26], EnumNumberMember: c[27], EnumStringBody: c[26], EnumStringMember: c[27], EnumSymbolBody: c[26], ExistsTypeAnnotation: c[1], ExperimentalRestProperty: c[6], ExperimentalSpreadProperty: c[6], ExportAllDeclaration: ["source", "attributes", "exported"], ExportDefaultDeclaration: ["declaration"], ExportDefaultSpecifier: c[28], ExportNamedDeclaration: c[20], ExportNamespaceSpecifier: c[28], ExportSpecifier: ["local", "exported"], ExpressionStatement: c[3], File: ["program"], ForInStatement: c[29], ForOfStatement: c[29], ForStatement: ["init", "test", "update", "body"], FunctionDeclaration: c[30], FunctionExpression: c[30], FunctionTypeAnnotation: ["typeParameters", "this", "params", "rest", "returnType"], FunctionTypeParam: c[15], GenericTypeAnnotation: c[12], HookDeclaration: c[31], HookTypeAnnotation: ["params", "returnType", "rest", "typeParameters"], Identifier: ["typeAnnotation", "decorators"], IfStatement: c[16], ImportAttribute: c[32], ImportDeclaration: ["specifiers", "source", "attributes"], ImportDefaultSpecifier: c[33], ImportExpression: ["source", "options"], ImportNamespaceSpecifier: c[33], ImportSpecifier: ["imported", "local"], IndexedAccessType: c[34], InferredPredicate: c[1], InferTypeAnnotation: c[35], InterfaceDeclaration: c[22], InterfaceExtends: c[12], InterfaceTypeAnnotation: ["extends", "body"], InterpreterDirective: c[1], IntersectionTypeAnnotation: c[36], JsExpressionRoot: c[37], JsonRoot: c[37], JSXAttribute: ["name", "value"], JSXClosingElement: ["name"], JSXClosingFragment: c[1], JSXElement: ["openingElement", "children", "closingElement"], JSXEmptyExpression: c[1], JSXExpressionContainer: c[3], JSXFragment: ["openingFragment", "children", "closingFragment"], JSXIdentifier: c[1], JSXMemberExpression: c[38], JSXNamespacedName: ["namespace", "name"], JSXOpeningElement: ["name", "typeArguments", "attributes"], JSXOpeningFragment: c[1], JSXSpreadAttribute: c[6], JSXSpreadChild: c[3], JSXText: c[1], KeyofTypeAnnotation: c[6], LabeledStatement: ["label", "body"], Literal: c[1], LogicalExpression: c[5], MatchArrayPattern: ["elements", "rest"], MatchAsPattern: ["pattern", "target"], MatchBindingPattern: c[21], MatchExpression: c[39], MatchExpressionCase: c[40], MatchIdentifierPattern: c[21], MatchLiteralPattern: c[41], MatchMemberPattern: ["base", "property"], MatchObjectPattern: ["properties", "rest"], MatchObjectPatternProperty: ["key", "pattern"], MatchOrPattern: ["patterns"], MatchRestPattern: c[6], MatchStatement: c[39], MatchStatementCase: c[40], MatchUnaryPattern: c[6], MatchWildcardPattern: c[1], MemberExpression: c[38], MetaProperty: ["meta", "property"], MethodDefinition: c[42], MixedTypeAnnotation: c[1], ModuleExpression: c[10], NeverTypeAnnotation: c[1], NewExpression: c[9], NGChainedExpression: c[43], NGEmptyExpression: c[1], NGMicrosyntax: c[10], NGMicrosyntaxAs: ["key", "alias"], NGMicrosyntaxExpression: ["expression", "alias"], NGMicrosyntaxKey: c[1], NGMicrosyntaxKeyedExpression: ["key", "expression"], NGMicrosyntaxLet: c[32], NGPipeExpression: ["left", "right", "arguments"], NGRoot: c[37], NullableTypeAnnotation: c[23], NullLiteral: c[1], NullLiteralTypeAnnotation: c[1], NumberLiteralTypeAnnotation: c[1], NumberTypeAnnotation: c[1], NumericLiteral: c[1], ObjectExpression: ["properties"], ObjectMethod: c[13], ObjectPattern: ["decorators", "properties", "typeAnnotation"], ObjectProperty: c[42], ObjectTypeAnnotation: ["properties", "indexers", "callProperties", "internalSlots"], ObjectTypeCallProperty: c[18], ObjectTypeIndexer: ["variance", "id", "key", "value"], ObjectTypeInternalSlot: ["id", "value"], ObjectTypeMappedTypeProperty: ["keyTparam", "propType", "sourceType", "variance"], ObjectTypeProperty: ["key", "value", "variance"], ObjectTypeSpreadProperty: c[6], OpaqueType: ["id", "typeParameters", "supertype", "impltype", "lowerBound", "upperBound"], OptionalCallExpression: c[9], OptionalIndexedAccessType: c[34], OptionalMemberExpression: c[38], ParenthesizedExpression: c[3], PipelineBareFunction: ["callee"], PipelinePrimaryTopicReference: c[1], PipelineTopicExpression: c[3], Placeholder: c[1], PrivateIdentifier: c[1], PrivateName: c[21], Program: c[7], Property: c[32], PropertyDefinition: c[14], QualifiedTypeIdentifier: c[44], QualifiedTypeofIdentifier: c[44], RegExpLiteral: c[1], RestElement: ["argument", "typeAnnotation", "decorators"], ReturnStatement: c[6], SatisfiesExpression: c[4], SequenceExpression: c[43], SpreadElement: c[6], StaticBlock: c[10], StringLiteral: c[1], StringLiteralTypeAnnotation: c[1], StringTypeAnnotation: c[1], Super: c[1], SwitchCase: ["test", "consequent"], SwitchStatement: ["discriminant", "cases"], SymbolTypeAnnotation: c[1], TaggedTemplateExpression: ["tag", "typeArguments", "quasi"], TemplateElement: c[1], TemplateLiteral: ["quasis", "expressions"], ThisExpression: c[1], ThisTypeAnnotation: c[1], ThrowStatement: c[6], TopicReference: c[1], TryStatement: ["block", "handler", "finalizer"], TSAbstractAccessorProperty: c[45], TSAbstractKeyword: c[1], TSAbstractMethodDefinition: c[32], TSAbstractPropertyDefinition: c[45], TSAnyKeyword: c[1], TSArrayType: c[2], TSAsExpression: c[4], TSAsyncKeyword: c[1], TSBigIntKeyword: c[1], TSBooleanKeyword: c[1], TSCallSignatureDeclaration: c[46], TSClassImplements: c[47], TSConditionalType: c[17], TSConstructorType: c[46], TSConstructSignatureDeclaration: c[46], TSDeclareFunction: c[31], TSDeclareKeyword: c[1], TSDeclareMethod: ["decorators", "key", "typeParameters", "params", "returnType"], TSEmptyBodyFunctionExpression: ["id", "typeParameters", "params", "returnType"], TSEnumBody: c[26], TSEnumDeclaration: c[19], TSEnumMember: ["id", "initializer"], TSExportAssignment: c[3], TSExportKeyword: c[1], TSExternalModuleReference: c[3], TSFunctionType: c[46], TSImportEqualsDeclaration: ["id", "moduleReference"], TSImportType: ["options", "qualifier", "typeArguments", "source"], TSIndexedAccessType: c[34], TSIndexSignature: ["parameters", "typeAnnotation"], TSInferType: c[35], TSInstantiationExpression: c[47], TSInterfaceBody: c[10], TSInterfaceDeclaration: c[22], TSInterfaceHeritage: c[47], TSIntersectionType: c[36], TSIntrinsicKeyword: c[1], TSJSDocAllType: c[1], TSJSDocNonNullableType: c[23], TSJSDocNullableType: c[23], TSJSDocUnknownType: c[1], TSLiteralType: c[41], TSMappedType: ["key", "constraint", "nameType", "typeAnnotation"], TSMethodSignature: ["key", "typeParameters", "params", "returnType"], TSModuleBlock: c[10], TSModuleDeclaration: c[19], TSNamedTupleMember: ["label", "elementType"], TSNamespaceExportDeclaration: c[21], TSNeverKeyword: c[1], TSNonNullExpression: c[3], TSNullKeyword: c[1], TSNumberKeyword: c[1], TSObjectKeyword: c[1], TSOptionalType: c[23], TSParameterProperty: ["parameter", "decorators"], TSParenthesizedType: c[23], TSPrivateKeyword: c[1], TSPropertySignature: ["key", "typeAnnotation"], TSProtectedKeyword: c[1], TSPublicKeyword: c[1], TSQualifiedName: c[5], TSReadonlyKeyword: c[1], TSRestType: c[23], TSSatisfiesExpression: c[4], TSStaticKeyword: c[1], TSStringKeyword: c[1], TSSymbolKeyword: c[1], TSTemplateLiteralType: ["quasis", "types"], TSThisType: c[1], TSTupleType: ["elementTypes"], TSTypeAliasDeclaration: ["id", "typeParameters", "typeAnnotation"], TSTypeAnnotation: c[23], TSTypeAssertion: c[4], TSTypeLiteral: c[26], TSTypeOperator: c[23], TSTypeParameter: ["name", "constraint", "default"], TSTypeParameterDeclaration: c[48], TSTypeParameterInstantiation: c[48], TSTypePredicate: c[49], TSTypeQuery: ["exprName", "typeArguments"], TSTypeReference: ["typeName", "typeArguments"], TSUndefinedKeyword: c[1], TSUnionType: c[36], TSUnknownKeyword: c[1], TSVoidKeyword: c[1], TupleTypeAnnotation: ["types", "elementTypes"], TupleTypeLabeledElement: ["label", "elementType", "variance"], TupleTypeSpreadElement: ["label", "typeAnnotation"], TypeAlias: c[24], TypeAnnotation: c[23], TypeCastExpression: c[4], TypeofTypeAnnotation: ["argument", "typeArguments"], TypeOperator: c[23], TypeParameter: ["bound", "default", "variance"], TypeParameterDeclaration: c[48], TypeParameterInstantiation: c[48], TypePredicate: c[49], UnaryExpression: c[6], UndefinedTypeAnnotation: c[1], UnionTypeAnnotation: c[36], UnknownTypeAnnotation: c[1], UpdateExpression: c[6], V8IntrinsicIdentifier: c[1], VariableDeclaration: ["declarations"], VariableDeclarator: c[27], Variance: c[1], VoidPattern: c[1], VoidTypeAnnotation: c[1], WhileStatement: c[25], WithStatement: ["object", "body"], YieldExpression: c[6] }, Er = Ss(ws), Cs = Er;
Es = Le, fn = te(["RegExpLiteral", "BigIntLiteral", "NumericLiteral", "StringLiteral", "DirectiveLiteral", "Literal", "JSXText", "TemplateElement", "StringLiteralTypeAnnotation", "NumberLiteralTypeAnnotation", "BigIntLiteralTypeAnnotation"]);
Ns = Ir;
De = Nr, ks = "Unexpected parseExpression() input: ";
Me = kr, vr = String.prototype.replaceAll ?? function(a2, t) {
return a2.global ? this.replace(a2, t) : this.split(a2).join(t);
}, Lr = ee("replaceAll", function() {
if (typeof this == "string") return vr;
}), xe = Lr, Dr = /\*\/$/, Mr = /^\/\*\*?/, Or = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, Fr = /(^|\s+)\/\/([^\n\r]*)/g, vs = /^(\r?\n)+/, Br = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g, Ls = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g, Rr = /(\r?\n|^) *\* ?/g, Ur = [];
Os = ["noformat", "noprettier"], Fs = ["format", "prettier"];
H = _r, Oe = "module", Nt = "commonjs";
Fe = jr, ie = (a2) => H(Kr(a2)), Vr = { sourceType: Oe, allowImportExportEverywhere: !0, allowReturnOutsideFunction: !0, allowNewTargetOutsideFunction: !0, allowSuperOutsideMethod: !0, allowUndeclaredExports: !0, errorRecovery: !0, createParenthesizedExpressions: !0, attachComment: !1, plugins: ["doExpressions", "exportDefaultFrom", "functionBind", "functionSent", "throwExpressions", "partialApplication", "decorators", "moduleBlocks", "asyncDoExpressions", "destructuringPrivate", "decoratorAutoAccessors", "sourcePhaseImports", "deferredImportEvaluation", ["optionalChainingAssign", { version: "2023-07" }], ["discardBinding", { syntaxType: "void" }]], tokens: !1, ranges: !1 }, js = "v8intrinsic", Vs = [["pipelineOperator", { proposal: "hack", topicToken: "%" }], ["pipelineOperator", { proposal: "fsharp" }]], _ = (a2, t = Vr) => ({ ...t, plugins: [...t.plugins, ...a2] }), zr = /@(?:no)?flow\b/u;
Hr = /* @__PURE__ */ new Set(["StrictNumericEscape", "StrictWith", "StrictOctalLiteral", "StrictDelete", "StrictEvalArguments", "StrictEvalArgumentsBinding", "StrictFunction", "ForInOfLoopInitializer", "ConstructorHasTypeParameters", "UnsupportedParameterPropertyKind", "DecoratorExportClass", "ParamDupe", "InvalidDecimal", "RestTrailingComma", "UnsupportedParameterDecorator", "UnterminatedJsxContent", "UnexpectedReservedWord", "ModuleAttributesWithDuplicateKeys", "InvalidEscapeSequenceTemplate", "NonAbstractClassHasAbstractMethod", "OptionalTypeBeforeRequired", "PatternIsOptional", "DeclareClassFieldHasInitializer", "TypeImportCannotSpecifyDefaultAndNamed", "VarRedeclaration", "InvalidPrivateFieldResolution", "DuplicateExport", "ImportAttributesUseAssert", "DeclarationMissingInitializer"]), zs = [_(["jsx"])], Wr = ie({ optionsCombinations: zs }), Jr = ie({ optionsCombinations: [_(["jsx", "typescript"]), _(["typescript"])] }), Gr = ie({ isExpression: !0, optionsCombinations: [_(["jsx"])] }), Xr = ie({ isExpression: !0, optionsCombinations: [_(["typescript"])] }), qs = ie({ optionsCombinations: [_(["jsx", ["flow", { all: !0 }], "flowComments"])] }), Yr = ie({ optionsCombinations: zs.map((a2) => _(["estree"], a2)) }), Lt = {};
Re(Lt, { json: () => ea, "json-stringify": () => ia, json5: () => ta, jsonc: () => sa });
vt = Qr, $s = { tokens: !1, ranges: !1, attachComment: !1, createParenthesizedExpressions: !0 };
ea = H({ parse: (a2) => Be(a2), hasPragma: () => !0, hasIgnorePragma: () => !1 }), ta = H((a2) => Be(a2)), sa = H((a2) => Be(a2, { allowEmpty: !0 })), ia = H({ parse: (a2) => Be(a2, { allowComments: !1 }), astFormat: "estree-json" }), ra = { ...kt, ...Lt };
}
});
init_babel();
export {
Ks as default,
ra as parsers
};
//# sourceMappingURL=babel-KZNQAA3R.js.map