import { t as __exportAll } from "./chunk-DrSxFLj_.js";
//#region ../../node_modules/.pnpm/prettier@3.8.2/node_modules/prettier/plugins/babel.mjs
var babel_exports = /* @__PURE__ */ __exportAll({
	default: () => Ks,
	parsers: () => ra
});
var Hs = Object.defineProperty;
var Re = (a, t) => {
	for (var e in t) Hs(a, e, {
		get: t[e],
		enumerable: !0
	});
};
var Ks = {};
Re(Ks, { parsers: () => ra });
var 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
});
function Ws(a, t) {
	if (a == null) return {};
	var e = {};
	for (var s in a) if ({}.hasOwnProperty.call(a, s)) {
		if (t.indexOf(s) !== -1) continue;
		e[s] = a[s];
	}
	return e;
}
var 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;
	}
};
function D(a, t) {
	let { line: e, column: s, index: i } = a;
	return new R(e, s + t, i + t);
}
var 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 = (a) => a.type === "UpdateExpression" ? Mt.UpdateExpression[`${a.prefix}`] : Mt[a.type], Gs = {
	AccessorIsGenerator: ({ kind: a }) => `A ${a}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: a }) => `Missing initializer in ${a} 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: a }) => `\`${a}\` 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: a, exportName: t }) => `A string literal cannot be used as an exported binding without \`from\`.
- Did you mean \`export { '${a}' as '${t}' } from 'some-module'\`?`,
	ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
	ForInOfLoopInitializer: ({ type: a }) => `'${a === "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: a }) => `Unsyntactic ${a === "BreakStatement" ? "break" : "continue"}.`,
	IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
	IllegalReturn: "'return' outside of function.",
	ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.",
	ImportBindingIsString: ({ importName: a }) => `A string literal cannot be used as an imported binding.
- Did you mean \`import { "${a}" 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: a }) => `Expected number in radix ${a}.`,
	InvalidEscapeSequence: "Bad character escape sequence.",
	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
	InvalidEscapedReservedWord: ({ reservedWord: a }) => `Escape sequence in keyword ${a}.`,
	InvalidIdentifier: ({ identifierName: a }) => `Invalid identifier ${a}.`,
	InvalidLhs: ({ ancestor: a }) => `Invalid left-hand side in ${be(a)}.`,
	InvalidLhsBinding: ({ ancestor: a }) => `Binding invalid left-hand side in ${be(a)}.`,
	InvalidLhsOptionalChaining: ({ ancestor: a }) => `Invalid optional chaining in the left-hand side of ${be(a)}.`,
	InvalidNumber: "Invalid number.",
	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
	InvalidOrUnexpectedToken: ({ unexpected: a }) => `Unexpected character '${a}'.`,
	InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
	InvalidPrivateFieldResolution: ({ identifierName: a }) => `Private name #${a} 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: a }) => `Label '${a}' 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: a }) => `This experimental syntax requires enabling the parser plugin: ${a.map((t) => JSON.stringify(t)).join(", ")}.`,
	MissingOneOfPlugins: ({ missingPlugin: a }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${a.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: a }) => `Duplicate key "${a}" is not allowed in module attributes.`,
	ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode: a }) => `An export name cannot include a lone surrogate, found '\\u${a.toString(16)}'.`,
	ModuleExportUndefined: ({ localName: a }) => `Export '${a}' 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: a }) => `Private names are only allowed in property accesses (\`obj.#${a}\`) or in \`in\` expressions (\`#${a} in obj\`).`,
	PrivateNameRedeclaration: ({ identifierName: a }) => `Duplicate private name #${a}.`,
	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: a }) => `Unexpected keyword '${a}'.`,
	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: a }) => `Unexpected reserved word '${a}'.`,
	UnexpectedSuper: "'super' is only allowed in object methods and classes.",
	UnexpectedToken: ({ expected: a, unexpected: t }) => `Unexpected token${t ? ` '${t}'.` : ""}${a ? `, expected "${a}"` : ""}`,
	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: a, onlyValidPropertyName: t }) => `The only valid meta property for ${a} is ${a}.${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: a }) => `Identifier '${a}' 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: a }) => `Assigning to '${a}' in strict mode.`,
	StrictEvalArgumentsBinding: ({ bindingName: a }) => `Binding '${a}' 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: a }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(a)}\`.`
}, Qs = 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: a }) => `Invalid topic token ${a}. In order to use ${a} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${a}" }.`,
	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
	PipeUnparenthesizedBody: ({ type: a }) => `Hack-style pipe body cannot be an unparenthesized ${be({ type: a })}; please wrap it in parentheses.`
}, {}), ei = ["message"];
function Ot(a, t, e) {
	Object.defineProperty(a, t, {
		enumerable: !1,
		configurable: !0,
		value: e
	});
}
function ti({ toMessage: a, code: t, reasonCode: e, syntaxPlugin: s }) {
	let i = e === "MissingPlugin" || e === "MissingOneOfPlugins";
	return function r(n, o) {
		let h = /* @__PURE__ */ 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 = `${a(o)} (${n.line}:${n.column})`;
				return this.message = l, l;
			},
			set(l) {
				Object.defineProperty(this, "message", {
					value: l,
					writable: !0
				});
			}
		}), h;
	};
}
function F(a, t) {
	if (Array.isArray(a)) return (s) => F(s, a[0]);
	let e = {};
	for (let s of Object.keys(a)) {
		let i = a[s], r = typeof i == "string" ? { message: () => i } : typeof i == "function" ? { message: i } : i, { message: n } = r, o = Ws(r, ei);
		e[s] = ti(Object.assign({
			code: "BABEL_PARSER_SYNTAX_ERROR",
			reasonCode: s,
			toMessage: typeof n == "string" ? () => n : n
		}, t ? { syntaxPlugin: t } : {}, o));
	}
	return e;
}
var p = Object.assign({}, F(Js), F(Gs), F(Xs), F(Ys), F`pipelineOperator`(Zs));
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(a) {
	let t = si();
	if (a == null) return t;
	if (a.annexB != null && a.annexB !== !1) throw new Error("The `annexB` option can only be set to `false`.");
	for (let e of Object.keys(t)) a[e] != null && (t[e] = a[e]);
	if (t.startLine === 1) a.startIndex == null && t.startColumn > 0 ? t.startIndex = t.startColumn : a.startColumn == null && t.startIndex > 0 && (t.startColumn = t.startIndex);
	else if (a.startColumn == null || a.startIndex == null) throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
	if (t.sourceType === "commonjs") {
		if (a.allowAwaitOutsideFunction != null) throw new Error("The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`.");
		if (a.allowReturnOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`.");
		if (a.allowNewTargetOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`.");
	}
	return t;
}
var { defineProperty: ri } = Object, Ft = (a, t) => {
	a && ri(a, t, {
		enumerable: !1,
		value: a[t]
	});
};
function ne(a) {
	return Ft(a.loc.start, "index"), Ft(a.loc.end, "index"), a;
}
var ai = (a) => class extends a {
	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);
		e.body = e.directives.map((h) => this.directiveToStmt(h)).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));
		return e.value = this.castNodeTo(l, this.hasPlugin("typescript") && !l.body ? "TSEmptyBodyFunctionExpression" : "FunctionExpression"), 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();
function S(a, t = {}) {
	t.keyword = a;
	let e = P(a, t);
	return ft.set(a, e), e;
}
function v(a, t) {
	return P(a, {
		beforeExpr: T,
		binop: t
	});
}
var pe = -1, dt = [], mt = [], yt = [], xt = [], Pt = [], gt = [];
function P(a, t = {}) {
	return ++pe, mt.push(a), yt.push(t.binop ?? -1), xt.push(t.beforeExpr ?? !1), Pt.push(t.startsExpr ?? !1), gt.push(t.prefix ?? !1), dt.push(new we(a, t)), pe;
}
function b(a, t = {}) {
	return ++pe, ft.set(a, pe), mt.push(a), 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;
}
var 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")
};
function w(a) {
	return a >= 93 && a <= 133;
}
function hi(a) {
	return a <= 92;
}
function O(a) {
	return a >= 58 && a <= 133;
}
function Jt(a) {
	return a >= 58 && a <= 137;
}
function ci(a) {
	return xt[a];
}
function ce(a) {
	return Pt[a];
}
function li(a) {
	return a >= 29 && a <= 33;
}
function Bt(a) {
	return a >= 129 && a <= 131;
}
function pi(a) {
	return a >= 90 && a <= 92;
}
function Tt(a) {
	return a >= 58 && a <= 92;
}
function ui(a) {
	return a >= 39 && a <= 59;
}
function fi(a) {
	return a === 34;
}
function di(a) {
	return gt[a];
}
function mi(a) {
	return a >= 121 && a <= 123;
}
function yi(a) {
	return a >= 124 && a <= 130;
}
function z(a) {
	return mt[a];
}
function Ae(a) {
	return yt[a];
}
function xi(a) {
	return a === 57;
}
function $e(a) {
	return a >= 24 && a <= 25;
}
function Gt(a) {
	return dt[a];
}
var bt = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", Xt = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", Pi = new RegExp("[" + bt + "]"), gi = new RegExp("[" + bt + Xt + "]");
bt = Xt = null;
var 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
];
function Ke(a, t) {
	let e = 65536;
	for (let s = 0, i = t.length; s < i; s += 2) {
		if (e += t[s], e > a) return !1;
		if (e += t[s + 1], e >= a) return !0;
	}
	return !1;
}
function B(a) {
	return a < 65 ? a === 36 : a <= 90 ? !0 : a < 97 ? a === 95 : a <= 122 ? !0 : a <= 65535 ? a >= 170 && Pi.test(String.fromCharCode(a)) : Ke(a, Yt);
}
function K(a) {
	return a < 48 ? a === 36 : a < 58 ? !0 : a < 65 ? !1 : a <= 90 ? !0 : a < 97 ? a === 95 : a <= 122 ? !0 : a <= 65535 ? a >= 170 && gi.test(String.fromCharCode(a)) : Ke(a, Yt) || Ke(a, Ti);
}
var 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);
function Qt(a, t) {
	return t && a === "await" || a === "enum";
}
function Zt(a, t) {
	return Qt(a, t) || Ai.has(a);
}
function es(a) {
	return Si.has(a);
}
function ts(a, t) {
	return Zt(a, t) || es(a);
}
function wi(a) {
	return bi.has(a);
}
function Ci(a, t, e) {
	return a === 64 && t === 64 && B(e);
}
var Ei = new Set([
	"break",
	"case",
	"catch",
	"continue",
	"debugger",
	"default",
	"do",
	"else",
	"finally",
	"for",
	"function",
	"if",
	"return",
	"switch",
	"throw",
	"try",
	"var",
	"const",
	"while",
	"with",
	"new",
	"this",
	"super",
	"class",
	"extends",
	"export",
	"import",
	"null",
	"true",
	"false",
	"in",
	"instanceof",
	"typeof",
	"void",
	"delete",
	"implements",
	"interface",
	"let",
	"package",
	"private",
	"protected",
	"public",
	"static",
	"yield",
	"eval",
	"arguments",
	"enum",
	"await"
]);
function Ii(a) {
	return Ei.has(a);
}
var 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 = 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: a }) => `Cannot overwrite reserved type ${a}.`,
	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: a, enumName: t }) => `Boolean enum members need to be initialized. Use either \`${a} = true,\` or \`${a} = false,\` in enum \`${t}\`.`,
	EnumDuplicateMemberName: ({ memberName: a, enumName: t }) => `Enum member names need to be unique, but the name \`${a}\` has already been used before in enum \`${t}\`.`,
	EnumInconsistentMemberValues: ({ enumName: a }) => `Enum \`${a}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
	EnumInvalidExplicitType: ({ invalidEnumType: a, enumName: t }) => `Enum type \`${a}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${t}\`.`,
	EnumInvalidExplicitTypeUnknownSupplied: ({ enumName: a }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${a}\`.`,
	EnumInvalidMemberInitializerPrimaryType: ({ enumName: a, memberName: t, explicitType: e }) => `Enum \`${a}\` has type \`${e}\`, so the initializer of \`${t}\` needs to be a ${e} literal.`,
	EnumInvalidMemberInitializerSymbolType: ({ enumName: a, memberName: t }) => `Symbol enum members cannot be initialized. Use \`${t},\` in enum \`${a}\`.`,
	EnumInvalidMemberInitializerUnknownType: ({ enumName: a, memberName: t }) => `The enum member initializer for \`${t}\` needs to be a literal (either a boolean, number, or string) in enum \`${a}\`.`,
	EnumInvalidMemberName: ({ enumName: a, memberName: t, suggestion: e }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${t}\`, consider using \`${e}\`, in enum \`${a}\`.`,
	EnumNumberMemberNotInitialized: ({ enumName: a, memberName: t }) => `Number enum members need to be initialized, e.g. \`${t} = 1\` in enum \`${a}\`.`,
	EnumStringMemberInconsistentlyInitialized: ({ enumName: a }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${a}\`.`,
	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: a }) => `Unexpected reserved type ${a}.`,
	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: a, suggestion: t }) => `\`declare export ${a}\` is not supported. Use \`${t}\` instead.`,
	UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
	UnterminatedFlowComment: "Unterminated flow-comment."
});
function ki(a) {
	return a.type === "DeclareExportAllDeclaration" || a.type === "DeclareExportDeclaration" && (!a.declaration || a.declaration.type !== "TypeAlias" && a.declaration.type !== "InterfaceDeclaration");
}
function Rt(a) {
	return a.importKind === "type" || a.importKind === "typeof";
}
var vi = {
	const: "declare export var",
	let: "declare export var",
	type: "export type",
	interface: "export interface"
};
function Li(a, t) {
	let e = [], s = [];
	for (let i = 0; i < a.length; i++) (t(a[i], i, a) ? e : s).push(a[i]);
	return [e, s];
}
var Di = /\*?\s*@((?:no)?flow)\b/, Mi = (a) => class extends a {
	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)) Jt(this.lookahead().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)) {
			if (O(this.lookahead().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() {
		switch (this.state.type) {
			case 78: return this.parseIdentifier(!0);
			default: return 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;
		return {
			id: this.parseIdentifier(!0),
			init: this.eat(29) ? this.flowEnumMemberInit() : {
				type: "none",
				loc: e
			}
		};
	}
	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;
	}
};
var ge = new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
function G(a) {
	switch (a) {
		case 10:
		case 13:
		case 8232:
		case 8233: return !0;
		default: return !1;
	}
}
function Ut(a, t, e) {
	for (let s = t; s < e; s++) if (G(a.charCodeAt(s))) return !0;
	return !1;
}
var _e = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g, je = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
function Fi(a) {
	switch (a) {
		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;
	}
}
var U = F`jsx`({
	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
	MissingClosingTagElement: ({ openingTagName: a }) => `Expected corresponding JSX closing tag for <${a}>.`,
	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: a, HTMLEntity: t }) => `Unexpected token \`${a}\`. Did you mean \`${t}\` or \`{'${a}'}\`?`,
	UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
	UnterminatedJsxContent: "Unterminated JSX contents.",
	UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
});
function V(a) {
	return a ? a.type === "JSXOpeningFragment" || a.type === "JSXClosingFragment" : !1;
}
function J(a) {
	if (a.type === "JSXIdentifier") return a.name;
	if (a.type === "JSXNamespacedName") return a.namespace.name + ":" + a.name.name;
	if (a.type === "JSXMemberExpression") return J(a.object) + "." + J(a.property);
	throw new Error("Node had unexpected type: " + a.type);
}
var Bi = (a) => class extends a {
	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 ? "&rbrace;" : "&gt;"
				});
				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) {
				this.input.slice(e, this.state.pos);
				if (++this.state.pos, void 0);
			}
		}
		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) return !!(s & 512) !== (i & 4) > 0;
			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;
	}
};
function Se(a, t) {
	return (a ? 2 : 0) | (t ? 1 : 0);
}
var 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];
	}
};
function ss(a, t) {
	a.trailingComments === void 0 ? a.trailingComments = t : a.trailingComments.unshift(...t);
}
function Ri(a, t) {
	a.leadingComments === void 0 ? a.leadingComments = t : a.leadingComments.unshift(...t);
}
function X(a, t) {
	a.innerComments === void 0 ? a.innerComments = t : a.innerComments.unshift(...t);
}
function $(a, t, e) {
	let s = null, i = t.length;
	for (; s === null && i > 0;) s = t[--i];
	s === null || s.start > e.start ? X(a, e.comments) : ss(s, e.comments);
}
var 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: new Set([
		46,
		66,
		69,
		79,
		95,
		98,
		101,
		111
	]),
	hex: new Set([
		46,
		88,
		95,
		120
	])
}, Te = {
	bin: (a) => a === 48 || a === 49,
	oct: (a) => a >= 48 && a <= 55,
	dec: (a) => a >= 48 && a <= 57,
	hex: (a) => a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102
};
function jt(a, 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(a, x, t, e)) {
			l += t.slice(f, e);
			break;
		}
		if (x === 92) {
			l += t.slice(f, e);
			let A = ji(t, e, s, i, a === "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 ? a === "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(a, t, e, s) {
	return a === "template" ? t === 96 || t === 36 && e.charCodeAt(s + 1) === 123 : t === (a === "double" ? 34 : 39);
}
function ji(a, t, e, s, i, r) {
	let n = !i;
	t++;
	let o = (l) => ({
		pos: t,
		ch: l,
		lineStart: e,
		curLine: s
	}), h = a.charCodeAt(t++);
	switch (h) {
		case 110: return o(`
`);
		case 114: return o("\r");
		case 120: {
			let l;
			return {code: l, pos: t} = et(a, t, e, s, 2, !1, n, r), o(l === null ? null : String.fromCharCode(l));
		}
		case 117: {
			let l;
			return {code: l, pos: t} = rs(a, 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: a.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(a.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 = a.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(a, t, e, s, i, r, n, o) {
	let h = t, l;
	return {n: l, pos: t} = is(a, 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(a, 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 ?? Infinity; k < N; ++k) {
		let C = a.charCodeAt(t), I;
		if (C === 95 && o !== "bail") {
			let Pe = a.charCodeAt(t - 1), ae = a.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 = Infinity, 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(a, t, e, s, i, r) {
	let n = a.charCodeAt(t), o;
	if (n === 123) {
		if (++t, {code: o, pos: t} = et(a, t, e, s, a.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(a, t, e, s, 4, !1, i, r));
	return {
		code: o,
		pos: t
	};
}
function he(a, t, e) {
	return new R(e, a - t, a);
}
var Vi = 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 ?? 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 r = t(e instanceof R ? e : e.loc.start, 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;
				o = (h & 3) === (e & 3) || 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];
		});
	}
};
function zi() {
	return new Z(3);
}
function qi() {
	return new Ce(1);
}
function $i() {
	return new Ce(2);
}
function as() {
	return new Z();
}
var nt = class extends st {
	addExtra(t, e, s, i = !0) {
		if (!t) return;
		let { extra: r } = t;
		r ?? (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;
		this.scope = new (this.getScopeHandler())(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 = (a) => a.type === "ParenthesizedExpression" ? ht(a.expression) : a, 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;
function Ki(a) {
	if (a == null) throw new Error(`Unexpected ${a} value.`);
	return a;
}
function zt(a) {
	if (!a) throw new Error("Assert fail");
}
var y = F`typescript`({
	AbstractMethodHasImplementation: ({ methodName: a }) => `Method '${a}' cannot have an implementation because it is marked abstract.`,
	AbstractPropertyHasInitializer: ({ propertyName: a }) => `Property '${a}' 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: a }) => `'declare' is not allowed in ${a}ters.`,
	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
	DuplicateAccessibilityModifier: ({ modifier: a }) => `Accessibility modifier already seen: '${a}'.`,
	DuplicateModifier: ({ modifier: a }) => `Duplicate modifier: '${a}'.`,
	EmptyHeritageClauseType: ({ token: a }) => `'${a}' 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: a }) => `'${a[0]}' modifier cannot be used with '${a[1]}' modifier.`,
	IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
	IndexSignatureHasAccessibility: ({ modifier: a }) => `Index signatures cannot have an accessibility modifier ('${a}').`,
	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: a }) => `'${a}' list can only include identifiers or qualified-names with optional type arguments.`,
	InvalidModifierOnAwaitUsingDeclaration: (a) => `'${a}' modifier cannot appear on an await using declaration.`,
	InvalidModifierOnTypeMember: ({ modifier: a }) => `'${a}' modifier cannot appear on a type member.`,
	InvalidModifierOnTypeParameter: ({ modifier: a }) => `'${a}' modifier cannot appear on a type parameter.`,
	InvalidModifierOnTypeParameterPositions: ({ modifier: a }) => `'${a}' modifier can only appear on a type parameter of a class, interface or type alias.`,
	InvalidModifierOnUsingDeclaration: (a) => `'${a}' modifier cannot appear on a using declaration.`,
	InvalidModifiersOrder: ({ orderedModifiers: a }) => `'${a[0]}' modifier must precede '${a[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: a }) => `Private elements cannot have an accessibility modifier ('${a}').`,
	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: a }) => `Single type parameter ${a} should have a trailing comma. Example usage: <${a},>.`,
	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: a }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${a}.`,
	UsingDeclarationInAmbientContext: (a) => `'${a}' declarations are not allowed in ambient contexts.`
});
function Hi(a) {
	switch (a) {
		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(a) {
	return a === "private" || a === "public" || a === "protected";
}
function Wi(a) {
	return a === "in" || a === "out";
}
function lt(a) {
	if (a.extra?.parenthesized) return !1;
	switch (a.type) {
		case "Identifier": return !0;
		case "MemberExpression": return !a.computed && lt(a.object);
		case "TSInstantiationExpression": return lt(a.expression);
		default: return !1;
	}
}
var Ji = (a) => class extends a {
	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));
		}
		this.tsParseModifiers({
			allowedModifiers: ["readonly"],
			disallowedModifiers: [
				"declare",
				"abstract",
				"private",
				"protected",
				"public",
				"static",
				"override"
			]
		}, e);
		return 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;
	}
};
function Gi(a) {
	if (a.type !== "MemberExpression") return !1;
	let { computed: t, property: e } = a;
	return t && e.type !== "StringLiteral" && (e.type !== "TemplateLiteral" || e.expressions.length > 0) ? !1 : os(a.object);
}
function Xi(a, t) {
	let { type: e } = a;
	if (a.extra?.parenthesized) return !1;
	if (t) {
		if (e === "Literal") {
			let { value: s } = a;
			if (typeof s == "string" || typeof s == "boolean") return !0;
		}
	} else if (e === "StringLiteral" || e === "BooleanLiteral") return !0;
	return !!(ns(a, t) || Yi(a, t) || e === "TemplateLiteral" && a.expressions.length === 0 || Gi(a));
}
function ns(a, t) {
	return t ? a.type === "Literal" && (typeof a.value == "number" || "bigint" in a) : a.type === "NumericLiteral" || a.type === "BigIntLiteral";
}
function Yi(a, t) {
	if (a.type === "UnaryExpression") {
		let { operator: e, argument: s } = a;
		if (e === "-" && ns(s, t)) return !0;
	}
	return !1;
}
function os(a) {
	return a.type === "Identifier" ? !0 : a.type !== "MemberExpression" || a.computed ? !1 : os(a.object);
}
var $t = F`placeholders`({
	ClassNameIsRequired: "A class name is required.",
	UnexpectedSpace: "Unexpected space in placeholder."
}), Qi = (a) => class extends a {
	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 = (a) => class extends a {
	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 = [
	"^^",
	"@@",
	"^",
	"%",
	"#"
];
function er(a) {
	if (a.has("decorators")) {
		if (a.has("decorators-legacy")) throw new Error("Cannot use the decorators and decorators-legacy plugin together");
		let t = a.get("decorators").decoratorsBeforeExport;
		if (t != null && typeof t != "boolean") throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
		let e = a.get("decorators").allowCallParenthesized;
		if (e != null && typeof e != "boolean") throw new Error("'allowCallParenthesized' must be a boolean.");
	}
	if (a.has("flow") && a.has("typescript")) throw new Error("Cannot combine flow and typescript plugins.");
	if (a.has("placeholders") && a.has("v8intrinsic")) throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
	if (a.has("pipelineOperator")) {
		let t = a.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 (a.has("placeholders")) throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
			if (a.has("v8intrinsic")) throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
			let e = a.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 (a.has("moduleAttributes")) throw new Error("`moduleAttributes` has been removed in Babel 8, please migrate to import attributes instead.");
	if (a.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 (!a.has("deprecatedImportAssert") && a.has("importAttributes") && a.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 (a.has("recordAndTuple")) throw new Error("The 'recordAndTuple' plugin has been removed in Babel 8. Please remove it from your configuration.");
	if (a.has("asyncDoExpressions") && !a.has("doExpressions")) {
		let t = /* @__PURE__ */ new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
		throw t.missingPlugins = "doExpressions", t;
	}
	if (a.has("optionalChainingAssign") && a.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 (a.has("discardBinding") && a.get("discardBinding").syntaxType !== "void") throw new Error("The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'.");
	if (a.has("decimal")) throw new Error("The 'decimal' plugin has been removed in Babel 8. Please remove it from your configuration.");
	if (a.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.");
}
var 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)) return;
		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;
function rr(a, t, e) {
	for (let s = 0; s < a.length; s++) {
		let i = a[s], { type: r } = i;
		typeof r == "number" && (i.type = Gt(r));
	}
	return a;
}
var 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;
	}
};
function Ie(a, t) {
	if (t?.sourceType === "unambiguous") {
		t = Object.assign({}, t);
		try {
			t.sourceType = "module";
			let e = le(t, a), s = e.parse();
			if (e.sawUnambiguousESM) return s;
			if (e.ambiguousScriptDifferentAst) try {
				return t.sourceType = "script", le(t, a).parse();
			} catch {}
			else s.program.sourceType = "script";
			return s;
		} catch (e) {
			try {
				return t.sourceType = "script", le(t, a).parse();
			} catch {}
			throw e;
		}
	} else return le(t, a).parse();
}
function Ne(a, t) {
	let e = le(t, a);
	return e.options.strictMode && (e.state.strict = !0), e.getExpression();
}
function ar(a) {
	let t = {};
	for (let e of Object.keys(a)) t[e] = Gt(a[e]);
	return t;
}
ar(oi);
function le(a, t) {
	let e = Ee, s = /* @__PURE__ */ new Map();
	if (a?.plugins) {
		for (let i of a.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(a, t, s);
}
var Wt = /* @__PURE__ */ new Map();
function nr(a) {
	let t = [];
	for (let i of tr) a.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(a) {
	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 (a instanceof RegExp) {
				if (!a.test(o)) return n;
			} else if (!a.includes(o)) return n;
			i ? n-- : n++;
		}
		return n === -1 || n === r ? n : !1;
	};
}
ke(/\s/u);
var cs = ke(" 	");
ke(",; 	");
var ls = ke(/[^\n\r]/u);
function or(a, t) {
	if (t === !1) return !1;
	if (a.charAt(t) === "/" && a.charAt(t + 1) === "*") {
		for (let e = t + 2; e < a.length; ++e) if (a.charAt(e) === "*" && a.charAt(e + 1) === "/") return e + 2;
	}
	return t;
}
var ps = or;
var us = (a) => a === `
` || a === "\r" || a === "\u2028" || a === "\u2029";
function hr(a, t, e) {
	let s = !!e?.backwards;
	if (t === !1) return !1;
	let i = a.charAt(t);
	if (s) {
		if (a.charAt(t - 1) === "\r" && i === `
`) return t - 2;
		if (us(i)) return t - 1;
	} else {
		if (i === "\r" && a.charAt(t + 1) === `
`) return t + 2;
		if (us(i)) return t + 1;
	}
	return t;
}
var fs = hr;
function cr(a, t) {
	return t === !1 ? !1 : a.charAt(t) === "/" && a.charAt(t + 1) === "/" ? ls(a, t) : t;
}
var ds = cr;
function lr(a, t) {
	let e = null, s = t;
	for (; s !== e;) e = s, s = cs(a, s), s = ps(a, s), s = ds(a, s), s = fs(a, s);
	return s;
}
var ms = lr;
function ys(a) {
	let t = [];
	for (let e of a) try {
		return e();
	} catch (s) {
		t.push(s);
	}
	throw Object.assign(/* @__PURE__ */ new Error("All combinations failed"), { errors: t });
}
function pr(a) {
	if (!a.startsWith("#!")) return "";
	let t = a.indexOf(`
`);
	return t === -1 ? a : a.slice(0, t);
}
var ve = pr;
var ee = (a, t) => (e, s, ...i) => e | 1 && s == null ? void 0 : (t.call(s) ?? s[a]).apply(s, i);
var ur = Array.prototype.findLast ?? function(a) {
	for (let t = this.length - 1; t >= 0; t--) {
		let e = this[t];
		if (a(e, t, this)) return e;
	}
}, xs = ee("findLast", function() {
	if (Array.isArray(this)) return ur;
});
function dr(a) {
	return this[a < 0 ? this.length + a : a];
}
var Ps = ee("at", function() {
	if (Array.isArray(this) || typeof this == "string") return dr;
});
function M(a) {
	let t = a.range?.[0] ?? a.start, e = (a.declaration?.decorators ?? a.decorators)?.[0];
	return e ? Math.min(M(e), t) : t;
}
function L(a) {
	return a.range?.[1] ?? a.end;
}
function yr(a) {
	let t = new Set(a);
	return (e) => t.has(e?.type);
}
var te = yr;
var se = te([
	"Block",
	"CommentBlock",
	"MultiLine"
]);
var gs = te([
	"Line",
	"CommentLine",
	"SingleLine",
	"HashbangComment",
	"HTMLOpen",
	"HTMLClose",
	"Hashbang",
	"InterpreterDirective"
]);
var St = /* @__PURE__ */ new WeakMap();
function gr(a) {
	return St.has(a) || St.set(a, se(a) && a.value[0] === "*" && /@(?:type|satisfies)\b/u.test(a.value)), St.get(a);
}
var Ts = gr;
function Tr(a) {
	if (!se(a)) return !1;
	let t = `*${a.value}*`.split(`
`);
	return t.length > 1 && t.every((e) => e.trimStart()[0] === "*");
}
var wt = /* @__PURE__ */ new WeakMap();
function br(a) {
	return wt.has(a) || wt.set(a, Tr(a)), wt.get(a);
}
var Ct = br;
function Ar(a) {
	if (a.length < 2) return;
	let t;
	for (let e = a.length - 1; e >= 0; e--) {
		let s = a[e];
		if (t && L(s) === M(t) && Ct(s) && Ct(t) && (a.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;
	}
}
var bs = Ar;
function Sr(a) {
	return a !== null && typeof a == "object";
}
var As = Sr;
var me = null;
function ye(a) {
	if (me !== null && typeof me.property) {
		let t = me;
		return me = ye.prototype = null, t;
	}
	return me = ye.prototype = a ?? Object.create(null), new ye();
}
var wr = 10;
for (let a = 0; a <= wr; a++) ye();
function Et(a) {
	return ye(a);
}
function Cr(a, t = "type") {
	Et(a);
	function e(s) {
		let i = s[t], r = a[i];
		if (!Array.isArray(r)) throw Object.assign(/* @__PURE__ */ new Error(`Missing visitor keys for '${i}'.`), { node: s });
		return r;
	}
	return e;
}
var Ss = Cr;
var 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"]
];
var Cs = Ss({
	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]
});
function Le(a, t) {
	if (!As(a)) return a;
	if (Array.isArray(a)) {
		for (let s = 0; s < a.length; s++) a[s] = Le(a[s], t);
		return a;
	}
	if (t.onEnter) {
		let s = t.onEnter(a) ?? a;
		if (s !== a) return Le(s, t);
		a = s;
	}
	let e = Cs(a);
	for (let s = 0; s < e.length; s++) a[e[s]] = Le(a[e[s]], t);
	return t.onLeave && (a = t.onLeave(a) || a), a;
}
var Es = Le;
te([
	"RegExpLiteral",
	"BigIntLiteral",
	"NumericLiteral",
	"StringLiteral",
	"DirectiveLiteral",
	"Literal",
	"JSXText",
	"TemplateElement",
	"StringLiteralTypeAnnotation",
	"NumberLiteralTypeAnnotation",
	"BigIntLiteralTypeAnnotation"
]);
function Ir(a, t) {
	let { parser: e, text: s } = t, { comments: i } = a, r = e === "oxc" && t.oxcAstType === "ts";
	bs(i);
	let n = a.type === "File" ? a.program : a;
	n.interpreter && (i.unshift(n.interpreter), delete n.interpreter), r && a.hashbang && (i.unshift(a.hashbang), delete a.hashbang), a.type === "Program" && (a.range = [0, s.length]);
	let o;
	return a = Es(a, {
		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) h.range = [M(h) + 1, L(h) - (h.tail ? 1 : 2)];
					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":
					a.extra = {
						...a.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;
			}
		}
	}), a;
}
function Is(a) {
	return a.type === "LogicalExpression" && a.right.type === "LogicalExpression" && a.operator === a.right.operator;
}
function It(a) {
	return Is(a) ? It({
		type: "LogicalExpression",
		operator: a.operator,
		left: It({
			type: "LogicalExpression",
			operator: a.operator,
			left: a.left,
			right: a.right.left,
			range: [M(a.left), L(a.right.left)]
		}),
		right: a.right.right,
		range: [M(a), L(a)]
	}) : a;
}
var Ns = Ir;
function Nr(a, t) {
	let e = /* @__PURE__ */ new SyntaxError(a + " (" + t.loc.start.line + ":" + t.loc.start.column + ")");
	return Object.assign(e, t);
}
var De = Nr;
var ks = "Unexpected parseExpression() input: ";
function kr(a) {
	let { message: t, loc: e, reasonCode: s } = a;
	if (!e) return a;
	let { line: i, column: r } = e, n = a;
	(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
	});
}
var Me = kr;
var vr = String.prototype.replaceAll ?? function(a, t) {
	return a.global ? this.replace(a, t) : this.split(a).join(t);
}, xe = ee("replaceAll", function() {
	if (typeof this == "string") return vr;
});
var 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 = [];
function Ds(a) {
	let t = a.match(Or);
	return t ? t[0].trimStart() : "";
}
function Ms(a) {
	a = xe(0, a.replace(Mr, "").replace(Dr, ""), Rr, "$1");
	let e = "";
	for (; e !== a;) e = a, a = xe(0, a, Br, `
$1 $2
`);
	a = a.replace(vs, "").trimEnd();
	let s = Object.create(null), i = xe(0, a, Ls, "").replace(vs, "").trimEnd(), r;
	for (; r = Ls.exec(a);) {
		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
	};
}
var Os = ["noformat", "noprettier"], Fs = ["format", "prettier"];
function Bs(a) {
	let t = ve(a);
	t && (a = a.slice(t.length + 1));
	let { pragmas: s, comments: i } = Ms(Ds(a));
	return {
		shebang: t,
		text: a,
		pragmas: s,
		comments: i
	};
}
function Rs(a) {
	let { pragmas: t } = Bs(a);
	return Fs.some((e) => Object.prototype.hasOwnProperty.call(t, e));
}
function Us(a) {
	let { pragmas: t } = Bs(a);
	return Os.some((e) => Object.prototype.hasOwnProperty.call(t, e));
}
function _r(a) {
	return a = typeof a == "function" ? { parse: a } : a, {
		astFormat: "estree",
		hasPragma: Rs,
		hasIgnorePragma: Us,
		locStart: M,
		locEnd: L,
		...a
	};
}
var H = _r;
var Oe = "module";
var Nt = "commonjs";
function _s(a) {
	if (typeof a == "string") {
		if (a = a.toLowerCase(), /\.(?:mjs|mts)$/iu.test(a)) return Oe;
		if (/\.(?:cjs|cts)$/iu.test(a)) return Nt;
	}
}
function jr(a, t) {
	let { type: e = "JsExpressionRoot", rootMarker: s, text: i } = t, { tokens: r, comments: n } = a;
	return delete a.tokens, delete a.comments, {
		tokens: r,
		comments: n,
		type: e,
		node: a,
		range: [0, i.length],
		rootMarker: s
	};
}
var Fe = jr;
var ie = (a) => H(Kr(a)), 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" }]], _ = (a, t = Vr) => ({
	...t,
	plugins: [...t.plugins, ...a]
}), zr = /@(?:no)?flow\b/u;
function qr(a, t) {
	if (t?.endsWith(".js.flow")) return !0;
	let e = ve(a);
	e && (a = a.slice(e.length));
	let s = ms(a, 0);
	return s !== !1 && (a = a.slice(0, s)), zr.test(a);
}
function $r(a, t, e) {
	let s = a(t, e), i = s.errors.find((r) => !Hr.has(r.reasonCode));
	if (i) throw i;
	return s;
}
function Kr({ isExpression: a = !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 = a ? Ne : Ie, l;
		try {
			l = ys(r.map((u) => () => $r(h, e, u)));
		} catch ({ errors: [u] }) {
			throw Me(u);
		}
		return a && (l = Fe(l, {
			text: e,
			rootMarker: s.rootMarker
		})), Ns(l, { text: e });
	};
}
var Hr = 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((a) => _(["estree"], a)) });
var Lt = {};
Re(Lt, {
	json: () => ea,
	"json-stringify": () => ia,
	json5: () => ta,
	jsonc: () => sa
});
function Qr(a) {
	return Array.isArray(a) && a.length > 0;
}
var vt = Qr;
var $s = {
	tokens: !1,
	ranges: !1,
	attachComment: !1,
	createParenthesizedExpressions: !0
};
function Zr(a) {
	let t = Ie(a, $s), { program: e } = t;
	if (e.body.length === 0 && e.directives.length === 0 && !e.interpreter) return t;
}
function Be(a, t = {}) {
	let { allowComments: e = !0, allowEmpty: s = !1 } = t, i;
	try {
		i = Ne(a, $s);
	} catch (r) {
		if (s && r.code === "BABEL_PARSER_SYNTAX_ERROR" && r.reasonCode === "ParseExpressionEmptyInput") try {
			i = Zr(a);
		} catch {}
		if (!i) throw Me(r);
	}
	if (!e && vt(i.comments)) throw q(i.comments[0], "Comment");
	return i = Fe(i, {
		type: "JsonRoot",
		text: a
	}), i.node.type === "File" ? delete i.node : re(i.node), i;
}
function q(a, t) {
	let [e, s] = [a.loc.start, a.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(a) {
	switch (a.type) {
		case "ArrayExpression":
			for (let t of a.elements) t !== null && re(t);
			return;
		case "ObjectExpression":
			for (let t of a.properties) re(t);
			return;
		case "ObjectProperty":
			if (a.computed) throw q(a.key, "Computed key");
			if (a.shorthand) throw q(a.key, "Shorthand property");
			a.key.type !== "Identifier" && re(a.key), re(a.value);
			return;
		case "UnaryExpression": {
			let { operator: t, argument: e } = a;
			if (t !== "+" && t !== "-") throw q(a, `Operator '${a.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 (a.name !== "Infinity" && a.name !== "NaN" && a.name !== "undefined") throw q(a, `Identifier '${a.name}'`);
			return;
		case "TemplateLiteral":
			if (vt(a.expressions)) throw q(a.expressions[0], "'TemplateLiteral' with expression");
			for (let t of a.quasis) re(t);
			return;
		case "NullLiteral":
		case "BooleanLiteral":
		case "NumericLiteral":
		case "StringLiteral":
		case "TemplateElement": return;
		default: throw q(a, `'${a.type}'`);
	}
}
var ea = H({
	parse: (a) => Be(a),
	hasPragma: () => !0,
	hasIgnorePragma: () => !1
}), ta = H((a) => Be(a)), sa = H((a) => Be(a, { allowEmpty: !0 })), ia = H({
	parse: (a) => Be(a, { allowComments: !1 }),
	astFormat: "estree-json"
});
var ra = {
	...kt,
	...Lt
};
//#endregion
export { Ks as default, ra as parsers, babel_exports as t };
