@amplitude/ai 0.2.1 → 0.3.1

package/dist/node_modules/.pnpm/acorn-typescript@1.4.13_acorn@8.16.0/node_modules/acorn-typescript/lib/index.js

@@ -0,0 +1,2389 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_acorn } from "../../../../acorn@8.16.0/node_modules/acorn/dist/acorn.js";
+
+//#region node_modules/.pnpm/acorn-typescript@1.4.13_acorn@8.16.0/node_modules/acorn-typescript/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var t = require_acorn();
+	function e(t) {
+		if (t && t.__esModule) return t;
+		var e = Object.create(null);
+		return t && Object.keys(t).forEach(function(s) {
+			if ("default" !== s) {
+				var i = Object.getOwnPropertyDescriptor(t, s);
+				Object.defineProperty(e, s, i.get ? i : {
+					enumerable: !0,
+					get: function() {
+						return t[s];
+					}
+				});
+			}
+		}), e.default = t, e;
+	}
+	var s = /* @__PURE__ */ e(t);
+	function i(t, e) {
+		for (var s = 0; s < e.length; s++) {
+			var i = e[s];
+			i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(t, "symbol" == typeof (r = function(t$1, e$1) {
+				if ("object" != typeof t$1 || null === t$1) return t$1;
+				var s$1 = t$1[Symbol.toPrimitive];
+				if (void 0 !== s$1) {
+					var i$1 = s$1.call(t$1, "string");
+					if ("object" != typeof i$1) return i$1;
+					throw new TypeError("@@toPrimitive must return a primitive value.");
+				}
+				return String(t$1);
+			}(i.key)) ? r : String(r), i);
+		}
+		var r;
+	}
+	function r() {
+		return r = Object.assign ? Object.assign.bind() : function(t) {
+			for (var e = 1; e < arguments.length; e++) {
+				var s = arguments[e];
+				for (var i in s) Object.prototype.hasOwnProperty.call(s, i) && (t[i] = s[i]);
+			}
+			return t;
+		}, r.apply(this, arguments);
+	}
+	function a(t, e) {
+		t.prototype = Object.create(e.prototype), t.prototype.constructor = t, n(t, e);
+	}
+	function n(t, e) {
+		return n = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t$1, e$1) {
+			return t$1.__proto__ = e$1, t$1;
+		}, n(t, e);
+	}
+	function o(t, e) {
+		(null == e || e > t.length) && (e = t.length);
+		for (var s = 0, i = new Array(e); s < e; s++) i[s] = t[s];
+		return i;
+	}
+	function h(t, e) {
+		var s = "undefined" != typeof Symbol && t[Symbol.iterator] || t["@@iterator"];
+		if (s) return (s = s.call(t)).next.bind(s);
+		if (Array.isArray(t) || (s = function(t$1, e$1) {
+			if (t$1) {
+				if ("string" == typeof t$1) return o(t$1, e$1);
+				var s$1 = Object.prototype.toString.call(t$1).slice(8, -1);
+				return "Object" === s$1 && t$1.constructor && (s$1 = t$1.constructor.name), "Map" === s$1 || "Set" === s$1 ? Array.from(t$1) : "Arguments" === s$1 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(s$1) ? o(t$1, e$1) : void 0;
+			}
+		}(t)) || e && t && "number" == typeof t.length) {
+			s && (t = s);
+			var i = 0;
+			return function() {
+				return i >= t.length ? { done: !0 } : {
+					done: !1,
+					value: t[i++]
+				};
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	var p = !0;
+	function c(e, s) {
+		return void 0 === s && (s = {}), new t.TokenType("name", s);
+	}
+	var l = /* @__PURE__ */ new WeakMap(), u = 1024, d = new RegExp("(?:[^\\S\\n\\r\\u2028\\u2029]|\\/\\/.*|\\/\\*.*?\\*\\/)*", "y"), m = new RegExp("(?=(" + d.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y"), y = function() {
+		this.shorthandAssign = void 0, this.trailingComma = void 0, this.parenthesizedAssign = void 0, this.parenthesizedBind = void 0, this.doubleProto = void 0, this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
+	};
+	function f(t, e) {
+		var s = e.key.name, i = t[s], r = "true";
+		return "MethodDefinition" !== e.type || "get" !== e.kind && "set" !== e.kind || (r = (e.static ? "s" : "i") + e.kind), "iget" === i && "iset" === r || "iset" === i && "iget" === r || "sget" === i && "sset" === r || "sset" === i && "sget" === r ? (t[s] = "true", !1) : !!i || (t[s] = r, !1);
+	}
+	function x(t, e) {
+		var s = t.key;
+		return !t.computed && ("Identifier" === s.type && s.name === e || "Literal" === s.type && s.value === e);
+	}
+	var T = {
+		AbstractMethodHasImplementation: function(t) {
+			return "Method '" + t.methodName + "' cannot have an implementation because it is marked abstract.";
+		},
+		AbstractPropertyHasInitializer: function(t) {
+			return "Property '" + t.propertyName + "' cannot have an initializer because it is marked abstract.";
+		},
+		AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
+		AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+		CannotFindName: function(t) {
+			return "Cannot find name '" + t.name + "'.";
+		},
+		ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
+		ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
+		ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "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: function(t) {
+			return "'declare' is not allowed in " + t.kind + "ters.";
+		},
+		DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
+		DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+		DuplicateAccessibilityModifier: function() {
+			return "Accessibility modifier already seen.";
+		},
+		DuplicateModifier: function(t) {
+			return "Duplicate modifier: '" + t.modifier + "'.";
+		},
+		EmptyHeritageClauseType: function(t) {
+			return "'" + t.token + "' list cannot be empty.";
+		},
+		EmptyTypeArguments: "Type argument list cannot be empty.",
+		EmptyTypeParameters: "Type parameter list cannot be empty.",
+		ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
+		ImportAliasHasImportType: "An import alias can not use 'import type'.",
+		IncompatibleModifiers: function(t) {
+			var e = t.modifiers;
+			return "'" + e[0] + "' modifier cannot be used with '" + e[1] + "' modifier.";
+		},
+		IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
+		IndexSignatureHasAccessibility: function(t) {
+			return "Index signatures cannot have an accessibility modifier ('" + t.modifier + "').";
+		},
+		IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
+		IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
+		IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
+		InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
+		InvalidModifierOnTypeMember: function(t) {
+			return "'" + t.modifier + "' modifier cannot appear on a type member.";
+		},
+		InvalidModifierOnTypeParameter: function(t) {
+			return "'" + t.modifier + "' modifier cannot appear on a type parameter.";
+		},
+		InvalidModifierOnTypeParameterPositions: function(t) {
+			return "'" + t.modifier + "' modifier can only appear on a type parameter of a class, interface or type alias.";
+		},
+		InvalidModifiersOrder: function(t) {
+			var e = t.orderedModifiers;
+			return "'" + e[0] + "' modifier must precede '" + e[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.",
+		MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
+		NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
+		NonClassMethodPropertyHasAbstractModifer: "'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: function(t) {
+			return "Private elements cannot have an accessibility modifier ('" + t.modifier + "').";
+		},
+		PrivateMethodsHasAccessibility: function(t) {
+			return "Private methods cannot have an accessibility modifier ('" + t.modifier + "').";
+		},
+		ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
+		ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
+		ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
+		SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
+		SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
+		SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
+		SingleTypeParameterWithoutTrailingComma: function(t) {
+			var e = t.typeParameterName;
+			return "Single type parameter " + e + " should have a trailing comma. Example usage: <" + e + ",>.";
+		},
+		StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
+		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.",
+		GenericsEndWithComma: "Trailing comma is not allowed at the end of generics.",
+		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: function(t) {
+			return "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got " + t.type + ".";
+		},
+		LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations."
+	}, v = {
+		quot: "\"",
+		amp: "&",
+		apos: "'",
+		lt: "<",
+		gt: ">",
+		nbsp: "\xA0",
+		iexcl: "¡",
+		cent: "¢",
+		pound: "£",
+		curren: "¤",
+		yen: "¥",
+		brvbar: "¦",
+		sect: "§",
+		uml: "¨",
+		copy: "©",
+		ordf: "ª",
+		laquo: "«",
+		not: "¬",
+		shy: "­",
+		reg: "®",
+		macr: "¯",
+		deg: "°",
+		plusmn: "±",
+		sup2: "²",
+		sup3: "³",
+		acute: "´",
+		micro: "µ",
+		para: "¶",
+		middot: "·",
+		cedil: "¸",
+		sup1: "¹",
+		ordm: "º",
+		raquo: "»",
+		frac14: "¼",
+		frac12: "½",
+		frac34: "¾",
+		iquest: "¿",
+		Agrave: "À",
+		Aacute: "Á",
+		Acirc: "Â",
+		Atilde: "Ã",
+		Auml: "Ä",
+		Aring: "Å",
+		AElig: "Æ",
+		Ccedil: "Ç",
+		Egrave: "È",
+		Eacute: "É",
+		Ecirc: "Ê",
+		Euml: "Ë",
+		Igrave: "Ì",
+		Iacute: "Í",
+		Icirc: "Î",
+		Iuml: "Ï",
+		ETH: "Ð",
+		Ntilde: "Ñ",
+		Ograve: "Ò",
+		Oacute: "Ó",
+		Ocirc: "Ô",
+		Otilde: "Õ",
+		Ouml: "Ö",
+		times: "×",
+		Oslash: "Ø",
+		Ugrave: "Ù",
+		Uacute: "Ú",
+		Ucirc: "Û",
+		Uuml: "Ü",
+		Yacute: "Ý",
+		THORN: "Þ",
+		szlig: "ß",
+		agrave: "à",
+		aacute: "á",
+		acirc: "â",
+		atilde: "ã",
+		auml: "ä",
+		aring: "å",
+		aelig: "æ",
+		ccedil: "ç",
+		egrave: "è",
+		eacute: "é",
+		ecirc: "ê",
+		euml: "ë",
+		igrave: "ì",
+		iacute: "í",
+		icirc: "î",
+		iuml: "ï",
+		eth: "ð",
+		ntilde: "ñ",
+		ograve: "ò",
+		oacute: "ó",
+		ocirc: "ô",
+		otilde: "õ",
+		ouml: "ö",
+		divide: "÷",
+		oslash: "ø",
+		ugrave: "ù",
+		uacute: "ú",
+		ucirc: "û",
+		uuml: "ü",
+		yacute: "ý",
+		thorn: "þ",
+		yuml: "ÿ",
+		OElig: "Œ",
+		oelig: "œ",
+		Scaron: "Š",
+		scaron: "š",
+		Yuml: "Ÿ",
+		fnof: "ƒ",
+		circ: "ˆ",
+		tilde: "˜",
+		Alpha: "Α",
+		Beta: "Β",
+		Gamma: "Γ",
+		Delta: "Δ",
+		Epsilon: "Ε",
+		Zeta: "Ζ",
+		Eta: "Η",
+		Theta: "Θ",
+		Iota: "Ι",
+		Kappa: "Κ",
+		Lambda: "Λ",
+		Mu: "Μ",
+		Nu: "Ν",
+		Xi: "Ξ",
+		Omicron: "Ο",
+		Pi: "Π",
+		Rho: "Ρ",
+		Sigma: "Σ",
+		Tau: "Τ",
+		Upsilon: "Υ",
+		Phi: "Φ",
+		Chi: "Χ",
+		Psi: "Ψ",
+		Omega: "Ω",
+		alpha: "α",
+		beta: "β",
+		gamma: "γ",
+		delta: "δ",
+		epsilon: "ε",
+		zeta: "ζ",
+		eta: "η",
+		theta: "θ",
+		iota: "ι",
+		kappa: "κ",
+		lambda: "λ",
+		mu: "μ",
+		nu: "ν",
+		xi: "ξ",
+		omicron: "ο",
+		pi: "π",
+		rho: "ρ",
+		sigmaf: "ς",
+		sigma: "σ",
+		tau: "τ",
+		upsilon: "υ",
+		phi: "φ",
+		chi: "χ",
+		psi: "ψ",
+		omega: "ω",
+		thetasym: "ϑ",
+		upsih: "ϒ",
+		piv: "ϖ",
+		ensp: " ",
+		emsp: " ",
+		thinsp: " ",
+		zwnj: "‌",
+		zwj: "‍",
+		lrm: "‎",
+		rlm: "‏",
+		ndash: "–",
+		mdash: "—",
+		lsquo: "‘",
+		rsquo: "’",
+		sbquo: "‚",
+		ldquo: "“",
+		rdquo: "”",
+		bdquo: "„",
+		dagger: "†",
+		Dagger: "‡",
+		bull: "•",
+		hellip: "…",
+		permil: "‰",
+		prime: "′",
+		Prime: "″",
+		lsaquo: "‹",
+		rsaquo: "›",
+		oline: "‾",
+		frasl: "⁄",
+		euro: "€",
+		image: "ℑ",
+		weierp: "℘",
+		real: "ℜ",
+		trade: "™",
+		alefsym: "ℵ",
+		larr: "←",
+		uarr: "↑",
+		rarr: "→",
+		darr: "↓",
+		harr: "↔",
+		crarr: "↵",
+		lArr: "⇐",
+		uArr: "⇑",
+		rArr: "⇒",
+		dArr: "⇓",
+		hArr: "⇔",
+		forall: "∀",
+		part: "∂",
+		exist: "∃",
+		empty: "∅",
+		nabla: "∇",
+		isin: "∈",
+		notin: "∉",
+		ni: "∋",
+		prod: "∏",
+		sum: "∑",
+		minus: "−",
+		lowast: "∗",
+		radic: "√",
+		prop: "∝",
+		infin: "∞",
+		ang: "∠",
+		and: "∧",
+		or: "∨",
+		cap: "∩",
+		cup: "∪",
+		int: "∫",
+		there4: "∴",
+		sim: "∼",
+		cong: "≅",
+		asymp: "≈",
+		ne: "≠",
+		equiv: "≡",
+		le: "≤",
+		ge: "≥",
+		sub: "⊂",
+		sup: "⊃",
+		nsub: "⊄",
+		sube: "⊆",
+		supe: "⊇",
+		oplus: "⊕",
+		otimes: "⊗",
+		perp: "⊥",
+		sdot: "⋅",
+		lceil: "⌈",
+		rceil: "⌉",
+		lfloor: "⌊",
+		rfloor: "⌋",
+		lang: "〈",
+		rang: "〉",
+		loz: "◊",
+		spades: "♠",
+		clubs: "♣",
+		hearts: "♥",
+		diams: "♦"
+	}, P = /^[\da-fA-F]+$/, b = /^\d+$/;
+	function g(t) {
+		return t ? "JSXIdentifier" === t.type ? t.name : "JSXNamespacedName" === t.type ? t.namespace.name + ":" + t.name.name : "JSXMemberExpression" === t.type ? g(t.object) + "." + g(t.property) : void 0 : t;
+	}
+	var A = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+	function S(t) {
+		if (!t) throw new Error("Assert fail");
+	}
+	function k(t) {
+		return "accessor" === t;
+	}
+	function C(t) {
+		return "in" === t || "out" === t;
+	}
+	function E(t, e) {
+		return 2 | (t ? 4 : 0) | (e ? 8 : 0);
+	}
+	function I(t) {
+		if ("MemberExpression" !== t.type) return !1;
+		var e = t.property;
+		return (!t.computed || !("TemplateLiteral" !== e.type || e.expressions.length > 0)) && N(t.object);
+	}
+	function N(t) {
+		return "Identifier" === t.type || "MemberExpression" === t.type && !t.computed && N(t.object);
+	}
+	function w(t) {
+		return "private" === t || "public" === t || "protected" === t;
+	}
+	function L(e) {
+		var n = e || {}, o = n.dts, d = void 0 !== o && o, N = n.allowSatisfies, L = void 0 !== N && N;
+		return function(n$1) {
+			var o$1 = n$1.acorn || s, N$1 = function(e$1) {
+				var s = l.get(e$1.Parser.acorn || e$1);
+				if (!s) {
+					var i = {
+						assert: c(0, { startsExpr: p }),
+						asserts: c(0, { startsExpr: p }),
+						global: c(0, { startsExpr: p }),
+						keyof: c(0, { startsExpr: p }),
+						readonly: c(0, { startsExpr: p }),
+						unique: c(0, { startsExpr: p }),
+						abstract: c(0, { startsExpr: p }),
+						declare: c(0, { startsExpr: p }),
+						enum: c(0, { startsExpr: p }),
+						module: c(0, { startsExpr: p }),
+						namespace: c(0, { startsExpr: p }),
+						interface: c(0, { startsExpr: p }),
+						type: c(0, { startsExpr: p })
+					}, a = {
+						at: new t.TokenType("@"),
+						jsxName: new t.TokenType("jsxName"),
+						jsxText: new t.TokenType("jsxText", { beforeExpr: !0 }),
+						jsxTagStart: new t.TokenType("jsxTagStart", { startsExpr: !0 }),
+						jsxTagEnd: new t.TokenType("jsxTagEnd")
+					}, n$2 = {
+						tc_oTag: new t.TokContext("<tag", !1, !1),
+						tc_cTag: new t.TokContext("</tag", !1, !1),
+						tc_expr: new t.TokContext("<tag>...</tag>", !0, !0)
+					}, o$2 = /* @__PURE__ */ new RegExp("^(?:" + Object.keys(i).join("|") + ")$");
+					a.jsxTagStart.updateContext = function() {
+						this.context.push(n$2.tc_expr), this.context.push(n$2.tc_oTag), this.exprAllowed = !1;
+					}, a.jsxTagEnd.updateContext = function(e$2) {
+						var s$1 = this.context.pop();
+						s$1 === n$2.tc_oTag && e$2 === t.tokTypes.slash || s$1 === n$2.tc_cTag ? (this.context.pop(), this.exprAllowed = this.curContext() === n$2.tc_expr) : this.exprAllowed = !0;
+					}, s = {
+						tokTypes: r({}, i, a),
+						tokContexts: r({}, n$2),
+						keywordsRegExp: o$2,
+						tokenIsLiteralPropertyName: function(e$2) {
+							return [
+								t.tokTypes.name,
+								t.tokTypes.string,
+								t.tokTypes.num
+							].concat(Object.values(t.keywordTypes), Object.values(i)).includes(e$2);
+						},
+						tokenIsKeywordOrIdentifier: function(e$2) {
+							return [t.tokTypes.name].concat(Object.values(t.keywordTypes), Object.values(i)).includes(e$2);
+						},
+						tokenIsIdentifier: function(e$2) {
+							return [].concat(Object.values(i), [t.tokTypes.name]).includes(e$2);
+						},
+						tokenIsTSDeclarationStart: function(t) {
+							return [
+								i.abstract,
+								i.declare,
+								i.enum,
+								i.module,
+								i.namespace,
+								i.interface,
+								i.type
+							].includes(t);
+						},
+						tokenIsTSTypeOperator: function(t) {
+							return [
+								i.keyof,
+								i.readonly,
+								i.unique
+							].includes(t);
+						},
+						tokenIsTemplate: function(e$2) {
+							return e$2 === t.tokTypes.invalidTemplate;
+						}
+					};
+				}
+				return s;
+			}(o$1), M = o$1.tokTypes, O = o$1.keywordTypes, D = o$1.isIdentifierStart, _ = o$1.lineBreak, R = o$1.isNewLine, j = o$1.tokContexts, F = o$1.isIdentifierChar, B = N$1.tokTypes, H = N$1.tokContexts, q = N$1.keywordsRegExp, U = N$1.tokenIsLiteralPropertyName, V = N$1.tokenIsTemplate, K = N$1.tokenIsTSDeclarationStart, z = N$1.tokenIsIdentifier, J = N$1.tokenIsKeywordOrIdentifier, X = N$1.tokenIsTSTypeOperator;
+			function W(t, e$1, s) {
+				void 0 === s && (s = t.length);
+				for (var i = e$1; i < s; i++) {
+					var r = t.charCodeAt(i);
+					if (R(r)) return i < s - 1 && 13 === r && 10 === t.charCodeAt(i + 1) ? i + 2 : i + 1;
+				}
+				return -1;
+			}
+			n$1 = function(t, e$1, s) {
+				var i = s.tokTypes, r = e$1.tokTypes;
+				return function(t$1) {
+					function e$2() {
+						return t$1.apply(this, arguments) || this;
+					}
+					a(e$2, t$1);
+					var s$1 = e$2.prototype;
+					return s$1.takeDecorators = function(t$2) {
+						var e$3 = this.decoratorStack[this.decoratorStack.length - 1];
+						e$3.length && (t$2.decorators = e$3, this.resetStartLocationFromNode(t$2, e$3[0]), this.decoratorStack[this.decoratorStack.length - 1] = []);
+					}, s$1.parseDecorators = function(t$2) {
+						for (var e$3 = this.decoratorStack[this.decoratorStack.length - 1]; this.match(r.at);) {
+							var s$2 = this.parseDecorator();
+							e$3.push(s$2);
+						}
+						this.match(i._export) ? t$2 || this.unexpected() : this.canHaveLeadingDecorator() || this.raise(this.start, "Leading decorators must be attached to a class declaration.");
+					}, s$1.parseDecorator = function() {
+						var t$2 = this.startNode();
+						this.next(), this.decoratorStack.push([]);
+						var e$3, s$2 = this.start, r$1 = this.startLoc;
+						if (this.match(i.parenL)) {
+							var a = this.start, n$2 = this.startLoc;
+							if (this.next(), e$3 = this.parseExpression(), this.expect(i.parenR), this.options.preserveParens) {
+								var o$2 = this.startNodeAt(a, n$2);
+								o$2.expression = e$3, e$3 = this.finishNode(o$2, "ParenthesizedExpression");
+							}
+						} else for (e$3 = this.parseIdent(!1); this.eat(i.dot);) {
+							var h = this.startNodeAt(s$2, r$1);
+							h.object = e$3, h.property = this.parseIdent(!0), h.computed = !1, e$3 = this.finishNode(h, "MemberExpression");
+						}
+						return t$2.expression = this.parseMaybeDecoratorArguments(e$3), this.decoratorStack.pop(), this.finishNode(t$2, "Decorator");
+					}, s$1.parseMaybeDecoratorArguments = function(t$2) {
+						if (this.eat(i.parenL)) {
+							var e$3 = this.startNodeAtNode(t$2);
+							return e$3.callee = t$2, e$3.arguments = this.parseExprList(i.parenR, !1), this.finishNode(e$3, "CallExpression");
+						}
+						return t$2;
+					}, e$2;
+				}(t);
+			}(n$1, N$1, o$1), n$1 = function(t, e$1, s, i) {
+				var r = t.tokTypes, n$2 = e$1.tokTypes, o$2 = t.isNewLine, h = t.isIdentifierChar, p = Object.assign({
+					allowNamespaces: !0,
+					allowNamespacedObjects: !0
+				}, i || {});
+				return function(t$1) {
+					function e$2() {
+						return t$1.apply(this, arguments) || this;
+					}
+					a(e$2, t$1);
+					var s$1 = e$2.prototype;
+					return s$1.jsx_readToken = function() {
+						for (var t$2 = "", e$3 = this.pos;;) {
+							this.pos >= this.input.length && this.raise(this.start, "Unterminated JSX contents");
+							var s$2 = this.input.charCodeAt(this.pos);
+							switch (s$2) {
+								case 60:
+								case 123: return this.pos === this.start ? 60 === s$2 && this.exprAllowed ? (++this.pos, this.finishToken(n$2.jsxTagStart)) : this.getTokenFromCode(s$2) : (t$2 += this.input.slice(e$3, this.pos), this.finishToken(n$2.jsxText, t$2));
+								case 38:
+									t$2 += this.input.slice(e$3, this.pos), t$2 += this.jsx_readEntity(), e$3 = this.pos;
+									break;
+								case 62:
+								case 125: this.raise(this.pos, "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" + (62 === s$2 ? "&gt;" : "&rbrace;") + "` or `{\"" + this.input[this.pos] + "\"}`?");
+								default: o$2(s$2) ? (t$2 += this.input.slice(e$3, this.pos), t$2 += this.jsx_readNewLine(!0), e$3 = this.pos) : ++this.pos;
+							}
+						}
+					}, s$1.jsx_readNewLine = function(t$2) {
+						var e$3, s$2 = this.input.charCodeAt(this.pos);
+						return ++this.pos, 13 === s$2 && 10 === this.input.charCodeAt(this.pos) ? (++this.pos, e$3 = t$2 ? "\n" : "\r\n") : e$3 = String.fromCharCode(s$2), this.options.locations && (++this.curLine, this.lineStart = this.pos), e$3;
+					}, s$1.jsx_readString = function(t$2) {
+						for (var e$3 = "", s$2 = ++this.pos;;) {
+							this.pos >= this.input.length && this.raise(this.start, "Unterminated string constant");
+							var i$1 = this.input.charCodeAt(this.pos);
+							if (i$1 === t$2) break;
+							38 === i$1 ? (e$3 += this.input.slice(s$2, this.pos), e$3 += this.jsx_readEntity(), s$2 = this.pos) : o$2(i$1) ? (e$3 += this.input.slice(s$2, this.pos), e$3 += this.jsx_readNewLine(!1), s$2 = this.pos) : ++this.pos;
+						}
+						return e$3 += this.input.slice(s$2, this.pos++), this.finishToken(r.string, e$3);
+					}, s$1.jsx_readEntity = function() {
+						var t$2, e$3 = "", s$2 = 0, i$1 = this.input[this.pos];
+						"&" !== i$1 && this.raise(this.pos, "Entity must start with an ampersand");
+						for (var r$1 = ++this.pos; this.pos < this.input.length && s$2++ < 10;) {
+							if (";" === (i$1 = this.input[this.pos++])) {
+								"#" === e$3[0] ? "x" === e$3[1] ? (e$3 = e$3.substr(2), P.test(e$3) && (t$2 = String.fromCharCode(parseInt(e$3, 16)))) : (e$3 = e$3.substr(1), b.test(e$3) && (t$2 = String.fromCharCode(parseInt(e$3, 10)))) : t$2 = v[e$3];
+								break;
+							}
+							e$3 += i$1;
+						}
+						return t$2 || (this.pos = r$1, "&");
+					}, s$1.jsx_readWord = function() {
+						var t$2, e$3 = this.pos;
+						do
+							t$2 = this.input.charCodeAt(++this.pos);
+						while (h(t$2) || 45 === t$2);
+						return this.finishToken(n$2.jsxName, this.input.slice(e$3, this.pos));
+					}, s$1.jsx_parseIdentifier = function() {
+						var t$2 = this.startNode();
+						return this.type === n$2.jsxName ? t$2.name = this.value : this.type.keyword ? t$2.name = this.type.keyword : this.unexpected(), this.next(), this.finishNode(t$2, "JSXIdentifier");
+					}, s$1.jsx_parseNamespacedName = function() {
+						var t$2 = this.start, e$3 = this.startLoc, s$2 = this.jsx_parseIdentifier();
+						if (!p.allowNamespaces || !this.eat(r.colon)) return s$2;
+						var i$1 = this.startNodeAt(t$2, e$3);
+						return i$1.namespace = s$2, i$1.name = this.jsx_parseIdentifier(), this.finishNode(i$1, "JSXNamespacedName");
+					}, s$1.jsx_parseElementName = function() {
+						if (this.type === n$2.jsxTagEnd) return "";
+						var t$2 = this.start, e$3 = this.startLoc, s$2 = this.jsx_parseNamespacedName();
+						for (this.type !== r.dot || "JSXNamespacedName" !== s$2.type || p.allowNamespacedObjects || this.unexpected(); this.eat(r.dot);) {
+							var i$1 = this.startNodeAt(t$2, e$3);
+							i$1.object = s$2, i$1.property = this.jsx_parseIdentifier(), s$2 = this.finishNode(i$1, "JSXMemberExpression");
+						}
+						return s$2;
+					}, s$1.jsx_parseAttributeValue = function() {
+						switch (this.type) {
+							case r.braceL:
+								var t$2 = this.jsx_parseExpressionContainer();
+								return "JSXEmptyExpression" === t$2.expression.type && this.raise(t$2.start, "JSX attributes must only be assigned a non-empty expression"), t$2;
+							case n$2.jsxTagStart:
+							case r.string: return this.parseExprAtom();
+							default: this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
+						}
+					}, s$1.jsx_parseEmptyExpression = function() {
+						var t$2 = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+						return this.finishNodeAt(t$2, "JSXEmptyExpression", this.start, this.startLoc);
+					}, s$1.jsx_parseExpressionContainer = function() {
+						var t$2 = this.startNode();
+						return this.next(), t$2.expression = this.type === r.braceR ? this.jsx_parseEmptyExpression() : this.parseExpression(), this.expect(r.braceR), this.finishNode(t$2, "JSXExpressionContainer");
+					}, s$1.jsx_parseAttribute = function() {
+						var t$2 = this.startNode();
+						return this.eat(r.braceL) ? (this.expect(r.ellipsis), t$2.argument = this.parseMaybeAssign(), this.expect(r.braceR), this.finishNode(t$2, "JSXSpreadAttribute")) : (t$2.name = this.jsx_parseNamespacedName(), t$2.value = this.eat(r.eq) ? this.jsx_parseAttributeValue() : null, this.finishNode(t$2, "JSXAttribute"));
+					}, s$1.jsx_parseOpeningElementAt = function(t$2, e$3) {
+						var s$2 = this.startNodeAt(t$2, e$3);
+						s$2.attributes = [];
+						var i$1 = this.jsx_parseElementName();
+						for (i$1 && (s$2.name = i$1); this.type !== r.slash && this.type !== n$2.jsxTagEnd;) s$2.attributes.push(this.jsx_parseAttribute());
+						return s$2.selfClosing = this.eat(r.slash), this.expect(n$2.jsxTagEnd), this.finishNode(s$2, i$1 ? "JSXOpeningElement" : "JSXOpeningFragment");
+					}, s$1.jsx_parseClosingElementAt = function(t$2, e$3) {
+						var s$2 = this.startNodeAt(t$2, e$3), i$1 = this.jsx_parseElementName();
+						return i$1 && (s$2.name = i$1), this.expect(n$2.jsxTagEnd), this.finishNode(s$2, i$1 ? "JSXClosingElement" : "JSXClosingFragment");
+					}, s$1.jsx_parseElementAt = function(t$2, e$3) {
+						var s$2 = this.startNodeAt(t$2, e$3), i$1 = [], a = this.jsx_parseOpeningElementAt(t$2, e$3), o$3 = null;
+						if (!a.selfClosing) {
+							t: for (;;) switch (this.type) {
+								case n$2.jsxTagStart:
+									if (t$2 = this.start, e$3 = this.startLoc, this.next(), this.eat(r.slash)) {
+										o$3 = this.jsx_parseClosingElementAt(t$2, e$3);
+										break t;
+									}
+									i$1.push(this.jsx_parseElementAt(t$2, e$3));
+									break;
+								case n$2.jsxText:
+									i$1.push(this.parseExprAtom());
+									break;
+								case r.braceL:
+									i$1.push(this.jsx_parseExpressionContainer());
+									break;
+								default: this.unexpected();
+							}
+							g(o$3.name) !== g(a.name) && this.raise(o$3.start, "Expected corresponding JSX closing tag for <" + g(a.name) + ">");
+						}
+						var h$1 = a.name ? "Element" : "Fragment";
+						return s$2["opening" + h$1] = a, s$2["closing" + h$1] = o$3, s$2.children = i$1, this.type === r.relational && "<" === this.value && this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag"), this.finishNode(s$2, "JSX" + h$1);
+					}, s$1.jsx_parseText = function() {
+						var t$2 = this.parseLiteral(this.value);
+						return t$2.type = "JSXText", t$2;
+					}, s$1.jsx_parseElement = function() {
+						var t$2 = this.start, e$3 = this.startLoc;
+						return this.next(), this.jsx_parseElementAt(t$2, e$3);
+					}, e$2;
+				}(s);
+			}(o$1, N$1, n$1, null == e ? void 0 : e.jsx), n$1 = function(t, e$1, s) {
+				var i = e$1.tokTypes, r = s.tokTypes;
+				return function(t$1) {
+					function e$2() {
+						return t$1.apply(this, arguments) || this;
+					}
+					a(e$2, t$1);
+					var s$1 = e$2.prototype;
+					return s$1.parseMaybeImportAttributes = function(t$2) {
+						if (this.type === r._with || this.type === i.assert) {
+							this.next();
+							var e$3 = this.parseImportAttributes();
+							e$3 && (t$2.attributes = e$3);
+						}
+					}, s$1.parseImportAttributes = function() {
+						this.expect(r.braceL);
+						var t$2 = this.parseWithEntries();
+						return this.expect(r.braceR), t$2;
+					}, s$1.parseWithEntries = function() {
+						var t$2 = [], e$3 = /* @__PURE__ */ new Set();
+						do {
+							if (this.type === r.braceR) break;
+							var s$2, i$1 = this.startNode();
+							s$2 = this.type === r.string ? this.parseLiteral(this.value) : this.parseIdent(!0), this.next(), i$1.key = s$2, e$3.has(i$1.key.name) && this.raise(this.pos, "Duplicated key in attributes"), e$3.add(i$1.key.name), this.type !== r.string && this.raise(this.pos, "Only string is supported as an attribute value"), i$1.value = this.parseLiteral(this.value), t$2.push(this.finishNode(i$1, "ImportAttribute"));
+						} while (this.eat(r.comma));
+						return t$2;
+					}, e$2;
+				}(t);
+			}(n$1, N$1, o$1);
+			return /* @__PURE__ */ function(t) {
+				function e$1(e$2, s$1, i) {
+					var r$1;
+					return (r$1 = t.call(this, e$2, s$1, i) || this).preValue = null, r$1.preToken = null, r$1.isLookahead = !1, r$1.isAmbientContext = !1, r$1.inAbstractClass = !1, r$1.inType = !1, r$1.inDisallowConditionalTypesContext = !1, r$1.maybeInArrowParameters = !1, r$1.shouldParseArrowReturnType = void 0, r$1.shouldParseAsyncArrowReturnType = void 0, r$1.decoratorStack = [[]], r$1.importsStack = [[]], r$1.importOrExportOuterKind = void 0, r$1.tsParseConstModifier = r$1.tsParseModifiers.bind(function(t$1) {
+						if (void 0 === t$1) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+						return t$1;
+					}(r$1), {
+						allowedModifiers: ["const"],
+						disallowedModifiers: ["in", "out"],
+						errorTemplate: T.InvalidModifierOnTypeParameterPositions
+					}), r$1;
+				}
+				a(e$1, t);
+				var s, r, n$2, p = e$1.prototype;
+				return p.getTokenFromCodeInType = function(e$2) {
+					return 62 === e$2 || 60 === e$2 ? this.finishOp(M.relational, 1) : t.prototype.getTokenFromCode.call(this, e$2);
+				}, p.readToken = function(e$2) {
+					if (!this.inType) {
+						var s$1 = this.curContext();
+						if (s$1 === H.tc_expr) return this.jsx_readToken();
+						if (s$1 === H.tc_oTag || s$1 === H.tc_cTag) {
+							if (D(e$2)) return this.jsx_readWord();
+							if (62 == e$2) return ++this.pos, this.finishToken(B.jsxTagEnd);
+							if ((34 === e$2 || 39 === e$2) && s$1 == H.tc_oTag) return this.jsx_readString(e$2);
+						}
+						if (60 === e$2 && this.exprAllowed && 33 !== this.input.charCodeAt(this.pos + 1)) return ++this.pos, this.finishToken(B.jsxTagStart);
+					}
+					return t.prototype.readToken.call(this, e$2);
+				}, p.getTokenFromCode = function(e$2) {
+					return this.inType ? this.getTokenFromCodeInType(e$2) : 64 === e$2 ? (++this.pos, this.finishToken(B.at)) : t.prototype.getTokenFromCode.call(this, e$2);
+				}, p.isAbstractClass = function() {
+					return this.ts_isContextual(B.abstract) && this.lookahead().type === M._class;
+				}, p.finishNode = function(e$2, s$1) {
+					return "" !== e$2.type && 0 !== e$2.end ? e$2 : t.prototype.finishNode.call(this, e$2, s$1);
+				}, p.tryParse = function(t$1, e$2) {
+					void 0 === e$2 && (e$2 = this.cloneCurLookaheadState());
+					var s$1 = { node: null };
+					try {
+						return {
+							node: t$1(function(t$2) {
+								throw void 0 === t$2 && (t$2 = null), s$1.node = t$2, s$1;
+							}),
+							error: null,
+							thrown: !1,
+							aborted: !1,
+							failState: null
+						};
+					} catch (t$2) {
+						var i = this.getCurLookaheadState();
+						if (this.setLookaheadState(e$2), t$2 instanceof SyntaxError) return {
+							node: null,
+							error: t$2,
+							thrown: !0,
+							aborted: !1,
+							failState: i
+						};
+						if (t$2 === s$1) return {
+							node: s$1.node,
+							error: null,
+							thrown: !1,
+							aborted: !0,
+							failState: i
+						};
+						throw t$2;
+					}
+				}, p.setOptionalParametersError = function(t$1, e$2) {
+					var s$1;
+					t$1.optionalParametersLoc = null != (s$1 = null == e$2 ? void 0 : e$2.loc) ? s$1 : this.startLoc;
+				}, p.reScan_lt_gt = function() {
+					this.type === M.relational && (this.pos -= 1, this.readToken_lt_gt(this.fullCharCodeAtPos()));
+				}, p.reScan_lt = function() {
+					var t$1 = this.type;
+					return t$1 === M.bitShift ? (this.pos -= 2, this.finishOp(M.relational, 1), M.relational) : t$1;
+				}, p.resetEndLocation = function(t$1, e$2) {
+					void 0 === e$2 && (e$2 = this.lastTokEndLoc), t$1.end = e$2.column, t$1.loc.end = e$2, this.options.ranges && (t$1.range[1] = e$2.column);
+				}, p.startNodeAtNode = function(e$2) {
+					return t.prototype.startNodeAt.call(this, e$2.start, e$2.loc.start);
+				}, p.nextTokenStart = function() {
+					return this.nextTokenStartSince(this.pos);
+				}, p.tsHasSomeModifiers = function(t$1, e$2) {
+					return e$2.some(function(e$3) {
+						return w(e$3) ? t$1.accessibility === e$3 : !!t$1[e$3];
+					});
+				}, p.tsIsStartOfStaticBlocks = function() {
+					return this.isContextual("static") && 123 === this.lookaheadCharCode();
+				}, p.tsCheckForInvalidTypeCasts = function(t$1) {
+					var e$2 = this;
+					t$1.forEach(function(t$2) {
+						"TSTypeCastExpression" === (null == t$2 ? void 0 : t$2.type) && e$2.raise(t$2.typeAnnotation.start, T.UnexpectedTypeAnnotation);
+					});
+				}, p.atPossibleAsyncArrow = function(t$1) {
+					return "Identifier" === t$1.type && "async" === t$1.name && this.lastTokEndLoc.column === t$1.end && !this.canInsertSemicolon() && t$1.end - t$1.start == 5 && t$1.start === this.potentialArrowAt;
+				}, p.tsIsIdentifier = function() {
+					return z(this.type);
+				}, p.tsTryParseTypeOrTypePredicateAnnotation = function() {
+					return this.match(M.colon) ? this.tsParseTypeOrTypePredicateAnnotation(M.colon) : void 0;
+				}, p.tsTryParseGenericAsyncArrowFunction = function(e$2, s$1, i) {
+					var r$1 = this;
+					if (this.tsMatchLeftRelational()) {
+						var a = this.maybeInArrowParameters;
+						this.maybeInArrowParameters = !0;
+						var n$3 = this.tsTryParseAndCatch(function() {
+							var i$1 = r$1.startNodeAt(e$2, s$1);
+							return i$1.typeParameters = r$1.tsParseTypeParameters(), t.prototype.parseFunctionParams.call(r$1, i$1), i$1.returnType = r$1.tsTryParseTypeOrTypePredicateAnnotation(), r$1.expect(M.arrow), i$1;
+						});
+						if (this.maybeInArrowParameters = a, n$3) return t.prototype.parseArrowExpression.call(this, n$3, null, !0, i);
+					}
+				}, p.tsParseTypeArgumentsInExpression = function() {
+					if (this.reScan_lt() === M.relational) return this.tsParseTypeArguments();
+				}, p.tsInNoContext = function(t$1) {
+					var e$2 = this.context;
+					this.context = [e$2[0]];
+					try {
+						return t$1();
+					} finally {
+						this.context = e$2;
+					}
+				}, p.tsTryParseTypeAnnotation = function() {
+					return this.match(M.colon) ? this.tsParseTypeAnnotation() : void 0;
+				}, p.isUnparsedContextual = function(t$1, e$2) {
+					var s$1 = t$1 + e$2.length;
+					if (this.input.slice(t$1, s$1) === e$2) {
+						var i = this.input.charCodeAt(s$1);
+						return !(F(i) || 55296 == (64512 & i));
+					}
+					return !1;
+				}, p.isAbstractConstructorSignature = function() {
+					return this.ts_isContextual(B.abstract) && this.lookahead().type === M._new;
+				}, p.nextTokenStartSince = function(t$1) {
+					return A.lastIndex = t$1, A.test(this.input) ? A.lastIndex : t$1;
+				}, p.lookaheadCharCode = function() {
+					return this.input.charCodeAt(this.nextTokenStart());
+				}, p.compareLookaheadState = function(t$1, e$2) {
+					for (var s$1 = 0, i = Object.keys(t$1); s$1 < i.length; s$1++) {
+						var r$1 = i[s$1];
+						if (t$1[r$1] !== e$2[r$1]) return !1;
+					}
+					return !0;
+				}, p.createLookaheadState = function() {
+					this.value = null, this.context = [this.curContext()];
+				}, p.getCurLookaheadState = function() {
+					return {
+						endLoc: this.endLoc,
+						lastTokEnd: this.lastTokEnd,
+						lastTokStart: this.lastTokStart,
+						lastTokStartLoc: this.lastTokStartLoc,
+						pos: this.pos,
+						value: this.value,
+						type: this.type,
+						start: this.start,
+						end: this.end,
+						context: this.context,
+						startLoc: this.startLoc,
+						lastTokEndLoc: this.lastTokEndLoc,
+						curLine: this.curLine,
+						lineStart: this.lineStart,
+						curPosition: this.curPosition,
+						containsEsc: this.containsEsc
+					};
+				}, p.cloneCurLookaheadState = function() {
+					return {
+						pos: this.pos,
+						value: this.value,
+						type: this.type,
+						start: this.start,
+						end: this.end,
+						context: this.context && this.context.slice(),
+						startLoc: this.startLoc,
+						lastTokEndLoc: this.lastTokEndLoc,
+						endLoc: this.endLoc,
+						lastTokEnd: this.lastTokEnd,
+						lastTokStart: this.lastTokStart,
+						lastTokStartLoc: this.lastTokStartLoc,
+						curLine: this.curLine,
+						lineStart: this.lineStart,
+						curPosition: this.curPosition,
+						containsEsc: this.containsEsc
+					};
+				}, p.setLookaheadState = function(t$1) {
+					this.pos = t$1.pos, this.value = t$1.value, this.endLoc = t$1.endLoc, this.lastTokEnd = t$1.lastTokEnd, this.lastTokStart = t$1.lastTokStart, this.lastTokStartLoc = t$1.lastTokStartLoc, this.type = t$1.type, this.start = t$1.start, this.end = t$1.end, this.context = t$1.context, this.startLoc = t$1.startLoc, this.lastTokEndLoc = t$1.lastTokEndLoc, this.curLine = t$1.curLine, this.lineStart = t$1.lineStart, this.curPosition = t$1.curPosition, this.containsEsc = t$1.containsEsc;
+				}, p.tsLookAhead = function(t$1) {
+					var e$2 = this.getCurLookaheadState(), s$1 = t$1();
+					return this.setLookaheadState(e$2), s$1;
+				}, p.lookahead = function(t$1) {
+					var e$2 = this.getCurLookaheadState();
+					if (this.createLookaheadState(), this.isLookahead = !0, void 0 !== t$1) for (var s$1 = 0; s$1 < t$1; s$1++) this.nextToken();
+					else this.nextToken();
+					this.isLookahead = !1;
+					var i = this.getCurLookaheadState();
+					return this.setLookaheadState(e$2), i;
+				}, p.readWord = function() {
+					var t$1 = this.readWord1(), e$2 = M.name;
+					return this.keywords.test(t$1) ? e$2 = O[t$1] : new RegExp(q).test(t$1) && (e$2 = B[t$1]), this.finishToken(e$2, t$1);
+				}, p.skipBlockComment = function() {
+					var t$1;
+					this.isLookahead || (t$1 = this.options.onComment && this.curPosition());
+					var e$2 = this.pos, s$1 = this.input.indexOf("*/", this.pos += 2);
+					if (-1 === s$1 && this.raise(this.pos - 2, "Unterminated comment"), this.pos = s$1 + 2, this.options.locations) for (var i, r$1 = e$2; (i = W(this.input, r$1, this.pos)) > -1;) ++this.curLine, r$1 = this.lineStart = i;
+					this.isLookahead || this.options.onComment && this.options.onComment(!0, this.input.slice(e$2 + 2, s$1), e$2, this.pos, t$1, this.curPosition());
+				}, p.skipLineComment = function(t$1) {
+					var e$2, s$1 = this.pos;
+					this.isLookahead || (e$2 = this.options.onComment && this.curPosition());
+					for (var i = this.input.charCodeAt(this.pos += t$1); this.pos < this.input.length && !R(i);) i = this.input.charCodeAt(++this.pos);
+					this.isLookahead || this.options.onComment && this.options.onComment(!1, this.input.slice(s$1 + t$1, this.pos), s$1, this.pos, e$2, this.curPosition());
+				}, p.finishToken = function(t$1, e$2) {
+					this.preValue = this.value, this.preToken = this.type, this.end = this.pos, this.options.locations && (this.endLoc = this.curPosition());
+					var s$1 = this.type;
+					this.type = t$1, this.value = e$2, this.isLookahead || this.updateContext(s$1);
+				}, p.resetStartLocation = function(t$1, e$2, s$1) {
+					t$1.start = e$2, t$1.loc.start = s$1, this.options.ranges && (t$1.range[0] = e$2);
+				}, p.isLineTerminator = function() {
+					return this.eat(M.semi) || t.prototype.canInsertSemicolon.call(this);
+				}, p.hasFollowingLineBreak = function() {
+					return m.lastIndex = this.end, m.test(this.input);
+				}, p.addExtra = function(t$1, e$2, s$1, i) {
+					if (void 0 === i && (i = !0), t$1) {
+						var r$1 = t$1.extra = t$1.extra || {};
+						i ? r$1[e$2] = s$1 : Object.defineProperty(r$1, e$2, {
+							enumerable: i,
+							value: s$1
+						});
+					}
+				}, p.isLiteralPropertyName = function() {
+					return U(this.type);
+				}, p.hasPrecedingLineBreak = function() {
+					return _.test(this.input.slice(this.lastTokEndLoc.index, this.start));
+				}, p.createIdentifier = function(t$1, e$2) {
+					return t$1.name = e$2, this.finishNode(t$1, "Identifier");
+				}, p.resetStartLocationFromNode = function(t$1, e$2) {
+					this.resetStartLocation(t$1, e$2.start, e$2.loc.start);
+				}, p.isThisParam = function(t$1) {
+					return "Identifier" === t$1.type && "this" === t$1.name;
+				}, p.isLookaheadContextual = function(t$1) {
+					var e$2 = this.nextTokenStart();
+					return this.isUnparsedContextual(e$2, t$1);
+				}, p.ts_type_isContextual = function(t$1, e$2) {
+					return t$1 === e$2 && !this.containsEsc;
+				}, p.ts_isContextual = function(t$1) {
+					return this.type === t$1 && !this.containsEsc;
+				}, p.ts_isContextualWithState = function(t$1, e$2) {
+					return t$1.type === e$2 && !t$1.containsEsc;
+				}, p.isContextualWithState = function(t$1, e$2) {
+					return e$2.type === M.name && e$2.value === t$1 && !e$2.containsEsc;
+				}, p.tsIsStartOfMappedType = function() {
+					return this.next(), this.eat(M.plusMin) ? this.ts_isContextual(B.readonly) : (this.ts_isContextual(B.readonly) && this.next(), !!this.match(M.bracketL) && (this.next(), !!this.tsIsIdentifier() && (this.next(), this.match(M._in))));
+				}, p.tsInDisallowConditionalTypesContext = function(t$1) {
+					var e$2 = this.inDisallowConditionalTypesContext;
+					this.inDisallowConditionalTypesContext = !0;
+					try {
+						return t$1();
+					} finally {
+						this.inDisallowConditionalTypesContext = e$2;
+					}
+				}, p.tsTryParseType = function() {
+					return this.tsEatThenParseType(M.colon);
+				}, p.match = function(t$1) {
+					return this.type === t$1;
+				}, p.matchJsx = function(t$1) {
+					return this.type === N$1.tokTypes[t$1];
+				}, p.ts_eatWithState = function(t$1, e$2, s$1) {
+					if (t$1 === s$1.type) {
+						for (var i = 0; i < e$2; i++) this.next();
+						return !0;
+					}
+					return !1;
+				}, p.ts_eatContextualWithState = function(t$1, e$2, s$1) {
+					if (q.test(t$1)) {
+						if (this.ts_isContextualWithState(s$1, B[t$1])) {
+							for (var i = 0; i < e$2; i++) this.next();
+							return !0;
+						}
+						return !1;
+					}
+					if (!this.isContextualWithState(t$1, s$1)) return !1;
+					for (var r$1 = 0; r$1 < e$2; r$1++) this.next();
+					return !0;
+				}, p.canHaveLeadingDecorator = function() {
+					return this.match(M._class);
+				}, p.eatContextual = function(e$2) {
+					return q.test(e$2) ? !!this.ts_isContextual(B[e$2]) && (this.next(), !0) : t.prototype.eatContextual.call(this, e$2);
+				}, p.tsIsExternalModuleReference = function() {
+					return this.isContextual("require") && 40 === this.lookaheadCharCode();
+				}, p.tsParseExternalModuleReference = function() {
+					var t$1 = this.startNode();
+					return this.expectContextual("require"), this.expect(M.parenL), this.match(M.string) || this.unexpected(), t$1.expression = this.parseExprAtom(), this.expect(M.parenR), this.finishNode(t$1, "TSExternalModuleReference");
+				}, p.tsParseEntityName = function(t$1) {
+					void 0 === t$1 && (t$1 = !0);
+					for (var e$2 = this.parseIdent(t$1); this.eat(M.dot);) {
+						var s$1 = this.startNodeAtNode(e$2);
+						s$1.left = e$2, s$1.right = this.parseIdent(t$1), e$2 = this.finishNode(s$1, "TSQualifiedName");
+					}
+					return e$2;
+				}, p.tsParseEnumMember = function() {
+					var t$1 = this.startNode();
+					return t$1.id = this.match(M.string) ? this.parseLiteral(this.value) : this.parseIdent(!0), this.eat(M.eq) && (t$1.initializer = this.parseMaybeAssign()), this.finishNode(t$1, "TSEnumMember");
+				}, p.tsParseEnumDeclaration = function(t$1, e$2) {
+					return void 0 === e$2 && (e$2 = {}), e$2.const && (t$1.const = !0), e$2.declare && (t$1.declare = !0), this.expectContextual("enum"), t$1.id = this.parseIdent(), this.checkLValSimple(t$1.id), this.expect(M.braceL), t$1.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)), this.expect(M.braceR), this.finishNode(t$1, "TSEnumDeclaration");
+				}, p.tsParseModuleBlock = function() {
+					var e$2 = this.startNode();
+					for (t.prototype.enterScope.call(this, 512), this.expect(M.braceL), e$2.body = []; this.type !== M.braceR;) {
+						var s$1 = this.parseStatement(null, !0);
+						e$2.body.push(s$1);
+					}
+					return this.next(), t.prototype.exitScope.call(this), this.finishNode(e$2, "TSModuleBlock");
+				}, p.tsParseAmbientExternalModuleDeclaration = function(e$2) {
+					return this.ts_isContextual(B.global) ? (e$2.global = !0, e$2.id = this.parseIdent()) : this.match(M.string) ? e$2.id = this.parseLiteral(this.value) : this.unexpected(), this.match(M.braceL) ? (t.prototype.enterScope.call(this, u), e$2.body = this.tsParseModuleBlock(), t.prototype.exitScope.call(this)) : t.prototype.semicolon.call(this), this.finishNode(e$2, "TSModuleDeclaration");
+				}, p.tsTryParseDeclare = function(t$1) {
+					var e$2 = this;
+					if (!this.isLineTerminator()) {
+						var s$1, i = this.type;
+						return this.isContextual("let") && (i = M._var, s$1 = "let"), this.tsInAmbientContext(function() {
+							if (i === M._function) return t$1.declare = !0, e$2.parseFunctionStatement(t$1, !1, !0);
+							if (i === M._class) return t$1.declare = !0, e$2.parseClass(t$1, !0);
+							if (i === B.enum) return e$2.tsParseEnumDeclaration(t$1, { declare: !0 });
+							if (i === B.global) return e$2.tsParseAmbientExternalModuleDeclaration(t$1);
+							if (i === M._const || i === M._var) return e$2.match(M._const) && e$2.isLookaheadContextual("enum") ? (e$2.expect(M._const), e$2.tsParseEnumDeclaration(t$1, {
+								const: !0,
+								declare: !0
+							})) : (t$1.declare = !0, e$2.parseVarStatement(t$1, s$1 || e$2.value, !0));
+							if (i === B.interface) {
+								var r$1 = e$2.tsParseInterfaceDeclaration(t$1, { declare: !0 });
+								if (r$1) return r$1;
+							}
+							return z(i) ? e$2.tsParseDeclaration(t$1, e$2.value, !0) : void 0;
+						});
+					}
+				}, p.tsIsListTerminator = function(t$1) {
+					switch (t$1) {
+						case "EnumMembers":
+						case "TypeMembers": return this.match(M.braceR);
+						case "HeritageClauseElement": return this.match(M.braceL);
+						case "TupleElementTypes": return this.match(M.bracketR);
+						case "TypeParametersOrArguments": return this.tsMatchRightRelational();
+					}
+				}, p.tsParseDelimitedListWorker = function(t$1, e$2, s$1, i) {
+					for (var r$1 = [], a = -1; !this.tsIsListTerminator(t$1);) {
+						a = -1;
+						var n$3 = e$2();
+						if (null == n$3) return;
+						if (r$1.push(n$3), !this.eat(M.comma)) {
+							if (this.tsIsListTerminator(t$1)) break;
+							s$1 && this.expect(M.comma);
+							return;
+						}
+						a = this.lastTokStart;
+					}
+					return i && (i.value = a), r$1;
+				}, p.tsParseDelimitedList = function(t$1, e$2, s$1) {
+					return function(t$2) {
+						if (null == t$2) throw new Error("Unexpected " + t$2 + " value.");
+						return t$2;
+					}(this.tsParseDelimitedListWorker(t$1, e$2, !0, s$1));
+				}, p.tsParseBracketedList = function(t$1, e$2, s$1, i, r$1) {
+					i || this.expect(s$1 ? M.bracketL : M.relational);
+					var a = this.tsParseDelimitedList(t$1, e$2, r$1);
+					return this.expect(s$1 ? M.bracketR : M.relational), a;
+				}, p.tsParseTypeParameterName = function() {
+					return this.parseIdent().name;
+				}, p.tsEatThenParseType = function(t$1) {
+					return this.match(t$1) ? this.tsNextThenParseType() : void 0;
+				}, p.tsExpectThenParseType = function(t$1) {
+					var e$2 = this;
+					return this.tsDoThenParseType(function() {
+						return e$2.expect(t$1);
+					});
+				}, p.tsNextThenParseType = function() {
+					var t$1 = this;
+					return this.tsDoThenParseType(function() {
+						return t$1.next();
+					});
+				}, p.tsDoThenParseType = function(t$1) {
+					var e$2 = this;
+					return this.tsInType(function() {
+						return t$1(), e$2.tsParseType();
+					});
+				}, p.tsSkipParameterStart = function() {
+					if (z(this.type) || this.match(M._this)) return this.next(), !0;
+					if (this.match(M.braceL)) try {
+						return this.parseObj(!0), !0;
+					} catch (t$1) {
+						return !1;
+					}
+					if (this.match(M.bracketL)) {
+						this.next();
+						try {
+							return this.parseBindingList(M.bracketR, !0, !0), !0;
+						} catch (t$1) {
+							return !1;
+						}
+					}
+					return !1;
+				}, p.tsIsUnambiguouslyStartOfFunctionType = function() {
+					if (this.next(), this.match(M.parenR) || this.match(M.ellipsis)) return !0;
+					if (this.tsSkipParameterStart()) {
+						if (this.match(M.colon) || this.match(M.comma) || this.match(M.question) || this.match(M.eq)) return !0;
+						if (this.match(M.parenR) && (this.next(), this.match(M.arrow))) return !0;
+					}
+					return !1;
+				}, p.tsIsStartOfFunctionType = function() {
+					return !!this.tsMatchLeftRelational() || this.match(M.parenL) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
+				}, p.tsInAllowConditionalTypesContext = function(t$1) {
+					var e$2 = this.inDisallowConditionalTypesContext;
+					this.inDisallowConditionalTypesContext = !1;
+					try {
+						return t$1();
+					} finally {
+						this.inDisallowConditionalTypesContext = e$2;
+					}
+				}, p.tsParseBindingListForSignature = function() {
+					var e$2 = this;
+					return t.prototype.parseBindingList.call(this, M.parenR, !0, !0).map(function(t$1) {
+						return "Identifier" !== t$1.type && "RestElement" !== t$1.type && "ObjectPattern" !== t$1.type && "ArrayPattern" !== t$1.type && e$2.raise(t$1.start, T.UnsupportedSignatureParameterKind(t$1.type)), t$1;
+					});
+				}, p.tsParseTypePredicateAsserts = function() {
+					if (this.type !== B.asserts) return !1;
+					var t$1 = this.containsEsc;
+					return this.next(), !(!z(this.type) && !this.match(M._this) || (t$1 && this.raise(this.lastTokStart, "Escape sequence in keyword asserts"), 0));
+				}, p.tsParseThisTypeNode = function() {
+					var t$1 = this.startNode();
+					return this.next(), this.finishNode(t$1, "TSThisType");
+				}, p.tsParseTypeAnnotation = function(t$1, e$2) {
+					var s$1 = this;
+					return void 0 === t$1 && (t$1 = !0), void 0 === e$2 && (e$2 = this.startNode()), this.tsInType(function() {
+						t$1 && s$1.expect(M.colon), e$2.typeAnnotation = s$1.tsParseType();
+					}), this.finishNode(e$2, "TSTypeAnnotation");
+				}, p.tsParseThisTypePredicate = function(t$1) {
+					this.next();
+					var e$2 = this.startNodeAtNode(t$1);
+					return e$2.parameterName = t$1, e$2.typeAnnotation = this.tsParseTypeAnnotation(!1), e$2.asserts = !1, this.finishNode(e$2, "TSTypePredicate");
+				}, p.tsParseThisTypeOrThisTypePredicate = function() {
+					var t$1 = this.tsParseThisTypeNode();
+					return this.isContextual("is") && !this.hasPrecedingLineBreak() ? this.tsParseThisTypePredicate(t$1) : t$1;
+				}, p.tsParseTypePredicatePrefix = function() {
+					var t$1 = this.parseIdent();
+					if (this.isContextual("is") && !this.hasPrecedingLineBreak()) return this.next(), t$1;
+				}, p.tsParseTypeOrTypePredicateAnnotation = function(t$1) {
+					var e$2 = this;
+					return this.tsInType(function() {
+						var s$1 = e$2.startNode();
+						e$2.expect(t$1);
+						var i = e$2.startNode(), r$1 = !!e$2.tsTryParse(e$2.tsParseTypePredicateAsserts.bind(e$2));
+						if (r$1 && e$2.match(M._this)) {
+							var a = e$2.tsParseThisTypeOrThisTypePredicate();
+							return "TSThisType" === a.type ? (i.parameterName = a, i.asserts = !0, i.typeAnnotation = null, a = e$2.finishNode(i, "TSTypePredicate")) : (e$2.resetStartLocationFromNode(a, i), a.asserts = !0), s$1.typeAnnotation = a, e$2.finishNode(s$1, "TSTypeAnnotation");
+						}
+						var n$3 = e$2.tsIsIdentifier() && e$2.tsTryParse(e$2.tsParseTypePredicatePrefix.bind(e$2));
+						if (!n$3) return r$1 ? (i.parameterName = e$2.parseIdent(), i.asserts = r$1, i.typeAnnotation = null, s$1.typeAnnotation = e$2.finishNode(i, "TSTypePredicate"), e$2.finishNode(s$1, "TSTypeAnnotation")) : e$2.tsParseTypeAnnotation(!1, s$1);
+						var o$2 = e$2.tsParseTypeAnnotation(!1);
+						return i.parameterName = n$3, i.typeAnnotation = o$2, i.asserts = r$1, s$1.typeAnnotation = e$2.finishNode(i, "TSTypePredicate"), e$2.finishNode(s$1, "TSTypeAnnotation");
+					});
+				}, p.tsFillSignature = function(t$1, e$2) {
+					var s$1 = t$1 === M.arrow;
+					e$2.typeParameters = this.tsTryParseTypeParameters(), this.expect(M.parenL), e$2.parameters = this.tsParseBindingListForSignature(), (s$1 || this.match(t$1)) && (e$2.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(t$1));
+				}, p.tsTryNextParseConstantContext = function() {
+					if (this.lookahead().type !== M._const) return null;
+					this.next();
+					var t$1 = this.tsParseTypeReference();
+					return t$1.typeParameters && this.raise(t$1.typeName.start, T.CannotFindName({ name: "const" })), t$1;
+				}, p.tsParseFunctionOrConstructorType = function(t$1, e$2) {
+					var s$1 = this, i = this.startNode();
+					return "TSConstructorType" === t$1 && (i.abstract = !!e$2, e$2 && this.next(), this.next()), this.tsInAllowConditionalTypesContext(function() {
+						return s$1.tsFillSignature(M.arrow, i);
+					}), this.finishNode(i, t$1);
+				}, p.tsParseUnionOrIntersectionType = function(t$1, e$2, s$1) {
+					var i = this.startNode(), r$1 = this.eat(s$1), a = [];
+					do
+						a.push(e$2());
+					while (this.eat(s$1));
+					return 1 !== a.length || r$1 ? (i.types = a, this.finishNode(i, t$1)) : a[0];
+				}, p.tsCheckTypeAnnotationForReadOnly = function(t$1) {
+					switch (t$1.typeAnnotation.type) {
+						case "TSTupleType":
+						case "TSArrayType": return;
+						default: this.raise(t$1.start, T.UnexpectedReadonly);
+					}
+				}, p.tsParseTypeOperator = function() {
+					var t$1 = this.startNode(), e$2 = this.value;
+					return this.next(), t$1.operator = e$2, t$1.typeAnnotation = this.tsParseTypeOperatorOrHigher(), "readonly" === e$2 && this.tsCheckTypeAnnotationForReadOnly(t$1), this.finishNode(t$1, "TSTypeOperator");
+				}, p.tsParseConstraintForInferType = function() {
+					var t$1 = this;
+					if (this.eat(M._extends)) {
+						var e$2 = this.tsInDisallowConditionalTypesContext(function() {
+							return t$1.tsParseType();
+						});
+						if (this.inDisallowConditionalTypesContext || !this.match(M.question)) return e$2;
+					}
+				}, p.tsParseInferType = function() {
+					var t$1 = this, e$2 = this.startNode();
+					this.expectContextual("infer");
+					var s$1 = this.startNode();
+					return s$1.name = this.tsParseTypeParameterName(), s$1.constraint = this.tsTryParse(function() {
+						return t$1.tsParseConstraintForInferType();
+					}), e$2.typeParameter = this.finishNode(s$1, "TSTypeParameter"), this.finishNode(e$2, "TSInferType");
+				}, p.tsParseLiteralTypeNode = function() {
+					var t$1 = this, e$2 = this.startNode();
+					return e$2.literal = function() {
+						switch (t$1.type) {
+							case M.num:
+							case M.string:
+							case M._true:
+							case M._false: return t$1.parseExprAtom();
+							default: t$1.unexpected();
+						}
+					}(), this.finishNode(e$2, "TSLiteralType");
+				}, p.tsParseImportType = function() {
+					var t$1 = this.startNode();
+					return this.expect(M._import), this.expect(M.parenL), this.match(M.string) || this.raise(this.start, T.UnsupportedImportTypeArgument), t$1.argument = this.parseExprAtom(), this.expect(M.parenR), this.eat(M.dot) && (t$1.qualifier = this.tsParseEntityName()), this.tsMatchLeftRelational() && (t$1.typeParameters = this.tsParseTypeArguments()), this.finishNode(t$1, "TSImportType");
+				}, p.tsParseTypeQuery = function() {
+					var t$1 = this.startNode();
+					return this.expect(M._typeof), t$1.exprName = this.match(M._import) ? this.tsParseImportType() : this.tsParseEntityName(), !this.hasPrecedingLineBreak() && this.tsMatchLeftRelational() && (t$1.typeParameters = this.tsParseTypeArguments()), this.finishNode(t$1, "TSTypeQuery");
+				}, p.tsParseMappedTypeParameter = function() {
+					var t$1 = this.startNode();
+					return t$1.name = this.tsParseTypeParameterName(), t$1.constraint = this.tsExpectThenParseType(M._in), this.finishNode(t$1, "TSTypeParameter");
+				}, p.tsParseMappedType = function() {
+					var t$1 = this.startNode();
+					return this.expect(M.braceL), this.match(M.plusMin) ? (t$1.readonly = this.value, this.next(), this.expectContextual("readonly")) : this.eatContextual("readonly") && (t$1.readonly = !0), this.expect(M.bracketL), t$1.typeParameter = this.tsParseMappedTypeParameter(), t$1.nameType = this.eatContextual("as") ? this.tsParseType() : null, this.expect(M.bracketR), this.match(M.plusMin) ? (t$1.optional = this.value, this.next(), this.expect(M.question)) : this.eat(M.question) && (t$1.optional = !0), t$1.typeAnnotation = this.tsTryParseType(), this.semicolon(), this.expect(M.braceR), this.finishNode(t$1, "TSMappedType");
+				}, p.tsParseTypeLiteral = function() {
+					var t$1 = this.startNode();
+					return t$1.members = this.tsParseObjectTypeMembers(), this.finishNode(t$1, "TSTypeLiteral");
+				}, p.tsParseTupleElementType = function() {
+					var t$1 = this.startLoc, e$2 = this.start, s$1 = this.eat(M.ellipsis), i = this.tsParseType(), r$1 = this.eat(M.question);
+					if (this.eat(M.colon)) {
+						var a = this.startNodeAtNode(i);
+						a.optional = r$1, "TSTypeReference" !== i.type || i.typeParameters || "Identifier" !== i.typeName.type ? (this.raise(i.start, T.InvalidTupleMemberLabel), a.label = i) : a.label = i.typeName, a.elementType = this.tsParseType(), i = this.finishNode(a, "TSNamedTupleMember");
+					} else if (r$1) {
+						var n$3 = this.startNodeAtNode(i);
+						n$3.typeAnnotation = i, i = this.finishNode(n$3, "TSOptionalType");
+					}
+					if (s$1) {
+						var o$2 = this.startNodeAt(e$2, t$1);
+						o$2.typeAnnotation = i, i = this.finishNode(o$2, "TSRestType");
+					}
+					return i;
+				}, p.tsParseTupleType = function() {
+					var t$1 = this, e$2 = this.startNode();
+					e$2.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), !0, !1);
+					var s$1 = !1, i = null;
+					return e$2.elementTypes.forEach(function(e$3) {
+						var r$1 = e$3.type;
+						!s$1 || "TSRestType" === r$1 || "TSOptionalType" === r$1 || "TSNamedTupleMember" === r$1 && e$3.optional || t$1.raise(e$3.start, T.OptionalTypeBeforeRequired), s$1 || (s$1 = "TSNamedTupleMember" === r$1 && e$3.optional || "TSOptionalType" === r$1);
+						var a = r$1;
+						"TSRestType" === r$1 && (a = (e$3 = e$3.typeAnnotation).type);
+						var n$3 = "TSNamedTupleMember" === a;
+						i ??= n$3, i !== n$3 && t$1.raise(e$3.start, T.MixedLabeledAndUnlabeledElements);
+					}), this.finishNode(e$2, "TSTupleType");
+				}, p.tsParseTemplateLiteralType = function() {
+					var t$1 = this.startNode();
+					return t$1.literal = this.parseTemplate({ isTagged: !1 }), this.finishNode(t$1, "TSLiteralType");
+				}, p.tsParseTypeReference = function() {
+					var t$1 = this.startNode();
+					return t$1.typeName = this.tsParseEntityName(), !this.hasPrecedingLineBreak() && this.tsMatchLeftRelational() && (t$1.typeParameters = this.tsParseTypeArguments()), this.finishNode(t$1, "TSTypeReference");
+				}, p.tsMatchLeftRelational = function() {
+					return this.match(M.relational) && "<" === this.value;
+				}, p.tsMatchRightRelational = function() {
+					return this.match(M.relational) && ">" === this.value;
+				}, p.tsParseParenthesizedType = function() {
+					var t$1 = this.startNode();
+					return this.expect(M.parenL), t$1.typeAnnotation = this.tsParseType(), this.expect(M.parenR), this.finishNode(t$1, "TSParenthesizedType");
+				}, p.tsParseNonArrayType = function() {
+					switch (this.type) {
+						case M.string:
+						case M.num:
+						case M._true:
+						case M._false: return this.tsParseLiteralTypeNode();
+						case M.plusMin:
+							if ("-" === this.value) {
+								var t$1 = this.startNode();
+								return this.lookahead().type !== M.num && this.unexpected(), t$1.literal = this.parseMaybeUnary(), this.finishNode(t$1, "TSLiteralType");
+							}
+							break;
+						case M._this: return this.tsParseThisTypeOrThisTypePredicate();
+						case M._typeof: return this.tsParseTypeQuery();
+						case M._import: return this.tsParseImportType();
+						case M.braceL: return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
+						case M.bracketL: return this.tsParseTupleType();
+						case M.parenL: return this.tsParseParenthesizedType();
+						case M.backQuote:
+						case M.dollarBraceL: return this.tsParseTemplateLiteralType();
+						default:
+							var e$2 = this.type;
+							if (z(e$2) || e$2 === M._void || e$2 === M._null) {
+								var s$1 = e$2 === M._void ? "TSVoidKeyword" : e$2 === M._null ? "TSNullKeyword" : function(t$2) {
+									switch (t$2) {
+										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;
+									}
+								}(this.value);
+								if (void 0 !== s$1 && 46 !== this.lookaheadCharCode()) {
+									var i = this.startNode();
+									return this.next(), this.finishNode(i, s$1);
+								}
+								return this.tsParseTypeReference();
+							}
+					}
+					this.unexpected();
+				}, p.tsParseArrayTypeOrHigher = function() {
+					for (var t$1 = this.tsParseNonArrayType(); !this.hasPrecedingLineBreak() && this.eat(M.bracketL);) if (this.match(M.bracketR)) {
+						var e$2 = this.startNodeAtNode(t$1);
+						e$2.elementType = t$1, this.expect(M.bracketR), t$1 = this.finishNode(e$2, "TSArrayType");
+					} else {
+						var s$1 = this.startNodeAtNode(t$1);
+						s$1.objectType = t$1, s$1.indexType = this.tsParseType(), this.expect(M.bracketR), t$1 = this.finishNode(s$1, "TSIndexedAccessType");
+					}
+					return t$1;
+				}, p.tsParseTypeOperatorOrHigher = function() {
+					var t$1 = this;
+					return X(this.type) && !this.containsEsc ? this.tsParseTypeOperator() : this.isContextual("infer") ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(function() {
+						return t$1.tsParseArrayTypeOrHigher();
+					});
+				}, p.tsParseIntersectionTypeOrHigher = function() {
+					return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), M.bitwiseAND);
+				}, p.tsParseUnionTypeOrHigher = function() {
+					return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), M.bitwiseOR);
+				}, p.tsParseNonConditionalType = function() {
+					return this.tsIsStartOfFunctionType() ? this.tsParseFunctionOrConstructorType("TSFunctionType") : this.match(M._new) ? this.tsParseFunctionOrConstructorType("TSConstructorType") : this.isAbstractConstructorSignature() ? this.tsParseFunctionOrConstructorType("TSConstructorType", !0) : this.tsParseUnionTypeOrHigher();
+				}, p.tsParseType = function() {
+					var t$1 = this;
+					S(this.inType);
+					var e$2 = this.tsParseNonConditionalType();
+					if (this.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(M._extends)) return e$2;
+					var s$1 = this.startNodeAtNode(e$2);
+					return s$1.checkType = e$2, s$1.extendsType = this.tsInDisallowConditionalTypesContext(function() {
+						return t$1.tsParseNonConditionalType();
+					}), this.expect(M.question), s$1.trueType = this.tsInAllowConditionalTypesContext(function() {
+						return t$1.tsParseType();
+					}), this.expect(M.colon), s$1.falseType = this.tsInAllowConditionalTypesContext(function() {
+						return t$1.tsParseType();
+					}), this.finishNode(s$1, "TSConditionalType");
+				}, p.tsIsUnambiguouslyIndexSignature = function() {
+					return this.next(), !!z(this.type) && (this.next(), this.match(M.colon));
+				}, p.tsInType = function(t$1) {
+					var e$2 = this.inType;
+					this.inType = !0;
+					try {
+						return t$1();
+					} finally {
+						this.inType = e$2;
+					}
+				}, p.tsTryParseIndexSignature = function(t$1) {
+					if (this.match(M.bracketL) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))) {
+						this.expect(M.bracketL);
+						var e$2 = this.parseIdent();
+						e$2.typeAnnotation = this.tsParseTypeAnnotation(), this.resetEndLocation(e$2), this.expect(M.bracketR), t$1.parameters = [e$2];
+						var s$1 = this.tsTryParseTypeAnnotation();
+						return s$1 && (t$1.typeAnnotation = s$1), this.tsParseTypeMemberSemicolon(), this.finishNode(t$1, "TSIndexSignature");
+					}
+				}, p.tsParseNoneModifiers = function(t$1) {
+					this.tsParseModifiers({
+						modified: t$1,
+						allowedModifiers: [],
+						disallowedModifiers: ["in", "out"],
+						errorTemplate: T.InvalidModifierOnTypeParameterPositions
+					});
+				}, p.tsParseTypeParameter = function(t$1) {
+					void 0 === t$1 && (t$1 = this.tsParseNoneModifiers.bind(this));
+					var e$2 = this.startNode();
+					return t$1(e$2), e$2.name = this.tsParseTypeParameterName(), e$2.constraint = this.tsEatThenParseType(M._extends), e$2.default = this.tsEatThenParseType(M.eq), this.finishNode(e$2, "TSTypeParameter");
+				}, p.tsParseTypeParameters = function(t$1) {
+					var e$2 = this.startNode();
+					this.tsMatchLeftRelational() || this.matchJsx("jsxTagStart") ? this.next() : this.unexpected();
+					var s$1 = { value: -1 };
+					return e$2.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, t$1), !1, !0, s$1), 0 === e$2.params.length && this.raise(this.start, T.EmptyTypeParameters), -1 !== s$1.value && this.addExtra(e$2, "trailingComma", s$1.value), this.finishNode(e$2, "TSTypeParameterDeclaration");
+				}, p.tsTryParseTypeParameters = function(t$1) {
+					if (this.tsMatchLeftRelational()) return this.tsParseTypeParameters(t$1);
+				}, p.tsTryParse = function(t$1) {
+					var e$2 = this.getCurLookaheadState(), s$1 = t$1();
+					return void 0 !== s$1 && !1 !== s$1 ? s$1 : void this.setLookaheadState(e$2);
+				}, p.tsTokenCanFollowModifier = function() {
+					return (this.match(M.bracketL) || this.match(M.braceL) || this.match(M.star) || this.match(M.ellipsis) || this.match(M.privateId) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
+				}, p.tsNextTokenCanFollowModifier = function() {
+					return this.next(!0), this.tsTokenCanFollowModifier();
+				}, p.tsParseModifier = function(t$1, e$2) {
+					if (z(this.type) || this.type === M._in) {
+						var s$1 = this.value;
+						if (-1 !== t$1.indexOf(s$1) && !this.containsEsc) {
+							if (e$2 && this.tsIsStartOfStaticBlocks()) return;
+							if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) return s$1;
+						}
+					}
+				}, p.tsParseModifiersByMap = function(t$1) {
+					for (var e$2 = t$1.modified, s$1 = t$1.map, i = 0, r$1 = Object.keys(s$1); i < r$1.length; i++) {
+						var a = r$1[i];
+						e$2[a] = s$1[a];
+					}
+				}, p.tsParseModifiers = function(t$1) {
+					for (var e$2 = this, s$1 = t$1.modified, i = t$1.allowedModifiers, r$1 = t$1.disallowedModifiers, a = t$1.stopOnStartOfClassStaticBlock, n$3 = t$1.errorTemplate, o$2 = void 0 === n$3 ? T.InvalidModifierOnTypeMember : n$3, h = {}, p$1 = function(t$2, i$1, r$2, a$1) {
+						i$1 === r$2 && s$1[a$1] && e$2.raise(t$2.column, T.InvalidModifiersOrder({ orderedModifiers: [r$2, a$1] }));
+					}, c = function(t$2, i$1, r$2, a$1) {
+						(s$1[r$2] && i$1 === a$1 || s$1[a$1] && i$1 === r$2) && e$2.raise(t$2.column, T.IncompatibleModifiers({ modifiers: [r$2, a$1] }));
+					};;) {
+						var l = this.startLoc, u = this.tsParseModifier(i.concat(null != r$1 ? r$1 : []), a);
+						if (!u) break;
+						w(u) ? s$1.accessibility ? this.raise(this.start, T.DuplicateAccessibilityModifier()) : (p$1(l, u, u, "override"), p$1(l, u, u, "static"), p$1(l, u, u, "readonly"), p$1(l, u, u, "accessor"), h.accessibility = u, s$1.accessibility = u) : C(u) ? s$1[u] ? this.raise(this.start, T.DuplicateModifier({ modifier: u })) : (p$1(l, u, "in", "out"), h[u] = u, s$1[u] = !0) : k(u) ? s$1[u] ? this.raise(this.start, T.DuplicateModifier({ modifier: u })) : (c(l, u, "accessor", "readonly"), c(l, u, "accessor", "static"), c(l, u, "accessor", "override"), h[u] = u, s$1[u] = !0) : Object.hasOwnProperty.call(s$1, u) ? this.raise(this.start, T.DuplicateModifier({ modifier: u })) : (p$1(l, u, "static", "readonly"), p$1(l, u, "static", "override"), p$1(l, u, "override", "readonly"), p$1(l, u, "abstract", "override"), c(l, u, "declare", "override"), c(l, u, "static", "abstract"), h[u] = u, s$1[u] = !0), null != r$1 && r$1.includes(u) && this.raise(this.start, o$2);
+					}
+					return h;
+				}, p.tsParseInOutModifiers = function(t$1) {
+					this.tsParseModifiers({
+						modified: t$1,
+						allowedModifiers: ["in", "out"],
+						disallowedModifiers: [
+							"public",
+							"private",
+							"protected",
+							"readonly",
+							"declare",
+							"abstract",
+							"override"
+						],
+						errorTemplate: T.InvalidModifierOnTypeParameter
+					});
+				}, p.tsParseTypeArguments = function() {
+					var t$1 = this, e$2 = this.startNode();
+					return e$2.params = this.tsInType(function() {
+						return t$1.tsInNoContext(function() {
+							return t$1.expect(M.relational), t$1.tsParseDelimitedList("TypeParametersOrArguments", t$1.tsParseType.bind(t$1));
+						});
+					}), 0 === e$2.params.length && this.raise(this.start, T.EmptyTypeArguments), this.exprAllowed = !1, this.expect(M.relational), this.finishNode(e$2, "TSTypeParameterInstantiation");
+				}, p.tsParseHeritageClause = function(t$1) {
+					var e$2 = this, s$1 = this.start, i = this.tsParseDelimitedList("HeritageClauseElement", function() {
+						var t$2 = e$2.startNode();
+						return t$2.expression = e$2.tsParseEntityName(), e$2.tsMatchLeftRelational() && (t$2.typeParameters = e$2.tsParseTypeArguments()), e$2.finishNode(t$2, "TSExpressionWithTypeArguments");
+					});
+					return i.length || this.raise(s$1, T.EmptyHeritageClauseType({ token: t$1 })), i;
+				}, p.tsParseTypeMemberSemicolon = function() {
+					this.eat(M.comma) || this.isLineTerminator() || this.expect(M.semi);
+				}, p.tsTryParseAndCatch = function(t$1) {
+					var e$2 = this.tryParse(function(e$3) {
+						return t$1() || e$3();
+					});
+					if (!e$2.aborted && e$2.node) return e$2.error && this.setLookaheadState(e$2.failState), e$2.node;
+				}, p.tsParseSignatureMember = function(t$1, e$2) {
+					return this.tsFillSignature(M.colon, e$2), this.tsParseTypeMemberSemicolon(), this.finishNode(e$2, t$1);
+				}, p.tsParsePropertyOrMethodSignature = function(t$1, e$2) {
+					this.eat(M.question) && (t$1.optional = !0);
+					var s$1 = t$1;
+					if (this.match(M.parenL) || this.tsMatchLeftRelational()) {
+						e$2 && this.raise(t$1.start, T.ReadonlyForMethodSignature);
+						var i = s$1;
+						i.kind && this.tsMatchLeftRelational() && this.raise(this.start, T.AccesorCannotHaveTypeParameters), this.tsFillSignature(M.colon, i), this.tsParseTypeMemberSemicolon();
+						var r$1 = "parameters", a = "typeAnnotation";
+						if ("get" === i.kind) i[r$1].length > 0 && (this.raise(this.start, "A 'get' accesor must not have any formal parameters."), this.isThisParam(i[r$1][0]) && this.raise(this.start, T.AccesorCannotDeclareThisParameter));
+						else if ("set" === i.kind) {
+							if (1 !== i[r$1].length) this.raise(this.start, "A 'get' accesor must not have any formal parameters.");
+							else {
+								var n$3 = i[r$1][0];
+								this.isThisParam(n$3) && this.raise(this.start, T.AccesorCannotDeclareThisParameter), "Identifier" === n$3.type && n$3.optional && this.raise(this.start, T.SetAccesorCannotHaveOptionalParameter), "RestElement" === n$3.type && this.raise(this.start, T.SetAccesorCannotHaveRestParameter);
+							}
+							i[a] && this.raise(i[a].start, T.SetAccesorCannotHaveReturnType);
+						} else i.kind = "method";
+						return this.finishNode(i, "TSMethodSignature");
+					}
+					var o$2 = s$1;
+					e$2 && (o$2.readonly = !0);
+					var h = this.tsTryParseTypeAnnotation();
+					return h && (o$2.typeAnnotation = h), this.tsParseTypeMemberSemicolon(), this.finishNode(o$2, "TSPropertySignature");
+				}, p.tsParseTypeMember = function() {
+					var t$1 = this.startNode();
+					if (this.match(M.parenL) || this.tsMatchLeftRelational()) return this.tsParseSignatureMember("TSCallSignatureDeclaration", t$1);
+					if (this.match(M._new)) {
+						var e$2 = this.startNode();
+						return this.next(), this.match(M.parenL) || this.tsMatchLeftRelational() ? this.tsParseSignatureMember("TSConstructSignatureDeclaration", t$1) : (t$1.key = this.createIdentifier(e$2, "new"), this.tsParsePropertyOrMethodSignature(t$1, !1));
+					}
+					return this.tsParseModifiers({
+						modified: t$1,
+						allowedModifiers: ["readonly"],
+						disallowedModifiers: [
+							"declare",
+							"abstract",
+							"private",
+							"protected",
+							"public",
+							"static",
+							"override"
+						]
+					}), this.tsTryParseIndexSignature(t$1) || (this.parsePropertyName(t$1), t$1.computed || "Identifier" !== t$1.key.type || "get" !== t$1.key.name && "set" !== t$1.key.name || !this.tsTokenCanFollowModifier() || (t$1.kind = t$1.key.name, this.parsePropertyName(t$1)), this.tsParsePropertyOrMethodSignature(t$1, !!t$1.readonly));
+				}, p.tsParseList = function(t$1, e$2) {
+					for (var s$1 = []; !this.tsIsListTerminator(t$1);) s$1.push(e$2());
+					return s$1;
+				}, p.tsParseObjectTypeMembers = function() {
+					this.expect(M.braceL);
+					var t$1 = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
+					return this.expect(M.braceR), t$1;
+				}, p.tsParseInterfaceDeclaration = function(t$1, e$2) {
+					if (void 0 === e$2 && (e$2 = {}), this.hasFollowingLineBreak()) return null;
+					this.expectContextual("interface"), e$2.declare && (t$1.declare = !0), z(this.type) ? (t$1.id = this.parseIdent(), this.checkLValSimple(t$1.id, 7)) : (t$1.id = null, this.raise(this.start, T.MissingInterfaceName)), t$1.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)), this.eat(M._extends) && (t$1.extends = this.tsParseHeritageClause("extends"));
+					var s$1 = this.startNode();
+					return s$1.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this)), t$1.body = this.finishNode(s$1, "TSInterfaceBody"), this.finishNode(t$1, "TSInterfaceDeclaration");
+				}, p.tsParseAbstractDeclaration = function(t$1) {
+					if (this.match(M._class)) return t$1.abstract = !0, this.parseClass(t$1, !0);
+					if (this.ts_isContextual(B.interface)) {
+						if (!this.hasFollowingLineBreak()) return t$1.abstract = !0, this.tsParseInterfaceDeclaration(t$1);
+					} else this.unexpected(t$1.start);
+				}, p.tsIsDeclarationStart = function() {
+					return K(this.type);
+				}, p.tsParseExpressionStatement = function(e$2, s$1) {
+					switch (s$1.name) {
+						case "declare":
+							var i = this.tsTryParseDeclare(e$2);
+							if (i) return i.declare = !0, i;
+							break;
+						case "global":
+							if (this.match(M.braceL)) {
+								t.prototype.enterScope.call(this, u);
+								var r$1 = e$2;
+								return r$1.global = !0, r$1.id = s$1, r$1.body = this.tsParseModuleBlock(), t.prototype.exitScope.call(this), this.finishNode(r$1, "TSModuleDeclaration");
+							}
+							break;
+						default: return this.tsParseDeclaration(e$2, s$1.name, !1);
+					}
+				}, p.tsParseModuleReference = function() {
+					return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(!1);
+				}, p.tsIsExportDefaultSpecifier = function() {
+					var t$1 = this.type, e$2 = this.isAsyncFunction(), s$1 = this.isLet();
+					if (z(t$1)) {
+						if (e$2 && !this.containsEsc || s$1) return !1;
+						if ((t$1 === B.type || t$1 === B.interface) && !this.containsEsc) {
+							var i = this.lookahead();
+							if (z(i.type) && !this.isContextualWithState("from", i) || i.type === M.braceL) return !1;
+						}
+					} else if (!this.match(M._default)) return !1;
+					var r$1 = this.nextTokenStart(), a = this.isUnparsedContextual(r$1, "from");
+					if (44 === this.input.charCodeAt(r$1) || z(this.type) && a) return !0;
+					if (this.match(M._default) && a) {
+						var n$3 = this.input.charCodeAt(this.nextTokenStartSince(r$1 + 4));
+						return 34 === n$3 || 39 === n$3;
+					}
+					return !1;
+				}, p.tsInAmbientContext = function(t$1) {
+					var e$2 = this.isAmbientContext;
+					this.isAmbientContext = !0;
+					try {
+						return t$1();
+					} finally {
+						this.isAmbientContext = e$2;
+					}
+				}, p.tsCheckLineTerminator = function(t$1) {
+					return t$1 ? !this.hasFollowingLineBreak() && (this.next(), !0) : !this.isLineTerminator();
+				}, p.tsParseModuleOrNamespaceDeclaration = function(e$2, s$1) {
+					if (void 0 === s$1 && (s$1 = !1), e$2.id = this.parseIdent(), s$1 || this.checkLValSimple(e$2.id, 8), this.eat(M.dot)) {
+						var i = this.startNode();
+						this.tsParseModuleOrNamespaceDeclaration(i, !0), e$2.body = i;
+					} else t.prototype.enterScope.call(this, u), e$2.body = this.tsParseModuleBlock(), t.prototype.exitScope.call(this);
+					return this.finishNode(e$2, "TSModuleDeclaration");
+				}, p.checkLValSimple = function(e$2, s$1, i) {
+					return void 0 === s$1 && (s$1 = 0), t.prototype.checkLValSimple.call(this, e$2, s$1, i);
+				}, p.tsParseTypeAliasDeclaration = function(t$1) {
+					var e$2 = this;
+					return t$1.id = this.parseIdent(), this.checkLValSimple(t$1.id, 6), t$1.typeAnnotation = this.tsInType(function() {
+						if (t$1.typeParameters = e$2.tsTryParseTypeParameters(e$2.tsParseInOutModifiers.bind(e$2)), e$2.expect(M.eq), e$2.ts_isContextual(B.interface) && e$2.lookahead().type !== M.dot) {
+							var s$1 = e$2.startNode();
+							return e$2.next(), e$2.finishNode(s$1, "TSIntrinsicKeyword");
+						}
+						return e$2.tsParseType();
+					}), this.semicolon(), this.finishNode(t$1, "TSTypeAliasDeclaration");
+				}, p.tsParseDeclaration = function(t$1, e$2, s$1) {
+					switch (e$2) {
+						case "abstract":
+							if (this.tsCheckLineTerminator(s$1) && (this.match(M._class) || z(this.type))) return this.tsParseAbstractDeclaration(t$1);
+							break;
+						case "module":
+							if (this.tsCheckLineTerminator(s$1)) {
+								if (this.match(M.string)) return this.tsParseAmbientExternalModuleDeclaration(t$1);
+								if (z(this.type)) return this.tsParseModuleOrNamespaceDeclaration(t$1);
+							}
+							break;
+						case "namespace":
+							if (this.tsCheckLineTerminator(s$1) && z(this.type)) return this.tsParseModuleOrNamespaceDeclaration(t$1);
+							break;
+						case "type": if (this.tsCheckLineTerminator(s$1) && z(this.type)) return this.tsParseTypeAliasDeclaration(t$1);
+					}
+				}, p.tsTryParseExportDeclaration = function() {
+					return this.tsParseDeclaration(this.startNode(), this.value, !0);
+				}, p.tsParseImportEqualsDeclaration = function(e$2, s$1) {
+					e$2.isExport = s$1 || !1, e$2.id = this.parseIdent(), this.checkLValSimple(e$2.id, 2), t.prototype.expect.call(this, M.eq);
+					var i = this.tsParseModuleReference();
+					return "type" === e$2.importKind && "TSExternalModuleReference" !== i.type && this.raise(i.start, T.ImportAliasHasImportType), e$2.moduleReference = i, t.prototype.semicolon.call(this), this.finishNode(e$2, "TSImportEqualsDeclaration");
+				}, p.isExportDefaultSpecifier = function() {
+					if (this.tsIsDeclarationStart()) return !1;
+					var t$1 = this.type;
+					if (z(t$1)) {
+						if (this.isContextual("async") || this.isContextual("let")) return !1;
+						if ((t$1 === B.type || t$1 === B.interface) && !this.containsEsc) {
+							var e$2 = this.lookahead();
+							if (z(e$2.type) && !this.isContextualWithState("from", e$2) || e$2.type === M.braceL) return !1;
+						}
+					} else if (!this.match(M._default)) return !1;
+					var s$1 = this.nextTokenStart(), i = this.isUnparsedContextual(s$1, "from");
+					if (44 === this.input.charCodeAt(s$1) || z(this.type) && i) return !0;
+					if (this.match(M._default) && i) {
+						var r$1 = this.input.charCodeAt(this.nextTokenStartSince(s$1 + 4));
+						return 34 === r$1 || 39 === r$1;
+					}
+					return !1;
+				}, p.parseTemplate = function(t$1) {
+					var e$2 = (void 0 === t$1 ? {} : t$1).isTagged, s$1 = void 0 !== e$2 && e$2, i = this.startNode();
+					this.next(), i.expressions = [];
+					var r$1 = this.parseTemplateElement({ isTagged: s$1 });
+					for (i.quasis = [r$1]; !r$1.tail;) this.type === M.eof && this.raise(this.pos, "Unterminated template literal"), this.expect(M.dollarBraceL), i.expressions.push(this.inType ? this.tsParseType() : this.parseExpression()), this.expect(M.braceR), i.quasis.push(r$1 = this.parseTemplateElement({ isTagged: s$1 }));
+					return this.next(), this.finishNode(i, "TemplateLiteral");
+				}, p.parseFunction = function(t$1, e$2, s$1, i, r$1) {
+					this.initFunction(t$1), (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !i) && (this.type === M.star && 2 & e$2 && this.unexpected(), t$1.generator = this.eat(M.star)), this.options.ecmaVersion >= 8 && (t$1.async = !!i), 1 & e$2 && (t$1.id = 4 & e$2 && this.type !== M.name ? null : this.parseIdent());
+					var a = this.yieldPos, n$3 = this.awaitPos, o$2 = this.awaitIdentPos, h = this.maybeInArrowParameters;
+					this.maybeInArrowParameters = !1, this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.enterScope(E(t$1.async, t$1.generator)), 1 & e$2 || (t$1.id = this.type === M.name ? this.parseIdent() : null), this.parseFunctionParams(t$1);
+					var p$1 = 1 & e$2;
+					return this.parseFunctionBody(t$1, s$1, !1, r$1, { isFunctionDeclaration: p$1 }), this.yieldPos = a, this.awaitPos = n$3, this.awaitIdentPos = o$2, 1 & e$2 && t$1.id && !(2 & e$2) && this.checkLValSimple(t$1.id, t$1.body ? this.strict || t$1.generator || t$1.async ? this.treatFunctionsAsVar ? 1 : 2 : 3 : 0), this.maybeInArrowParameters = h, this.finishNode(t$1, p$1 ? "FunctionDeclaration" : "FunctionExpression");
+				}, p.parseFunctionBody = function(e$2, s$1, i, r$1, a) {
+					void 0 === s$1 && (s$1 = !1), void 0 === i && (i = !1), void 0 === r$1 && (r$1 = !1), this.match(M.colon) && (e$2.returnType = this.tsParseTypeOrTypePredicateAnnotation(M.colon));
+					var n$3 = null != a && a.isFunctionDeclaration ? "TSDeclareFunction" : null != a && a.isClassMethod ? "TSDeclareMethod" : void 0;
+					return n$3 && !this.match(M.braceL) && this.isLineTerminator() ? this.finishNode(e$2, n$3) : "TSDeclareFunction" === n$3 && this.isAmbientContext && (this.raise(e$2.start, T.DeclareFunctionHasImplementation), e$2.declare) ? (t.prototype.parseFunctionBody.call(this, e$2, s$1, i, !1), this.finishNode(e$2, n$3)) : (t.prototype.parseFunctionBody.call(this, e$2, s$1, i, r$1), e$2);
+				}, p.parseNew = function() {
+					var t$1;
+					this.containsEsc && this.raiseRecoverable(this.start, "Escape sequence in keyword new");
+					var e$2 = this.startNode(), s$1 = this.parseIdent(!0);
+					if (this.options.ecmaVersion >= 6 && this.eat(M.dot)) {
+						e$2.meta = s$1;
+						var i = this.containsEsc;
+						return e$2.property = this.parseIdent(!0), "target" !== e$2.property.name && this.raiseRecoverable(e$2.property.start, "The only valid meta property for new is 'new.target'"), i && this.raiseRecoverable(e$2.start, "'new.target' must not contain escaped characters"), this.allowNewDotTarget || this.raiseRecoverable(e$2.start, "'new.target' can only be used in functions and class static block"), this.finishNode(e$2, "MetaProperty");
+					}
+					var r$1 = this.start, a = this.startLoc, n$3 = this.type === M._import;
+					e$2.callee = this.parseSubscripts(this.parseExprAtom(), r$1, a, !0, !1), n$3 && "ImportExpression" === e$2.callee.type && this.raise(r$1, "Cannot use new with import()");
+					var o$2 = e$2.callee;
+					return "TSInstantiationExpression" !== o$2.type || null != (t$1 = o$2.extra) && t$1.parenthesized || (e$2.typeParameters = o$2.typeParameters, e$2.callee = o$2.expression), e$2.arguments = this.eat(M.parenL) ? this.parseExprList(M.parenR, this.options.ecmaVersion >= 8, !1) : [], this.finishNode(e$2, "NewExpression");
+				}, p.parseExprOp = function(e$2, s$1, i, r$1, a) {
+					var n$3;
+					if (M._in.binop > r$1 && !this.hasPrecedingLineBreak() && (this.isContextual("as") && (n$3 = "TSAsExpression"), L && this.isContextual("satisfies") && (n$3 = "TSSatisfiesExpression"), n$3)) {
+						var o$2 = this.startNodeAt(s$1, i);
+						o$2.expression = e$2;
+						return o$2.typeAnnotation = this.tsTryNextParseConstantContext() || this.tsNextThenParseType(), this.finishNode(o$2, n$3), this.reScan_lt_gt(), this.parseExprOp(o$2, s$1, i, r$1, a);
+					}
+					return t.prototype.parseExprOp.call(this, e$2, s$1, i, r$1, a);
+				}, p.parseImportSpecifiers = function() {
+					var t$1 = [], e$2 = !0;
+					if (N$1.tokenIsIdentifier(this.type) && (t$1.push(this.parseImportDefaultSpecifier()), !this.eat(M.comma))) return t$1;
+					if (this.type === M.star) return t$1.push(this.parseImportNamespaceSpecifier()), t$1;
+					for (this.expect(M.braceL); !this.eat(M.braceR);) {
+						if (e$2) e$2 = !1;
+						else if (this.expect(M.comma), this.afterTrailingComma(M.braceR)) break;
+						t$1.push(this.parseImportSpecifier());
+					}
+					return t$1;
+				}, p.parseImport = function(t$1) {
+					var e$2 = this.lookahead();
+					if (t$1.importKind = "value", this.importOrExportOuterKind = "value", z(e$2.type) || this.match(M.star) || this.match(M.braceL)) {
+						var s$1 = this.lookahead(2);
+						if (s$1.type !== M.comma && !this.isContextualWithState("from", s$1) && s$1.type !== M.eq && this.ts_eatContextualWithState("type", 1, e$2) && (this.importOrExportOuterKind = "type", t$1.importKind = "type", e$2 = this.lookahead(), s$1 = this.lookahead(2)), z(e$2.type) && s$1.type === M.eq) {
+							this.next();
+							var i = this.tsParseImportEqualsDeclaration(t$1);
+							return this.importOrExportOuterKind = "value", i;
+						}
+					}
+					return this.next(), this.type === M.string ? (t$1.specifiers = [], t$1.source = this.parseExprAtom()) : (t$1.specifiers = this.parseImportSpecifiers(), this.expectContextual("from"), t$1.source = this.type === M.string ? this.parseExprAtom() : this.unexpected()), this.parseMaybeImportAttributes(t$1), this.semicolon(), this.finishNode(t$1, "ImportDeclaration"), this.importOrExportOuterKind = "value", "type" === t$1.importKind && t$1.specifiers.length > 1 && "ImportDefaultSpecifier" === t$1.specifiers[0].type && this.raise(t$1.start, T.TypeImportCannotSpecifyDefaultAndNamed), t$1;
+				}, p.parseExportDefaultDeclaration = function() {
+					if (this.isAbstractClass()) {
+						var e$2 = this.startNode();
+						return this.next(), e$2.abstract = !0, this.parseClass(e$2, !0);
+					}
+					if (this.match(B.interface)) {
+						var s$1 = this.tsParseInterfaceDeclaration(this.startNode());
+						if (s$1) return s$1;
+					}
+					return t.prototype.parseExportDefaultDeclaration.call(this);
+				}, p.parseExportAllDeclaration = function(t$1, e$2) {
+					return this.options.ecmaVersion >= 11 && (this.eatContextual("as") ? (t$1.exported = this.parseModuleExportName(), this.checkExport(e$2, t$1.exported, this.lastTokStart)) : t$1.exported = null), this.expectContextual("from"), this.type !== M.string && this.unexpected(), t$1.source = this.parseExprAtom(), this.parseMaybeImportAttributes(t$1), this.semicolon(), this.finishNode(t$1, "ExportAllDeclaration");
+				}, p.parseDynamicImport = function(t$1) {
+					if (this.next(), t$1.source = this.parseMaybeAssign(), this.eat(M.comma)) t$1.arguments = [this.parseExpression()];
+					if (!this.eat(M.parenR)) {
+						var s$1 = this.start;
+						this.eat(M.comma) && this.eat(M.parenR) ? this.raiseRecoverable(s$1, "Trailing comma is not allowed in import()") : this.unexpected(s$1);
+					}
+					return this.finishNode(t$1, "ImportExpression");
+				}, p.parseExport = function(t$1, e$2) {
+					var s$1 = this.lookahead();
+					if (this.ts_eatWithState(M._import, 2, s$1)) {
+						this.ts_isContextual(B.type) && 61 !== this.lookaheadCharCode() ? (t$1.importKind = "type", this.importOrExportOuterKind = "type", this.next()) : (t$1.importKind = "value", this.importOrExportOuterKind = "value");
+						var i = this.tsParseImportEqualsDeclaration(t$1, !0);
+						return this.importOrExportOuterKind = void 0, i;
+					}
+					if (this.ts_eatWithState(M.eq, 2, s$1)) {
+						var r$1 = t$1;
+						return r$1.expression = this.parseExpression(), this.semicolon(), this.importOrExportOuterKind = void 0, this.finishNode(r$1, "TSExportAssignment");
+					}
+					if (this.ts_eatContextualWithState("as", 2, s$1)) {
+						var a = t$1;
+						return this.expectContextual("namespace"), a.id = this.parseIdent(), this.semicolon(), this.importOrExportOuterKind = void 0, this.finishNode(a, "TSNamespaceExportDeclaration");
+					}
+					if (this.ts_isContextualWithState(s$1, B.type) && this.lookahead(2).type === M.braceL ? (this.next(), this.importOrExportOuterKind = "type", t$1.exportKind = "type") : (this.importOrExportOuterKind = "value", t$1.exportKind = "value"), this.next(), this.eat(M.star)) return this.parseExportAllDeclaration(t$1, e$2);
+					if (this.eat(M._default)) return this.checkExport(e$2, "default", this.lastTokStart), t$1.declaration = this.parseExportDefaultDeclaration(), this.finishNode(t$1, "ExportDefaultDeclaration");
+					if (this.shouldParseExportStatement()) t$1.declaration = this.parseExportDeclaration(t$1), "VariableDeclaration" === t$1.declaration.type ? this.checkVariableExport(e$2, t$1.declaration.declarations) : this.checkExport(e$2, t$1.declaration.id, t$1.declaration.id.start), t$1.specifiers = [], t$1.source = null;
+					else {
+						if (t$1.declaration = null, t$1.specifiers = this.parseExportSpecifiers(e$2), this.eatContextual("from")) this.type !== M.string && this.unexpected(), t$1.source = this.parseExprAtom(), this.parseMaybeImportAttributes(t$1);
+						else {
+							for (var n$3, o$2 = h(t$1.specifiers); !(n$3 = o$2()).done;) {
+								var p$1 = n$3.value;
+								this.checkUnreserved(p$1.local), this.checkLocalExport(p$1.local), "Literal" === p$1.local.type && this.raise(p$1.local.start, "A string literal cannot be used as an exported binding without `from`.");
+							}
+							t$1.source = null;
+						}
+						this.semicolon();
+					}
+					return this.finishNode(t$1, "ExportNamedDeclaration");
+				}, p.checkExport = function(t$1, e$2, s$1) {
+					t$1 && ("string" != typeof e$2 && (e$2 = "Identifier" === e$2.type ? e$2.name : e$2.value), t$1[e$2] = !0);
+				}, p.parseMaybeDefault = function(e$2, s$1, i) {
+					var r$1 = t.prototype.parseMaybeDefault.call(this, e$2, s$1, i);
+					return "AssignmentPattern" === r$1.type && r$1.typeAnnotation && r$1.right.start < r$1.typeAnnotation.start && this.raise(r$1.typeAnnotation.start, T.TypeAnnotationAfterAssign), r$1;
+				}, p.typeCastToParameter = function(t$1) {
+					return t$1.expression.typeAnnotation = t$1.typeAnnotation, this.resetEndLocation(t$1.expression, t$1.typeAnnotation.end), t$1.expression;
+				}, p.toAssignableList = function(e$2, s$1) {
+					for (var i = 0; i < e$2.length; i++) {
+						var r$1 = e$2[i];
+						"TSTypeCastExpression" === (null == r$1 ? void 0 : r$1.type) && (e$2[i] = this.typeCastToParameter(r$1));
+					}
+					return t.prototype.toAssignableList.call(this, e$2, s$1);
+				}, p.reportReservedArrowTypeParam = function(t$1) {}, p.parseExprAtom = function(e$2, s$1, i) {
+					if (this.type === B.jsxText) return this.jsx_parseText();
+					if (this.type === B.jsxTagStart) return this.jsx_parseElement();
+					if (this.type === B.at) return this.parseDecorators(), this.parseExprAtom();
+					if (z(this.type)) {
+						var r$1 = this.potentialArrowAt === this.start, a = this.start, n$3 = this.startLoc, o$2 = this.containsEsc, h = this.parseIdent(!1);
+						if (this.options.ecmaVersion >= 8 && !o$2 && "async" === h.name && !this.canInsertSemicolon() && this.eat(M._function)) return this.overrideContext(j.f_expr), this.parseFunction(this.startNodeAt(a, n$3), 0, !1, !0, s$1);
+						if (r$1 && !this.canInsertSemicolon()) {
+							if (this.eat(M.arrow)) return this.parseArrowExpression(this.startNodeAt(a, n$3), [h], !1, s$1);
+							if (this.options.ecmaVersion >= 8 && "async" === h.name && this.type === M.name && !o$2 && (!this.potentialArrowInForAwait || "of" !== this.value || this.containsEsc)) return h = this.parseIdent(!1), !this.canInsertSemicolon() && this.eat(M.arrow) || this.unexpected(), this.parseArrowExpression(this.startNodeAt(a, n$3), [h], !0, s$1);
+						}
+						return h;
+					}
+					return t.prototype.parseExprAtom.call(this, e$2, s$1, i);
+				}, p.parseExprAtomDefault = function() {
+					if (z(this.type)) {
+						var t$1 = this.potentialArrowAt === this.start, e$2 = this.containsEsc, s$1 = this.parseIdent();
+						if (!e$2 && "async" === s$1.name && !this.canInsertSemicolon()) {
+							var i = this.type;
+							if (i === M._function) return this.next(), this.parseFunction(this.startNodeAtNode(s$1), void 0, !0, !0);
+							if (z(i)) {
+								if (61 === this.lookaheadCharCode()) {
+									var r$1 = this.parseIdent(!1);
+									return !this.canInsertSemicolon() && this.eat(M.arrow) || this.unexpected(), this.parseArrowExpression(this.startNodeAtNode(s$1), [r$1], !0);
+								}
+								return s$1;
+							}
+						}
+						return t$1 && this.match(M.arrow) && !this.canInsertSemicolon() ? (this.next(), this.parseArrowExpression(this.startNodeAtNode(s$1), [s$1], !1)) : s$1;
+					}
+					this.unexpected();
+				}, p.parseIdentNode = function() {
+					var e$2 = this.startNode();
+					return J(this.type) ? (e$2.name = this.value, e$2) : t.prototype.parseIdentNode.call(this);
+				}, p.parseVarStatement = function(e$2, s$1, i) {
+					void 0 === i && (i = !1);
+					var r$1 = this.isAmbientContext;
+					this.next(), t.prototype.parseVar.call(this, e$2, !1, s$1, i || r$1), this.semicolon();
+					var a = this.finishNode(e$2, "VariableDeclaration");
+					if (!r$1) return a;
+					for (var n$3, o$2 = h(a.declarations); !(n$3 = o$2()).done;) {
+						var p$1 = n$3.value, c = p$1.init;
+						c && ("const" !== s$1 || p$1.id.typeAnnotation ? this.raise(c.start, T.InitializerNotAllowedInAmbientContext) : "StringLiteral" !== c.type && "BooleanLiteral" !== c.type && "NumericLiteral" !== c.type && "BigIntLiteral" !== c.type && ("TemplateLiteral" !== c.type || c.expressions.length > 0) && !I(c) && this.raise(c.start, T.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference));
+					}
+					return a;
+				}, p.parseStatement = function(e$2, s$1, i) {
+					if (this.match(B.at) && this.parseDecorators(!0), this.match(M._const) && this.isLookaheadContextual("enum")) {
+						var r$1 = this.startNode();
+						return this.expect(M._const), this.tsParseEnumDeclaration(r$1, { const: !0 });
+					}
+					if (this.ts_isContextual(B.enum)) return this.tsParseEnumDeclaration(this.startNode());
+					if (this.ts_isContextual(B.interface)) {
+						var a = this.tsParseInterfaceDeclaration(this.startNode());
+						if (a) return a;
+					}
+					return t.prototype.parseStatement.call(this, e$2, s$1, i);
+				}, p.parseAccessModifier = function() {
+					return this.tsParseModifier([
+						"public",
+						"protected",
+						"private"
+					]);
+				}, p.parsePostMemberNameModifiers = function(t$1) {
+					this.eat(M.question) && (t$1.optional = !0), t$1.readonly && this.match(M.parenL) && this.raise(t$1.start, T.ClassMethodHasReadonly), t$1.declare && this.match(M.parenL) && this.raise(t$1.start, T.ClassMethodHasDeclare);
+				}, p.parseExpressionStatement = function(e$2, s$1) {
+					return ("Identifier" === s$1.type ? this.tsParseExpressionStatement(e$2, s$1) : void 0) || t.prototype.parseExpressionStatement.call(this, e$2, s$1);
+				}, p.shouldParseExportStatement = function() {
+					return !!this.tsIsDeclarationStart() || !!this.match(B.at) || t.prototype.shouldParseExportStatement.call(this);
+				}, p.parseConditional = function(t$1, e$2, s$1, i, r$1) {
+					if (this.eat(M.question)) {
+						var a = this.startNodeAt(e$2, s$1);
+						return a.test = t$1, a.consequent = this.parseMaybeAssign(), this.expect(M.colon), a.alternate = this.parseMaybeAssign(i), this.finishNode(a, "ConditionalExpression");
+					}
+					return t$1;
+				}, p.parseMaybeConditional = function(t$1, e$2) {
+					var s$1 = this, i = this.start, r$1 = this.startLoc, a = this.parseExprOps(t$1, e$2);
+					if (this.checkExpressionErrors(e$2)) return a;
+					if (!this.maybeInArrowParameters || !this.match(M.question)) return this.parseConditional(a, i, r$1, t$1, e$2);
+					var n$3 = this.tryParse(function() {
+						return s$1.parseConditional(a, i, r$1, t$1, e$2);
+					});
+					return n$3.node ? (n$3.error && this.setLookaheadState(n$3.failState), n$3.node) : (n$3.error && this.setOptionalParametersError(e$2, n$3.error), a);
+				}, p.parseParenItem = function(e$2) {
+					var s$1 = this.start, i = this.startLoc;
+					if (e$2 = t.prototype.parseParenItem.call(this, e$2), this.eat(M.question) && (e$2.optional = !0, this.resetEndLocation(e$2)), this.match(M.colon)) {
+						var r$1 = this.startNodeAt(s$1, i);
+						return r$1.expression = e$2, r$1.typeAnnotation = this.tsParseTypeAnnotation(), this.finishNode(r$1, "TSTypeCastExpression");
+					}
+					return e$2;
+				}, p.parseExportDeclaration = function(t$1) {
+					var e$2 = this;
+					if (!this.isAmbientContext && this.ts_isContextual(B.declare)) return this.tsInAmbientContext(function() {
+						return e$2.parseExportDeclaration(t$1);
+					});
+					var s$1 = this.start, i = this.startLoc, r$1 = this.eatContextual("declare");
+					!r$1 || !this.ts_isContextual(B.declare) && this.shouldParseExportStatement() || this.raise(this.start, T.ExpectedAmbientAfterExportDeclare);
+					var a = z(this.type) && this.tsTryParseExportDeclaration() || this.parseStatement(null);
+					return a ? (("TSInterfaceDeclaration" === a.type || "TSTypeAliasDeclaration" === a.type || r$1) && (t$1.exportKind = "type"), r$1 && (this.resetStartLocation(a, s$1, i), a.declare = !0), a) : null;
+				}, p.parseClassId = function(e$2, s$1) {
+					if (s$1 || !this.isContextual("implements")) {
+						t.prototype.parseClassId.call(this, e$2, s$1);
+						var i = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
+						i && (e$2.typeParameters = i);
+					}
+				}, p.parseClassPropertyAnnotation = function(t$1) {
+					t$1.optional || ("!" === this.value && this.eat(M.prefix) ? t$1.definite = !0 : this.eat(M.question) && (t$1.optional = !0));
+					var e$2 = this.tsTryParseTypeAnnotation();
+					e$2 && (t$1.typeAnnotation = e$2);
+				}, p.parseClassField = function(e$2) {
+					if ("PrivateIdentifier" === e$2.key.type) e$2.abstract && this.raise(e$2.start, T.PrivateElementHasAbstract), e$2.accessibility && this.raise(e$2.start, T.PrivateElementHasAccessibility({ modifier: e$2.accessibility })), this.parseClassPropertyAnnotation(e$2);
+					else if (this.parseClassPropertyAnnotation(e$2), this.isAmbientContext && (!e$2.readonly || e$2.typeAnnotation) && this.match(M.eq) && this.raise(this.start, T.DeclareClassFieldHasInitializer), e$2.abstract && this.match(M.eq)) {
+						var s$1 = e$2.key;
+						this.raise(this.start, T.AbstractPropertyHasInitializer({ propertyName: "Identifier" !== s$1.type || e$2.computed ? "[" + this.input.slice(s$1.start, s$1.end) + "]" : s$1.name }));
+					}
+					return t.prototype.parseClassField.call(this, e$2);
+				}, p.parseClassMethod = function(t$1, e$2, s$1, i) {
+					var r$1 = "constructor" === t$1.kind, a = "PrivateIdentifier" === t$1.key.type, n$3 = this.tsTryParseTypeParameters();
+					a ? (n$3 && (t$1.typeParameters = n$3), t$1.accessibility && this.raise(t$1.start, T.PrivateMethodsHasAccessibility({ modifier: t$1.accessibility }))) : n$3 && r$1 && this.raise(n$3.start, T.ConstructorHasTypeParameters);
+					var o$2 = t$1.declare, h = t$1.kind;
+					!(void 0 !== o$2 && o$2) || "get" !== h && "set" !== h || this.raise(t$1.start, T.DeclareAccessor({ kind: h })), n$3 && (t$1.typeParameters = n$3);
+					var p$1 = t$1.key;
+					"constructor" === t$1.kind ? (e$2 && this.raise(p$1.start, "Constructor can't be a generator"), s$1 && this.raise(p$1.start, "Constructor can't be an async method")) : t$1.static && x(t$1, "prototype") && this.raise(p$1.start, "Classes may not have a static property named prototype");
+					var c = t$1.value = this.parseMethod(e$2, s$1, i, !0, t$1);
+					return "get" === t$1.kind && 0 !== c.params.length && this.raiseRecoverable(c.start, "getter should have no params"), "set" === t$1.kind && 1 !== c.params.length && this.raiseRecoverable(c.start, "setter should have exactly one param"), "set" === t$1.kind && "RestElement" === c.params[0].type && this.raiseRecoverable(c.params[0].start, "Setter cannot use rest params"), this.finishNode(t$1, "MethodDefinition");
+				}, p.isClassMethod = function() {
+					return this.match(M.relational);
+				}, p.parseClassElement = function(e$2) {
+					var s$1 = this;
+					if (this.eat(M.semi)) return null;
+					var i, r$1 = this.options.ecmaVersion, a = this.startNode(), n$3 = "", o$2 = !1, h = !1, p$1 = "method", c = [
+						"declare",
+						"private",
+						"public",
+						"protected",
+						"accessor",
+						"override",
+						"abstract",
+						"readonly",
+						"static"
+					], l = this.tsParseModifiers({
+						modified: a,
+						allowedModifiers: c,
+						disallowedModifiers: ["in", "out"],
+						stopOnStartOfClassStaticBlock: !0,
+						errorTemplate: T.InvalidModifierOnTypeParameterPositions
+					});
+					i = Boolean(l.static);
+					var u = function() {
+						if (!s$1.tsIsStartOfStaticBlocks()) {
+							var l$1 = s$1.tsTryParseIndexSignature(a);
+							if (l$1) return a.abstract && s$1.raise(a.start, T.IndexSignatureHasAbstract), a.accessibility && s$1.raise(a.start, T.IndexSignatureHasAccessibility({ modifier: a.accessibility })), a.declare && s$1.raise(a.start, T.IndexSignatureHasDeclare), a.override && s$1.raise(a.start, T.IndexSignatureHasOverride), l$1;
+							if (!s$1.inAbstractClass && a.abstract && s$1.raise(a.start, T.NonAbstractClassHasAbstractMethod), a.override && e$2 && s$1.raise(a.start, T.OverrideNotInSubClass), a.static = i, i && (s$1.isClassElementNameStart() || s$1.type === M.star || (n$3 = "static")), !n$3 && r$1 >= 8 && s$1.eatContextual("async") && (!s$1.isClassElementNameStart() && s$1.type !== M.star || s$1.canInsertSemicolon() ? n$3 = "async" : h = !0), !n$3 && (r$1 >= 9 || !h) && s$1.eat(M.star) && (o$2 = !0), !n$3 && !h && !o$2) {
+								var u$1 = s$1.value;
+								(s$1.eatContextual("get") || s$1.eatContextual("set")) && (s$1.isClassElementNameStart() ? p$1 = u$1 : n$3 = u$1);
+							}
+							if (n$3 ? (a.computed = !1, a.key = s$1.startNodeAt(s$1.lastTokStart, s$1.lastTokStartLoc), a.key.name = n$3, s$1.finishNode(a.key, "Identifier")) : s$1.parseClassElementName(a), s$1.parsePostMemberNameModifiers(a), s$1.isClassMethod() || r$1 < 13 || s$1.type === M.parenL || "method" !== p$1 || o$2 || h) {
+								var d$1 = !a.static && x(a, "constructor"), m = d$1 && e$2;
+								d$1 && "method" !== p$1 && s$1.raise(a.key.start, "Constructor can't have get/set modifier"), a.kind = d$1 ? "constructor" : p$1, s$1.parseClassMethod(a, o$2, h, m);
+							} else s$1.parseClassField(a);
+							return a;
+						}
+						if (s$1.next(), s$1.next(), s$1.tsHasSomeModifiers(a, c) && s$1.raise(s$1.start, T.StaticBlockCannotHaveModifier), r$1 >= 13) return t.prototype.parseClassStaticBlock.call(s$1, a), a;
+					};
+					return a.declare ? this.tsInAmbientContext(u) : u(), a;
+				}, p.isClassElementNameStart = function() {
+					return !!this.tsIsIdentifier() || t.prototype.isClassElementNameStart.call(this);
+				}, p.parseClassSuper = function(e$2) {
+					t.prototype.parseClassSuper.call(this, e$2), e$2.superClass && (this.tsMatchLeftRelational() || this.match(M.bitShift)) && (e$2.superTypeParameters = this.tsParseTypeArgumentsInExpression()), this.eatContextual("implements") && (e$2.implements = this.tsParseHeritageClause("implements"));
+				}, p.parseFunctionParams = function(e$2) {
+					var s$1 = this.tsTryParseTypeParameters();
+					s$1 && (e$2.typeParameters = s$1), t.prototype.parseFunctionParams.call(this, e$2);
+				}, p.parseVarId = function(e$2, s$1) {
+					t.prototype.parseVarId.call(this, e$2, s$1), "Identifier" === e$2.id.type && !this.hasPrecedingLineBreak() && "!" === this.value && this.eat(M.prefix) && (e$2.definite = !0);
+					var i = this.tsTryParseTypeAnnotation();
+					i && (e$2.id.typeAnnotation = i, this.resetEndLocation(e$2.id));
+				}, p.parseArrowExpression = function(t$1, e$2, s$1, i) {
+					this.match(M.colon) && (t$1.returnType = this.tsParseTypeAnnotation());
+					var r$1 = this.yieldPos, a = this.awaitPos, n$3 = this.awaitIdentPos;
+					this.enterScope(16 | E(s$1, !1)), this.initFunction(t$1);
+					var o$2 = this.maybeInArrowParameters;
+					return this.options.ecmaVersion >= 8 && (t$1.async = !!s$1), this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.maybeInArrowParameters = !0, t$1.params = this.toAssignableList(e$2, !0), this.maybeInArrowParameters = !1, this.parseFunctionBody(t$1, !0, !1, i), this.yieldPos = r$1, this.awaitPos = a, this.awaitIdentPos = n$3, this.maybeInArrowParameters = o$2, this.finishNode(t$1, "ArrowFunctionExpression");
+				}, p.parseMaybeAssignOrigin = function(t$1, e$2, s$1) {
+					if (this.isContextual("yield")) {
+						if (this.inGenerator) return this.parseYield(t$1);
+						this.exprAllowed = !1;
+					}
+					var i = !1, r$1 = -1, a = -1, n$3 = -1;
+					e$2 ? (r$1 = e$2.parenthesizedAssign, a = e$2.trailingComma, n$3 = e$2.doubleProto, e$2.parenthesizedAssign = e$2.trailingComma = -1) : (e$2 = new y(), i = !0);
+					var o$2 = this.start, h = this.startLoc;
+					(this.type === M.parenL || z(this.type)) && (this.potentialArrowAt = this.start, this.potentialArrowInForAwait = "await" === t$1);
+					var p$1 = this.parseMaybeConditional(t$1, e$2);
+					if (s$1 && (p$1 = s$1.call(this, p$1, o$2, h)), this.type.isAssign) {
+						var c = this.startNodeAt(o$2, h);
+						return c.operator = this.value, this.type === M.eq && (p$1 = this.toAssignable(p$1, !0, e$2)), i || (e$2.parenthesizedAssign = e$2.trailingComma = e$2.doubleProto = -1), e$2.shorthandAssign >= p$1.start && (e$2.shorthandAssign = -1), this.type === M.eq ? this.checkLValPattern(p$1) : this.checkLValSimple(p$1), c.left = p$1, this.next(), c.right = this.parseMaybeAssign(t$1), n$3 > -1 && (e$2.doubleProto = n$3), this.finishNode(c, "AssignmentExpression");
+					}
+					return i && this.checkExpressionErrors(e$2, !0), r$1 > -1 && (e$2.parenthesizedAssign = r$1), a > -1 && (e$2.trailingComma = a), p$1;
+				}, p.parseMaybeAssign = function(t$1, e$2, s$1) {
+					var i, r$1, a, n$3, o$2, h, p$1, c, l, u, d$1, m = this;
+					if (this.matchJsx("jsxTagStart") || this.tsMatchLeftRelational()) {
+						if (c = this.cloneCurLookaheadState(), !(l = this.tryParse(function() {
+							return m.parseMaybeAssignOrigin(t$1, e$2, s$1);
+						}, c)).error) return l.node;
+						var y = this.context, f = y[y.length - 1];
+						f === N$1.tokContexts.tc_oTag && y[y.length - 2] === N$1.tokContexts.tc_expr ? (y.pop(), y.pop()) : f !== N$1.tokContexts.tc_oTag && f !== N$1.tokContexts.tc_expr || y.pop();
+					}
+					if (!(null != (i = l) && i.error || this.tsMatchLeftRelational())) return this.parseMaybeAssignOrigin(t$1, e$2, s$1);
+					c && !this.compareLookaheadState(c, this.getCurLookaheadState()) || (c = this.cloneCurLookaheadState());
+					var x = this.tryParse(function(i$1) {
+						var r$2, a$1;
+						d$1 = m.tsParseTypeParameters();
+						var n$4 = m.parseMaybeAssignOrigin(t$1, e$2, s$1);
+						return ("ArrowFunctionExpression" !== n$4.type || null != (r$2 = n$4.extra) && r$2.parenthesized) && i$1(), 0 !== (null == (a$1 = d$1) ? void 0 : a$1.params.length) && m.resetStartLocationFromNode(n$4, d$1), n$4.typeParameters = d$1, n$4;
+					}, c);
+					if (!x.error && !x.aborted) return d$1 && this.reportReservedArrowTypeParam(d$1), x.node;
+					if (!l && (S(!0), !(u = this.tryParse(function() {
+						return m.parseMaybeAssignOrigin(t$1, e$2, s$1);
+					}, c)).error)) return u.node;
+					if (null != (r$1 = l) && r$1.node) return this.setLookaheadState(l.failState), l.node;
+					if (x.node) return this.setLookaheadState(x.failState), d$1 && this.reportReservedArrowTypeParam(d$1), x.node;
+					if (null != (a = u) && a.node) return this.setLookaheadState(u.failState), u.node;
+					if (null != (n$3 = l) && n$3.thrown) throw l.error;
+					if (x.thrown) throw x.error;
+					if (null != (o$2 = u) && o$2.thrown) throw u.error;
+					throw (null == (h = l) ? void 0 : h.error) || x.error || (null == (p$1 = u) ? void 0 : p$1.error);
+				}, p.parseAssignableListItem = function(t$1) {
+					for (var e$2 = []; this.match(B.at);) e$2.push(this.parseDecorator());
+					var s$1, i = this.start, r$1 = this.startLoc, a = !1, n$3 = !1;
+					if (void 0 !== t$1) {
+						var o$2 = {};
+						this.tsParseModifiers({
+							modified: o$2,
+							allowedModifiers: [
+								"public",
+								"private",
+								"protected",
+								"override",
+								"readonly"
+							]
+						}), s$1 = o$2.accessibility, n$3 = o$2.override, a = o$2.readonly, !1 === t$1 && (s$1 || a || n$3) && this.raise(r$1.start, T.UnexpectedParameterModifier);
+					}
+					var h = this.parseMaybeDefault(i, r$1);
+					this.parseBindingListItem(h);
+					var p$1 = this.parseMaybeDefault(h.start, h.loc, h);
+					if (e$2.length && (p$1.decorators = e$2), s$1 || a || n$3) {
+						var c = this.startNodeAt(i, r$1);
+						return s$1 && (c.accessibility = s$1), a && (c.readonly = a), n$3 && (c.override = n$3), "Identifier" !== p$1.type && "AssignmentPattern" !== p$1.type && this.raise(c.start, T.UnsupportedParameterPropertyKind), c.parameter = p$1, this.finishNode(c, "TSParameterProperty");
+					}
+					return p$1;
+				}, p.checkLValInnerPattern = function(e$2, s$1, i) {
+					void 0 === s$1 && (s$1 = 0), "TSParameterProperty" === e$2.type ? this.checkLValInnerPattern(e$2.parameter, s$1, i) : t.prototype.checkLValInnerPattern.call(this, e$2, s$1, i);
+				}, p.parseBindingListItem = function(t$1) {
+					this.eat(M.question) && ("Identifier" === t$1.type || this.isAmbientContext || this.inType || this.raise(t$1.start, T.PatternIsOptional), t$1.optional = !0);
+					var e$2 = this.tsTryParseTypeAnnotation();
+					return e$2 && (t$1.typeAnnotation = e$2), this.resetEndLocation(t$1), t$1;
+				}, p.isAssignable = function(t$1, e$2) {
+					var s$1 = this;
+					switch (t$1.type) {
+						case "TSTypeCastExpression": return this.isAssignable(t$1.expression, e$2);
+						case "TSParameterProperty":
+						case "Identifier":
+						case "ObjectPattern":
+						case "ArrayPattern":
+						case "AssignmentPattern":
+						case "RestElement": return !0;
+						case "ObjectExpression":
+							var i = t$1.properties.length - 1;
+							return t$1.properties.every(function(t$2, e$3) {
+								return "ObjectMethod" !== t$2.type && (e$3 === i || "SpreadElement" !== t$2.type) && s$1.isAssignable(t$2);
+							});
+						case "Property":
+						case "ObjectProperty": return this.isAssignable(t$1.value);
+						case "SpreadElement": return this.isAssignable(t$1.argument);
+						case "ArrayExpression": return t$1.elements.every(function(t$2) {
+							return null === t$2 || s$1.isAssignable(t$2);
+						});
+						case "AssignmentExpression": return "=" === t$1.operator;
+						case "ParenthesizedExpression": return this.isAssignable(t$1.expression);
+						case "MemberExpression":
+						case "OptionalMemberExpression": return !e$2;
+						default: return !1;
+					}
+				}, p.toAssignable = function(e$2, s$1, i) {
+					switch (void 0 === s$1 && (s$1 = !1), void 0 === i && (i = new y()), e$2.type) {
+						case "ParenthesizedExpression": return this.toAssignableParenthesizedExpression(e$2, s$1, i);
+						case "TSAsExpression":
+						case "TSSatisfiesExpression":
+						case "TSNonNullExpression":
+						case "TSTypeAssertion": return s$1 || this.raise(e$2.start, T.UnexpectedTypeCastInParameter), this.toAssignable(e$2.expression, s$1, i);
+						case "MemberExpression": break;
+						case "AssignmentExpression": return s$1 || "TSTypeCastExpression" !== e$2.left.type || (e$2.left = this.typeCastToParameter(e$2.left)), t.prototype.toAssignable.call(this, e$2, s$1, i);
+						case "TSTypeCastExpression": return this.typeCastToParameter(e$2);
+						default: return t.prototype.toAssignable.call(this, e$2, s$1, i);
+					}
+					return e$2;
+				}, p.toAssignableParenthesizedExpression = function(e$2, s$1, i) {
+					switch (e$2.expression.type) {
+						case "TSAsExpression":
+						case "TSSatisfiesExpression":
+						case "TSNonNullExpression":
+						case "TSTypeAssertion":
+						case "ParenthesizedExpression": return this.toAssignable(e$2.expression, s$1, i);
+						default: return t.prototype.toAssignable.call(this, e$2, s$1, i);
+					}
+				}, p.curPosition = function() {
+					if (this.options.locations) {
+						var e$2 = t.prototype.curPosition.call(this);
+						return Object.defineProperty(e$2, "offset", { get: function() {
+							return function(t$1) {
+								var e$3 = new o$1.Position(this.line, this.column + t$1);
+								return e$3.index = this.index + t$1, e$3;
+							};
+						} }), e$2.index = this.pos, e$2;
+					}
+				}, p.parseBindingAtom = function() {
+					return this.type === M._this ? this.parseIdent(!0) : t.prototype.parseBindingAtom.call(this);
+				}, p.shouldParseArrow = function(t$1) {
+					var e$2, s$1 = this;
+					if (e$2 = this.match(M.colon) ? t$1.every(function(t$2) {
+						return s$1.isAssignable(t$2, !0);
+					}) : !this.canInsertSemicolon()) {
+						if (this.match(M.colon)) {
+							var i = this.tryParse(function(t$2) {
+								var e$3 = s$1.tsParseTypeOrTypePredicateAnnotation(M.colon);
+								return !s$1.canInsertSemicolon() && s$1.match(M.arrow) || t$2(), e$3;
+							});
+							if (i.aborted) return this.shouldParseArrowReturnType = void 0, !1;
+							i.thrown || (i.error && this.setLookaheadState(i.failState), this.shouldParseArrowReturnType = i.node);
+						}
+						return !!this.match(M.arrow) || (this.shouldParseArrowReturnType = void 0, !1);
+					}
+					return this.shouldParseArrowReturnType = void 0, e$2;
+				}, p.parseParenArrowList = function(t$1, e$2, s$1, i) {
+					var r$1 = this.startNodeAt(t$1, e$2);
+					return r$1.returnType = this.shouldParseArrowReturnType, this.shouldParseArrowReturnType = void 0, this.parseArrowExpression(r$1, s$1, !1, i);
+				}, p.parseParenAndDistinguishExpression = function(t$1, e$2) {
+					var s$1, i = this.start, r$1 = this.startLoc, a = this.options.ecmaVersion >= 8;
+					if (this.options.ecmaVersion >= 6) {
+						var n$3 = this.maybeInArrowParameters;
+						this.maybeInArrowParameters = !0, this.next();
+						var o$2, h = this.start, p$1 = this.startLoc, c = [], l = !0, u = !1, d$1 = new y(), m = this.yieldPos, f = this.awaitPos;
+						for (this.yieldPos = 0, this.awaitPos = 0; this.type !== M.parenR;) {
+							if (l ? l = !1 : this.expect(M.comma), a && this.afterTrailingComma(M.parenR, !0)) {
+								u = !0;
+								break;
+							}
+							if (this.type === M.ellipsis) {
+								o$2 = this.start, c.push(this.parseParenItem(this.parseRestBinding())), this.type === M.comma && this.raise(this.start, "Comma is not permitted after the rest element");
+								break;
+							}
+							c.push(this.parseMaybeAssign(e$2, d$1, this.parseParenItem));
+						}
+						var x = this.lastTokEnd, T = this.lastTokEndLoc;
+						if (this.expect(M.parenR), this.maybeInArrowParameters = n$3, t$1 && this.shouldParseArrow(c) && this.eat(M.arrow)) return this.checkPatternErrors(d$1, !1), this.checkYieldAwaitInDefaultParams(), this.yieldPos = m, this.awaitPos = f, this.parseParenArrowList(i, r$1, c, e$2);
+						c.length && !u || this.unexpected(this.lastTokStart), o$2 && this.unexpected(o$2), this.checkExpressionErrors(d$1, !0), this.yieldPos = m || this.yieldPos, this.awaitPos = f || this.awaitPos, c.length > 1 ? ((s$1 = this.startNodeAt(h, p$1)).expressions = c, this.finishNodeAt(s$1, "SequenceExpression", x, T)) : s$1 = c[0];
+					} else s$1 = this.parseParenExpression();
+					if (this.options.preserveParens) {
+						var v = this.startNodeAt(i, r$1);
+						return v.expression = s$1, this.finishNode(v, "ParenthesizedExpression");
+					}
+					return s$1;
+				}, p.parseTaggedTemplateExpression = function(t$1, e$2, s$1, i) {
+					var r$1 = this.startNodeAt(e$2, s$1);
+					return r$1.tag = t$1, r$1.quasi = this.parseTemplate({ isTagged: !0 }), i && this.raise(e$2, "Tagged Template Literals are not allowed in optionalChain."), this.finishNode(r$1, "TaggedTemplateExpression");
+				}, p.shouldParseAsyncArrow = function() {
+					var t$1 = this;
+					if (!this.match(M.colon)) return !this.canInsertSemicolon() && this.eat(M.arrow);
+					var e$2 = this.tryParse(function(e$3) {
+						var s$1 = t$1.tsParseTypeOrTypePredicateAnnotation(M.colon);
+						return !t$1.canInsertSemicolon() && t$1.match(M.arrow) || e$3(), s$1;
+					});
+					return e$2.aborted ? (this.shouldParseAsyncArrowReturnType = void 0, !1) : e$2.thrown ? void 0 : (e$2.error && this.setLookaheadState(e$2.failState), this.shouldParseAsyncArrowReturnType = e$2.node, !this.canInsertSemicolon() && this.eat(M.arrow));
+				}, p.parseSubscriptAsyncArrow = function(t$1, e$2, s$1, i) {
+					var r$1 = this.startNodeAt(t$1, e$2);
+					return r$1.returnType = this.shouldParseAsyncArrowReturnType, this.shouldParseAsyncArrowReturnType = void 0, this.parseArrowExpression(r$1, s$1, !0, i);
+				}, p.parseExprList = function(t$1, e$2, s$1, i) {
+					for (var r$1 = [], a = !0; !this.eat(t$1);) {
+						if (a) a = !1;
+						else if (this.expect(M.comma), e$2 && this.afterTrailingComma(t$1)) break;
+						var n$3 = void 0;
+						s$1 && this.type === M.comma ? n$3 = null : this.type === M.ellipsis ? (n$3 = this.parseSpread(i), i && this.type === M.comma && i.trailingComma < 0 && (i.trailingComma = this.start)) : n$3 = this.parseMaybeAssign(!1, i, this.parseParenItem), r$1.push(n$3);
+					}
+					return r$1;
+				}, p.parseSubscript = function(t$1, e$2, s$1, i, r$1, a, n$3) {
+					var o$2 = this, h = a;
+					if (!this.hasPrecedingLineBreak() && "!" === this.value && this.match(M.prefix)) {
+						this.exprAllowed = !1, this.next();
+						var p$1 = this.startNodeAt(e$2, s$1);
+						return p$1.expression = t$1, t$1 = this.finishNode(p$1, "TSNonNullExpression");
+					}
+					var c = !1;
+					if (this.match(M.questionDot) && 60 === this.lookaheadCharCode()) {
+						if (i) return t$1;
+						t$1.optional = !0, h = c = !0, this.next();
+					}
+					if (this.tsMatchLeftRelational() || this.match(M.bitShift)) {
+						var l, u = this.tsTryParseAndCatch(function() {
+							if (!i && o$2.atPossibleAsyncArrow(t$1)) {
+								var r$2 = o$2.tsTryParseGenericAsyncArrowFunction(e$2, s$1, n$3);
+								if (r$2) return t$1 = r$2;
+							}
+							var a$1 = o$2.tsParseTypeArgumentsInExpression();
+							if (!a$1) return t$1;
+							if (c && !o$2.match(M.parenL)) return l = o$2.curPosition(), t$1;
+							if (V(o$2.type) || o$2.type === M.backQuote) {
+								var p$2 = o$2.parseTaggedTemplateExpression(t$1, e$2, s$1, h);
+								return p$2.typeParameters = a$1, p$2;
+							}
+							if (!i && o$2.eat(M.parenL)) {
+								var u$1 = new y(), d$2 = o$2.startNodeAt(e$2, s$1);
+								return d$2.callee = t$1, d$2.arguments = o$2.parseExprList(M.parenR, o$2.options.ecmaVersion >= 8, !1, u$1), o$2.tsCheckForInvalidTypeCasts(d$2.arguments), d$2.typeParameters = a$1, h && (d$2.optional = c), o$2.checkExpressionErrors(u$1, !0), t$1 = o$2.finishNode(d$2, "CallExpression");
+							}
+							var m$1 = o$2.type;
+							if (!(o$2.tsMatchRightRelational() || m$1 === M.bitShift || m$1 !== M.parenL && (f$1 = m$1, Boolean(f$1.startsExpr)) && !o$2.hasPrecedingLineBreak())) {
+								var f$1, x$1 = o$2.startNodeAt(e$2, s$1);
+								return x$1.expression = t$1, x$1.typeParameters = a$1, o$2.finishNode(x$1, "TSInstantiationExpression");
+							}
+						});
+						if (l && this.unexpected(l), u) return "TSInstantiationExpression" === u.type && (this.match(M.dot) || this.match(M.questionDot) && 40 !== this.lookaheadCharCode()) && this.raise(this.start, T.InvalidPropertyAccessAfterInstantiationExpression), t$1 = u;
+					}
+					var d$1 = this.options.ecmaVersion >= 11, m = d$1 && this.eat(M.questionDot);
+					i && m && this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions");
+					var f = this.eat(M.bracketL);
+					if (f || m && this.type !== M.parenL && this.type !== M.backQuote || this.eat(M.dot)) {
+						var x = this.startNodeAt(e$2, s$1);
+						x.object = t$1, f ? (x.property = this.parseExpression(), this.expect(M.bracketR)) : x.property = this.type === M.privateId && "Super" !== t$1.type ? this.parsePrivateIdent() : this.parseIdent("never" !== this.options.allowReserved), x.computed = !!f, d$1 && (x.optional = m), t$1 = this.finishNode(x, "MemberExpression");
+					} else if (!i && this.eat(M.parenL)) {
+						var v = this.maybeInArrowParameters;
+						this.maybeInArrowParameters = !0;
+						var P = new y(), b = this.yieldPos, g = this.awaitPos, A = this.awaitIdentPos;
+						this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0;
+						var S = this.parseExprList(M.parenR, this.options.ecmaVersion >= 8, !1, P);
+						if (r$1 && !m && this.shouldParseAsyncArrow()) this.checkPatternErrors(P, !1), this.checkYieldAwaitInDefaultParams(), this.awaitIdentPos > 0 && this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"), this.yieldPos = b, this.awaitPos = g, this.awaitIdentPos = A, t$1 = this.parseSubscriptAsyncArrow(e$2, s$1, S, n$3);
+						else {
+							this.checkExpressionErrors(P, !0), this.yieldPos = b || this.yieldPos, this.awaitPos = g || this.awaitPos, this.awaitIdentPos = A || this.awaitIdentPos;
+							var k = this.startNodeAt(e$2, s$1);
+							k.callee = t$1, k.arguments = S, d$1 && (k.optional = m), t$1 = this.finishNode(k, "CallExpression");
+						}
+						this.maybeInArrowParameters = v;
+					} else if (this.type === M.backQuote) {
+						(m || h) && this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
+						var C = this.startNodeAt(e$2, s$1);
+						C.tag = t$1, C.quasi = this.parseTemplate({ isTagged: !0 }), t$1 = this.finishNode(C, "TaggedTemplateExpression");
+					}
+					return t$1;
+				}, p.parseGetterSetter = function(t$1) {
+					t$1.kind = t$1.key.name, this.parsePropertyName(t$1), t$1.value = this.parseMethod(!1);
+					var e$2 = "get" === t$1.kind ? 0 : 1, s$1 = t$1.value.params[0], i = s$1 && this.isThisParam(s$1);
+					t$1.value.params.length !== (e$2 = i ? e$2 + 1 : e$2) ? this.raiseRecoverable(t$1.value.start, "get" === t$1.kind ? "getter should have no params" : "setter should have exactly one param") : "set" === t$1.kind && "RestElement" === t$1.value.params[0].type && this.raiseRecoverable(t$1.value.params[0].start, "Setter cannot use rest params");
+				}, p.parseProperty = function(e$2, s$1) {
+					if (!e$2) {
+						var i = [];
+						if (this.match(B.at)) for (; this.match(B.at);) i.push(this.parseDecorator());
+						var r$1 = t.prototype.parseProperty.call(this, e$2, s$1);
+						return "SpreadElement" === r$1.type && i.length && this.raise(r$1.start, "Decorators can't be used with SpreadElement"), i.length && (r$1.decorators = i, i = []), r$1;
+					}
+					return t.prototype.parseProperty.call(this, e$2, s$1);
+				}, p.parseCatchClauseParam = function() {
+					var t$1 = this.parseBindingAtom(), e$2 = "Identifier" === t$1.type;
+					this.enterScope(e$2 ? 32 : 0), this.checkLValPattern(t$1, e$2 ? 4 : 2);
+					var s$1 = this.tsTryParseTypeAnnotation();
+					return s$1 && (t$1.typeAnnotation = s$1, this.resetEndLocation(t$1)), this.expect(M.parenR), t$1;
+				}, p.parseClass = function(t$1, e$2) {
+					var s$1 = this.inAbstractClass;
+					this.inAbstractClass = !!t$1.abstract;
+					try {
+						this.next(), this.takeDecorators(t$1);
+						var i = this.strict;
+						this.strict = !0, this.parseClassId(t$1, e$2), this.parseClassSuper(t$1);
+						var r$1 = this.enterClassBody(), a = this.startNode(), n$3 = !1;
+						a.body = [];
+						var o$2 = [];
+						for (this.expect(M.braceL); this.type !== M.braceR;) if (this.match(B.at)) o$2.push(this.parseDecorator());
+						else {
+							var h = this.parseClassElement(null !== t$1.superClass);
+							o$2.length && (h.decorators = o$2, this.resetStartLocationFromNode(h, o$2[0]), o$2 = []), h && (a.body.push(h), "MethodDefinition" === h.type && "constructor" === h.kind && "FunctionExpression" === h.value.type ? (n$3 && this.raiseRecoverable(h.start, "Duplicate constructor in the same class"), n$3 = !0, h.decorators && h.decorators.length > 0 && this.raise(h.start, "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?")) : h.key && "PrivateIdentifier" === h.key.type && f(r$1, h) && this.raiseRecoverable(h.key.start, "Identifier '#" + h.key.name + "' has already been declared"));
+						}
+						return this.strict = i, this.next(), o$2.length && this.raise(this.start, "Decorators must be attached to a class element."), t$1.body = this.finishNode(a, "ClassBody"), this.exitClassBody(), this.finishNode(t$1, e$2 ? "ClassDeclaration" : "ClassExpression");
+					} finally {
+						this.inAbstractClass = s$1;
+					}
+				}, p.parseClassFunctionParams = function() {
+					var t$1 = this.tsTryParseTypeParameters(this.tsParseConstModifier), e$2 = this.parseBindingList(M.parenR, !1, this.options.ecmaVersion >= 8, !0);
+					return t$1 && (e$2.typeParameters = t$1), e$2;
+				}, p.parseMethod = function(t$1, e$2, s$1, i, r$1) {
+					var a = this.startNode(), n$3 = this.yieldPos, o$2 = this.awaitPos, h = this.awaitIdentPos;
+					if (this.initFunction(a), this.options.ecmaVersion >= 6 && (a.generator = t$1), this.options.ecmaVersion >= 8 && (a.async = !!e$2), this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.enterScope(64 | E(e$2, a.generator) | (s$1 ? 128 : 0)), this.expect(M.parenL), a.params = this.parseClassFunctionParams(), this.checkYieldAwaitInDefaultParams(), this.parseFunctionBody(a, !1, !0, !1, { isClassMethod: i }), this.yieldPos = n$3, this.awaitPos = o$2, this.awaitIdentPos = h, r$1 && r$1.abstract && a.body) {
+						var p$1 = r$1.key;
+						this.raise(r$1.start, T.AbstractMethodHasImplementation({ methodName: "Identifier" !== p$1.type || r$1.computed ? "[" + this.input.slice(p$1.start, p$1.end) + "]" : p$1.name }));
+					}
+					return this.finishNode(a, "FunctionExpression");
+				}, e$1.parse = function(t$1, e$2) {
+					if (!1 === e$2.locations) throw new Error("You have to enable options.locations while using acorn-typescript");
+					e$2.locations = !0;
+					var s$1 = new this(e$2, t$1);
+					return d && (s$1.isAmbientContext = !0), s$1.parse();
+				}, e$1.parseExpressionAt = function(t$1, e$2, s$1) {
+					if (!1 === s$1.locations) throw new Error("You have to enable options.locations while using acorn-typescript");
+					s$1.locations = !0;
+					var i = new this(s$1, t$1, e$2);
+					return d && (i.isAmbientContext = !0), i.nextToken(), i.parseExpression();
+				}, p.parseImportSpecifier = function() {
+					if (this.ts_isContextual(B.type)) {
+						var e$2 = this.startNode();
+						return e$2.imported = this.parseModuleExportName(), this.parseTypeOnlyImportExportSpecifier(e$2, !0, "type" === this.importOrExportOuterKind), this.finishNode(e$2, "ImportSpecifier");
+					}
+					var s$1 = t.prototype.parseImportSpecifier.call(this);
+					return s$1.importKind = "value", s$1;
+				}, p.parseExportSpecifier = function(e$2) {
+					var s$1 = this.ts_isContextual(B.type);
+					if (!this.match(M.string) && s$1) {
+						var i = this.startNode();
+						return i.local = this.parseModuleExportName(), this.parseTypeOnlyImportExportSpecifier(i, !1, "type" === this.importOrExportOuterKind), this.finishNode(i, "ExportSpecifier"), this.checkExport(e$2, i.exported, i.exported.start), i;
+					}
+					var r$1 = t.prototype.parseExportSpecifier.call(this, e$2);
+					return r$1.exportKind = "value", r$1;
+				}, p.parseTypeOnlyImportExportSpecifier = function(e$2, s$1, i) {
+					var r$1, a = s$1 ? "imported" : "local", n$3 = s$1 ? "local" : "exported", o$2 = e$2[a], h = !1, p$1 = !0, c = o$2.start;
+					if (this.isContextual("as")) {
+						var l = this.parseIdent();
+						if (this.isContextual("as")) {
+							var u = this.parseIdent();
+							J(this.type) ? (h = !0, o$2 = l, r$1 = s$1 ? this.parseIdent() : this.parseModuleExportName(), p$1 = !1) : (r$1 = u, p$1 = !1);
+						} else J(this.type) ? (p$1 = !1, r$1 = s$1 ? this.parseIdent() : this.parseModuleExportName()) : (h = !0, o$2 = l);
+					} else J(this.type) && (h = !0, s$1 ? (o$2 = t.prototype.parseIdent.call(this, !0), this.isContextual("as") || this.checkUnreserved(o$2)) : o$2 = this.parseModuleExportName());
+					h && i && this.raise(c, s$1 ? T.TypeModifierIsUsedInTypeImports : T.TypeModifierIsUsedInTypeExports), e$2[a] = o$2, e$2[n$3] = r$1, e$2[s$1 ? "importKind" : "exportKind"] = h ? "type" : "value", p$1 && this.eatContextual("as") && (e$2[n$3] = s$1 ? this.parseIdent() : this.parseModuleExportName()), e$2[n$3] || (e$2[n$3] = this.copyNode(e$2[a])), s$1 && this.checkLValSimple(e$2[n$3], 2);
+				}, p.raiseCommonCheck = function(e$2, s$1, i) {
+					return "Comma is not permitted after the rest element" === s$1 ? this.isAmbientContext && this.match(M.comma) && 41 === this.lookaheadCharCode() ? void this.next() : t.prototype.raise.call(this, e$2, s$1) : i ? t.prototype.raiseRecoverable.call(this, e$2, s$1) : t.prototype.raise.call(this, e$2, s$1);
+				}, p.raiseRecoverable = function(t$1, e$2) {
+					return this.raiseCommonCheck(t$1, e$2, !0);
+				}, p.raise = function(t$1, e$2) {
+					return this.raiseCommonCheck(t$1, e$2, !0);
+				}, p.updateContext = function(e$2) {
+					var s$1 = this.type;
+					if (s$1 == M.braceL) {
+						var i = this.curContext();
+						i == H.tc_oTag ? this.context.push(j.b_expr) : i == H.tc_expr ? this.context.push(j.b_tmpl) : t.prototype.updateContext.call(this, e$2), this.exprAllowed = !0;
+					} else {
+						if (s$1 !== M.slash || e$2 !== B.jsxTagStart) return t.prototype.updateContext.call(this, e$2);
+						this.context.length -= 2, this.context.push(H.tc_cTag), this.exprAllowed = !1;
+					}
+				}, p.jsx_parseOpeningElementAt = function(t$1, e$2) {
+					var s$1 = this, i = this.startNodeAt(t$1, e$2), r$1 = this.jsx_parseElementName();
+					if (r$1 && (i.name = r$1), this.match(M.relational) || this.match(M.bitShift)) {
+						var a = this.tsTryParseAndCatch(function() {
+							return s$1.tsParseTypeArgumentsInExpression();
+						});
+						a && (i.typeParameters = a);
+					}
+					for (i.attributes = []; this.type !== M.slash && this.type !== B.jsxTagEnd;) i.attributes.push(this.jsx_parseAttribute());
+					return i.selfClosing = this.eat(M.slash), this.expect(B.jsxTagEnd), this.finishNode(i, r$1 ? "JSXOpeningElement" : "JSXOpeningFragment");
+				}, p.enterScope = function(e$2) {
+					e$2 === u && this.importsStack.push([]), t.prototype.enterScope.call(this, e$2);
+					var s$1 = t.prototype.currentScope.call(this);
+					s$1.types = [], s$1.enums = [], s$1.constEnums = [], s$1.classes = [], s$1.exportOnlyBindings = [];
+				}, p.exitScope = function() {
+					t.prototype.currentScope.call(this).flags === u && this.importsStack.pop(), t.prototype.exitScope.call(this);
+				}, p.hasImport = function(t$1, e$2) {
+					var s$1 = this.importsStack.length;
+					if (this.importsStack[s$1 - 1].indexOf(t$1) > -1) return !0;
+					if (!e$2 && s$1 > 1) {
+						for (var i = 0; i < s$1 - 1; i++) if (this.importsStack[i].indexOf(t$1) > -1) return !0;
+					}
+					return !1;
+				}, p.maybeExportDefined = function(t$1, e$2) {
+					this.inModule && 1 & t$1.flags && this.undefinedExports.delete(e$2);
+				}, p.isRedeclaredInScope = function(e$2, s$1, i) {
+					return !!(0 & i) && (2 & i ? e$2.lexical.indexOf(s$1) > -1 || e$2.functions.indexOf(s$1) > -1 || e$2.var.indexOf(s$1) > -1 : 3 & i ? e$2.lexical.indexOf(s$1) > -1 || !t.prototype.treatFunctionsAsVarInScope.call(this, e$2) && e$2.var.indexOf(s$1) > -1 : e$2.lexical.indexOf(s$1) > -1 && !(32 & e$2.flags && e$2.lexical[0] === s$1) || !this.treatFunctionsAsVarInScope(e$2) && e$2.functions.indexOf(s$1) > -1);
+				}, p.checkRedeclarationInScope = function(t$1, e$2, s$1, i) {
+					this.isRedeclaredInScope(t$1, e$2, s$1) && this.raise(i, "Identifier '" + e$2 + "' has already been declared.");
+				}, p.declareName = function(e$2, s$1, i) {
+					if (4096 & s$1) return this.hasImport(e$2, !0) && this.raise(i, "Identifier '" + e$2 + "' has already been declared."), void this.importsStack[this.importsStack.length - 1].push(e$2);
+					var r$1 = this.currentScope();
+					if (1024 & s$1) return this.maybeExportDefined(r$1, e$2), void r$1.exportOnlyBindings.push(e$2);
+					t.prototype.declareName.call(this, e$2, s$1, i), 0 & s$1 && (0 & s$1 || (this.checkRedeclarationInScope(r$1, e$2, s$1, i), this.maybeExportDefined(r$1, e$2)), r$1.types.push(e$2)), 256 & s$1 && r$1.enums.push(e$2), 512 & s$1 && r$1.constEnums.push(e$2), 128 & s$1 && r$1.classes.push(e$2);
+				}, p.checkLocalExport = function(e$2) {
+					var s$1 = e$2.name;
+					if (!this.hasImport(s$1)) {
+						for (var i = this.scopeStack.length - 1; i >= 0; i--) {
+							var r$1 = this.scopeStack[i];
+							if (r$1.types.indexOf(s$1) > -1 || r$1.exportOnlyBindings.indexOf(s$1) > -1) return;
+						}
+						t.prototype.checkLocalExport.call(this, e$2);
+					}
+				}, s = e$1, n$2 = [{
+					key: "acornTypeScript",
+					get: function() {
+						return N$1;
+					}
+				}], (r = [{
+					key: "acornTypeScript",
+					get: function() {
+						return N$1;
+					}
+				}]) && i(s.prototype, r), n$2 && i(s, n$2), Object.defineProperty(s, "prototype", { writable: !1 }), e$1;
+			}(n$1);
+		};
+	}
+	exports.default = L, exports.tsPlugin = L;
+}));
+
+//#endregion
+export default require_lib();
+
+export { require_lib };
+//# sourceMappingURL=index.js.map