@builder.io/fusion 0.0.1

package/acorn-CvZ7-_4Z.js

@@ -0,0 +1,4565 @@
+import { n as e } from "./chunk-hvVJRdgc.js";
+//#region ../../node_modules/prettier/plugins/acorn.mjs
+function t(e, t) {
+	for (var n = 65536, r = 0; r < t.length; r += 2) {
+		if (n += t[r], n > e) return !1;
+		if (n += t[r + 1], n >= e) return !0;
+	}
+	return !1;
+}
+function n(e, n) {
+	return e < 65 ? e === 36 : e < 91 ? !0 : e < 97 ? e === 95 : e < 123 ? !0 : e <= 65535 ? e >= 170 && Tt.test(String.fromCharCode(e)) : n === !1 ? !1 : t(e, vt);
+}
+function r(e, n) {
+	return e < 48 ? e === 36 : e < 58 ? !0 : e < 65 ? !1 : e < 91 ? !0 : e < 97 ? e === 95 : e < 123 ? !0 : e <= 65535 ? e >= 170 && Et.test(String.fromCharCode(e)) : n === !1 ? !1 : t(e, vt) || t(e, _t);
+}
+function i(e, t) {
+	return new b(e, {
+		beforeExpr: !0,
+		binop: t
+	});
+}
+function a(e, t) {
+	return t === void 0 && (t = {}), t.keyword = e, Dt[e] = new b(e, t);
+}
+function o(e) {
+	return e === 10 || e === 13 || e === 8232 || e === 8233;
+}
+function s(e, t, n) {
+	n === void 0 && (n = e.length);
+	for (var r = t; r < n; r++) {
+		var i = e.charCodeAt(r);
+		if (o(i)) return r < n - 1 && i === 13 && e.charCodeAt(r + 1) === 10 ? r + 2 : r + 1;
+	}
+	return -1;
+}
+function c(e) {
+	return Pt[e] || (Pt[e] = RegExp("^(?:" + e.replace(/ /g, "|") + ")$"));
+}
+function l(e) {
+	return e <= 65535 ? String.fromCharCode(e) : (e -= 65536, String.fromCharCode((e >> 10) + 55296, (e & 1023) + 56320));
+}
+function u(e, t) {
+	for (var n = 1, r = 0;;) {
+		var i = s(e, r, t);
+		if (i < 0) return new D(n, t - r);
+		++n, r = i;
+	}
+}
+function d(e) {
+	var t = {};
+	for (var n in Lt) t[n] = e && E(e, n) ? e[n] : Lt[n];
+	if (t.ecmaVersion === "latest" ? t.ecmaVersion = 1e8 : t.ecmaVersion == null ? (!Rt && typeof console == "object" && console.warn && (Rt = !0, console.warn("Since Acorn 8.0.0, options.ecmaVersion is required.\nDefaulting to 2020, but this will stop working in the future.")), t.ecmaVersion = 11) : t.ecmaVersion >= 2015 && (t.ecmaVersion -= 2009), t.allowReserved ??= t.ecmaVersion < 5, (!e || e.allowHashBang == null) && (t.allowHashBang = t.ecmaVersion >= 14), Nt(t.onToken)) {
+		var r = t.onToken;
+		t.onToken = function(e) {
+			return r.push(e);
+		};
+	}
+	return Nt(t.onComment) && (t.onComment = f(t, t.onComment)), t;
+}
+function f(e, t) {
+	return function(n, r, i, a, o, s) {
+		var c = {
+			type: n ? "Block" : "Line",
+			value: r,
+			start: i,
+			end: a
+		};
+		e.locations && (c.loc = new It(this, o, s)), e.ranges && (c.range = [i, a]), t.push(c);
+	};
+}
+function p(e, t) {
+	return k | (e ? zt : 0) | (t ? Bt : 0);
+}
+function m(e, t) {
+	var n = t.key.name, r = e[n], i = "true";
+	return t.type === "MethodDefinition" && (t.kind === "get" || t.kind === "set") && (i = (t.static ? "s" : "i") + t.kind), r === "iget" && i === "iset" || r === "iset" && i === "iget" || r === "sget" && i === "sset" || r === "sset" && i === "sget" ? (e[n] = "true", !1) : r ? !0 : (e[n] = i, !1);
+}
+function h(e, t) {
+	var n = e.computed, r = e.key;
+	return !n && (r.type === "Identifier" && r.name === t || r.type === "Literal" && r.value === t);
+}
+function g(e) {
+	return e.type === "Identifier" || e.type === "ParenthesizedExpression" && g(e.expression);
+}
+function _(e) {
+	return e.type === "MemberExpression" && e.property.type === "PrivateIdentifier" || e.type === "ChainExpression" && _(e.expression) || e.type === "ParenthesizedExpression" && _(e.expression);
+}
+function ee(e, t, n, r) {
+	return e.type = t, e.end = n, this.options.locations && (e.loc.end = r), this.options.ranges && (e.range[1] = n), e;
+}
+function te(e) {
+	var t = Dn[e] = {
+		binary: c(gn[e] + " " + yn),
+		binaryOfStrings: c(vn[e]),
+		nonBinary: {
+			General_Category: c(yn),
+			Script: c(En[e])
+		}
+	};
+	t.nonBinary.Script_Extensions = t.nonBinary.Script, t.nonBinary.gc = t.nonBinary.General_Category, t.nonBinary.sc = t.nonBinary.Script, t.nonBinary.scx = t.nonBinary.Script_Extensions;
+}
+function ne(e) {
+	for (var t in e) return !0;
+	return !1;
+}
+function re(e) {
+	return e === 105 || e === 109 || e === 115;
+}
+function ie(e) {
+	return e === 36 || e >= 40 && e <= 43 || e === 46 || e === 63 || e >= 91 && e <= 94 || e >= 123 && e <= 125;
+}
+function ae(e) {
+	return n(e, !0) || e === 36 || e === 95;
+}
+function oe(e) {
+	return r(e, !0) || e === 36 || e === 95 || e === 8204 || e === 8205;
+}
+function se(e) {
+	return e >= 65 && e <= 90 || e >= 97 && e <= 122;
+}
+function ce(e) {
+	return e >= 0 && e <= 1114111;
+}
+function le(e) {
+	return e === 100 || e === 68 || e === 115 || e === 83 || e === 119 || e === 87;
+}
+function ue(e) {
+	return se(e) || e === 95;
+}
+function de(e) {
+	return ue(e) || he(e);
+}
+function fe(e) {
+	return e === 33 || e >= 35 && e <= 38 || e >= 42 && e <= 44 || e === 46 || e >= 58 && e <= 64 || e === 94 || e === 96 || e === 126;
+}
+function pe(e) {
+	return e === 40 || e === 41 || e === 45 || e === 47 || e >= 91 && e <= 93 || e >= 123 && e <= 125;
+}
+function me(e) {
+	return e === 33 || e === 35 || e === 37 || e === 38 || e === 44 || e === 45 || e >= 58 && e <= 62 || e === 64 || e === 96 || e === 126;
+}
+function he(e) {
+	return e >= 48 && e <= 57;
+}
+function ge(e) {
+	return e >= 48 && e <= 57 || e >= 65 && e <= 70 || e >= 97 && e <= 102;
+}
+function _e(e) {
+	return e >= 65 && e <= 70 ? 10 + (e - 65) : e >= 97 && e <= 102 ? 10 + (e - 97) : e - 48;
+}
+function ve(e) {
+	return e >= 48 && e <= 55;
+}
+function ye(e, t) {
+	return t ? parseInt(e, 8) : parseFloat(e.replace(/_/g, ""));
+}
+function be(e) {
+	return typeof BigInt == "function" ? BigInt(e.replace(/_/g, "")) : null;
+}
+function xe(e, t) {
+	let n = /* @__PURE__ */ SyntaxError(e + " (" + t.loc.start.line + ":" + t.loc.start.column + ")");
+	return Object.assign(n, t);
+}
+function Se(e) {
+	let t = [];
+	for (let n of e) try {
+		return n();
+	} catch (e) {
+		t.push(e);
+	}
+	throw Object.assign(/* @__PURE__ */ Error("All combinations failed"), { errors: t });
+}
+function Ce(e) {
+	return this[e < 0 ? this.length + e : e];
+}
+function v(e) {
+	let t = e.range?.[0] ?? e.start, n = (e.declaration?.decorators ?? e.decorators)?.[0];
+	return n ? Math.min(v(n), t) : t;
+}
+function y(e) {
+	return e.range?.[1] ?? e.end;
+}
+function we(e) {
+	let t = new Set(e);
+	return (e) => t.has(e?.type);
+}
+function Te(e) {
+	return Wn.has(e) || Wn.set(e, Hn(e) && e.value[0] === "*" && /@(?:type|satisfies)\b/u.test(e.value)), Wn.get(e);
+}
+function Ee(e) {
+	if (!Hn(e)) return !1;
+	let t = `*${e.value}*`.split("\n");
+	return t.length > 1 && t.every((e) => e.trimStart()[0] === "*");
+}
+function De(e) {
+	return Kn.has(e) || Kn.set(e, Ee(e)), Kn.get(e);
+}
+function Oe(e) {
+	if (e.length < 2) return;
+	let t;
+	for (let n = e.length - 1; n >= 0; n--) {
+		let r = e[n];
+		if (t && y(r) === v(t) && qn(r) && qn(t) && (e.splice(n + 1, 1), r.value += "*//*" + t.value, r.range = [v(r), y(t)]), !Un(r) && !Hn(r)) throw TypeError(`Unknown comment type: "${r.type}".`);
+		t = r;
+	}
+}
+function ke(e) {
+	return typeof e == "object" && !!e;
+}
+function Ae(e) {
+	if (X !== null && typeof X.property) {
+		let e = X;
+		return X = Ae.prototype = null, e;
+	}
+	return X = Ae.prototype = e ?? Object.create(null), new Ae();
+}
+function je(e) {
+	return Ae(e);
+}
+function Me(e, t = "type") {
+	je(e);
+	function n(n) {
+		let r = n[t], i = e[r];
+		if (!Array.isArray(i)) throw Object.assign(/* @__PURE__ */ Error(`Missing visitor keys for '${r}'.`), { node: n });
+		return i;
+	}
+	return n;
+}
+function Ne(e, t) {
+	if (!Yn(e)) return e;
+	if (Array.isArray(e)) {
+		for (let n = 0; n < e.length; n++) e[n] = Ne(e[n], t);
+		return e;
+	}
+	if (t.onEnter) {
+		let n = t.onEnter(e) ?? e;
+		if (n !== e) return Ne(n, t);
+		e = n;
+	}
+	let n = Qn(e);
+	for (let r = 0; r < n.length; r++) e[n[r]] = Ne(e[n[r]], t);
+	return t.onLeave && (e = t.onLeave(e) || e), e;
+}
+function Pe(e, t) {
+	let { parser: n, text: r } = t, { comments: i } = e, a = n === "oxc" && t.oxcAstType === "ts";
+	Jn(i);
+	let o = e.type === "File" ? e.program : e;
+	o.interpreter && (i.unshift(o.interpreter), delete o.interpreter), a && e.hashbang && (i.unshift(e.hashbang), delete e.hashbang), e.type === "Program" && (e.range = [0, r.length]);
+	let s;
+	return e = $n(e, {
+		onEnter(t) {
+			switch (t.type) {
+				case "ParenthesizedExpression": {
+					let { expression: e } = t, n = v(t);
+					if (e.type === "TypeCastExpression") return e.range = [n, y(t)], e;
+					let o = !1;
+					if (!a) {
+						if (!s) {
+							s = [];
+							for (let e of i) Gn(e) && s.push(y(e));
+						}
+						let e = zn(0, s, (e) => e <= n);
+						o = e && r.slice(e, n).trim().length === 0;
+					}
+					return o ? void 0 : (e.extra = {
+						...e.extra,
+						parenthesized: !0
+					}, e);
+				}
+				case "TemplateLiteral":
+					if (t.expressions.length !== t.quasis.length - 1) throw Error("Malformed template literal.");
+					break;
+				case "TemplateElement":
+					(n === "flow" || n === "hermes" || n === "espree" || n === "typescript" || a) && (t.range = [v(t) + 1, y(t) - (t.tail ? 1 : 2)]);
+					break;
+				case "VariableDeclaration": {
+					let e = Bn(0, t.declarations, -1);
+					e?.init && r[y(e)] !== ";" && (t.range = [v(t), y(e)]);
+					break;
+				}
+				case "TSParenthesizedType": return t.typeAnnotation;
+				case "TopicReference":
+					e.extra = {
+						...e.extra,
+						__isUsingHackPipeline: !0
+					};
+					break;
+				case "TSUnionType":
+				case "TSIntersectionType":
+					if (t.types.length === 1) return t.types[0];
+					break;
+				case "ImportExpression":
+					n === "hermes" && t.attributes && !t.options && (t.options = t.attributes);
+					break;
+			}
+		},
+		onLeave(e) {
+			switch (e.type) {
+				case "LogicalExpression":
+					if (Fe(e)) return Ie(e);
+					break;
+				case "TSImportType":
+					!e.source && e.argument.type === "TSLiteralType" && (e.source = e.argument.literal, delete e.argument);
+					break;
+			}
+		}
+	}), e;
+}
+function Fe(e) {
+	return e.type === "LogicalExpression" && e.right.type === "LogicalExpression" && e.operator === e.right.operator;
+}
+function Ie(e) {
+	return Fe(e) ? Ie({
+		type: "LogicalExpression",
+		operator: e.operator,
+		left: Ie({
+			type: "LogicalExpression",
+			operator: e.operator,
+			left: e.left,
+			right: e.right.left,
+			range: [v(e.left), y(e.right.left)]
+		}),
+		right: e.right.right,
+		range: [v(e), y(e)]
+	}) : e;
+}
+function Le(e) {
+	let t = e.match(ar);
+	return t ? t[0].trimStart() : "";
+}
+function Re(e) {
+	e = nr(0, e.replace(ir, "").replace(rr, ""), ur, "$1");
+	let t = "";
+	for (; t !== e;) t = e, e = nr(0, e, cr, "\n$1 $2\n");
+	e = e.replace(sr, "").trimEnd();
+	let n = Object.create(null), r = nr(0, e, lr, "").replace(sr, "").trimEnd(), i;
+	for (; i = lr.exec(e);) {
+		let e = nr(0, i[2], or, "");
+		if (typeof n[i[1]] == "string" || Array.isArray(n[i[1]])) {
+			let t = n[i[1]];
+			n[i[1]] = [
+				...dr,
+				...Array.isArray(t) ? t : [t],
+				e
+			];
+		} else n[i[1]] = e;
+	}
+	return {
+		comments: r,
+		pragmas: n
+	};
+}
+function ze(e) {
+	if (!e.startsWith("#!")) return "";
+	let t = e.indexOf("\n");
+	return t === -1 ? e : e.slice(0, t);
+}
+function Be(e) {
+	let t = mr(e);
+	t && (e = e.slice(t.length + 1));
+	let { pragmas: n, comments: r } = Re(Le(e));
+	return {
+		shebang: t,
+		text: e,
+		pragmas: n,
+		comments: r
+	};
+}
+function Ve(e) {
+	let { pragmas: t } = Be(e);
+	return pr.some((e) => Object.prototype.hasOwnProperty.call(t, e));
+}
+function He(e) {
+	let { pragmas: t } = Be(e);
+	return fr.some((e) => Object.prototype.hasOwnProperty.call(t, e));
+}
+function Ue(e) {
+	return e = typeof e == "function" ? { parse: e } : e, {
+		astFormat: "estree",
+		hasPragma: Ve,
+		hasIgnorePragma: He,
+		locStart: v,
+		locEnd: y,
+		...e
+	};
+}
+function We(e) {
+	if (typeof e == "string") {
+		if (e = e.toLowerCase(), /\.(?:mjs|mts)$/iu.test(e)) return gr;
+		if (/\.(?:cjs|cts)$/iu.test(e)) return vr;
+	}
+}
+function Ge(e) {
+	let { message: t, loc: n } = e;
+	if (!n) return e;
+	let { line: r, column: i } = n;
+	return In(t.replace(/ \(\d+:\d+\)$/u, ""), {
+		loc: { start: {
+			line: r,
+			column: i + 1
+		} },
+		cause: e
+	});
+}
+function Ke(e, t) {
+	let n = Sr(), r = [], i = n.parse(e, {
+		...br,
+		sourceType: t === vr ? _r : t,
+		allowImportExportEverywhere: t === gr,
+		onComment: r
+	});
+	return i.comments = r, i;
+}
+function qe(e, t) {
+	let n = We(t?.filepath), r = (n ? [n] : yr).map((t) => () => Ke(e, t)), i;
+	try {
+		i = Se(r);
+	} catch ({ errors: [e] }) {
+		throw Ge(e);
+	}
+	return er(i, { text: e });
+}
+function Je(e, t) {
+	let n = e[0], r = Bn(0, e, -1), i = {
+		type: Q.Template,
+		value: t.slice(n.start, r.end)
+	};
+	return n.loc && (i.loc = {
+		start: n.loc.start,
+		end: r.loc.end
+	}), n.range && (i.start = n.range[0], i.end = r.range[1], i.range = [i.start, i.end]), i;
+}
+function Ye(e, t) {
+	this._acornTokTypes = e, this._tokens = [], this._curlyBrace = null, this._code = t;
+}
+function Xe() {
+	return Bn(0, Er, -1);
+}
+function Ze(e = 5) {
+	let t = e === "latest" ? Xe() : e;
+	if (typeof t != "number") throw Error(`ecmaVersion must be a number or "latest". Received value of type ${typeof e} instead.`);
+	if (t >= 2015 && (t -= 2009), !Er.includes(t)) throw Error("Invalid ecmaVersion.");
+	return t;
+}
+function Qe(e = "script") {
+	if (e === "script" || e === "module") return e;
+	if (e === "commonjs") return "script";
+	throw Error("Invalid sourceType.");
+}
+function $e(e) {
+	let t = Ze(e.ecmaVersion), n = Qe(e.sourceType), r = e.range === !0, i = e.loc === !0;
+	if (t !== 3 && e.allowReserved) throw Error("`allowReserved` is only supported when ecmaVersion is 3");
+	if (typeof e.allowReserved < "u" && typeof e.allowReserved != "boolean") throw Error("`allowReserved`, when present, must be `true` or `false`");
+	let a = t === 3 ? e.allowReserved || "never" : !1, o = e.ecmaFeatures || {}, s = e.sourceType === "commonjs" || !!o.globalReturn;
+	if (n === "module" && t < 6) throw Error("sourceType 'module' is not supported when ecmaVersion < 2015. Consider adding `{ ecmaVersion: 2015 }` to the parser options.");
+	return Object.assign({}, e, {
+		ecmaVersion: t,
+		sourceType: n,
+		ranges: r,
+		locations: i,
+		allowReserved: a,
+		allowReturnOutsideFunction: s
+	});
+}
+function et(e, t, n, r, i, a, o) {
+	let s;
+	s = e ? "Block" : o.slice(n, n + 2) === "#!" ? "Hashbang" : "Line";
+	let c = {
+		type: s,
+		value: t
+	};
+	return typeof n == "number" && (c.start = n, c.end = r, c.range = [n, r]), typeof i == "object" && (c.loc = {
+		start: i,
+		end: a
+	}), c;
+}
+function tt(e, t) {
+	return new (kr.get(t))(t, e).parse();
+}
+function nt(e) {
+	let { message: t, lineNumber: n, column: r } = e;
+	return typeof n == "number" ? In(t, {
+		loc: { start: {
+			line: n,
+			column: r
+		} },
+		cause: e
+	}) : e;
+}
+function rt(e, t) {
+	let n = We(t?.filepath), r = (n ? [n] : yr).map((t) => () => tt(e, {
+		...Ar,
+		sourceType: t
+	})), i;
+	try {
+		i = Se(r);
+	} catch ({ errors: [e] }) {
+		throw nt(e);
+	}
+	return er(i, {
+		parser: "espree",
+		text: e
+	});
+}
+var it, at, ot, st, ct, lt, ut, dt, ft, pt, mt, ht, gt, _t, vt, yt, bt, xt, St, Ct, wt, Tt, Et, b, x, S, Dt, C, w, Ot, kt, T, At, jt, Mt, E, Nt, Pt, Ft, D, It, Lt, Rt, O, k, zt, Bt, Vt, Ht, Ut, Wt, A, j, Gt, Kt, qt, M, Jt, Yt, Xt, N, P, F, Zt, Qt, I, $t, en, tn, L, nn, rn, R, z, B, V, H, an, on, U, sn, cn, W, ln, un, dn, fn, pn, mn, hn, gn, _n, vn, yn, bn, xn, Sn, Cn, wn, Tn, En, Dn, On, kn, An, G, jn, K, Mn, q, J, Nn, Y, Pn, Fn, In, Ln, Rn, zn, Bn, Vn, Hn, Un, Wn, Gn, Kn, qn, Jn, Yn, X, Xn, Zn, Z, Qn, $n, er, tr, nr, rr, ir, ar, or, sr, cr, lr, ur, dr, fr, pr, mr, hr, gr, _r, vr, yr, br, xr, Sr, Cr, wr, Q, Tr, Er, $, Dr, Or, kr, Ar, jr;
+//#endregion
+e((() => {
+	for (it = Object.create, at = Object.defineProperty, ot = Object.getOwnPropertyDescriptor, st = Object.getOwnPropertyNames, ct = Object.getPrototypeOf, lt = Object.prototype.hasOwnProperty, ut = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), dt = (e, t) => {
+		for (var n in t) at(e, n, {
+			get: t[n],
+			enumerable: !0
+		});
+	}, ft = (e, t, n, r) => {
+		if (t && typeof t == "object" || typeof t == "function") for (let i of st(t)) !lt.call(e, i) && i !== n && at(e, i, {
+			get: () => t[i],
+			enumerable: !(r = ot(t, i)) || r.enumerable
+		});
+		return e;
+	}, pt = (e, t, n) => (n = e == null ? {} : it(ct(e)), ft(t || !e || !e.__esModule ? at(n, "default", {
+		value: e,
+		enumerable: !0
+	}) : n, e)), mt = ut((e, t) => {
+		t.exports = {};
+	}), ht = ut((e, t) => {
+		var n = mt(), r = /^[\da-fA-F]+$/, i = /^\d+$/, a = /* @__PURE__ */ new WeakMap();
+		function o(e) {
+			e = e.Parser.acorn || e;
+			let t = a.get(e);
+			if (!t) {
+				let n = e.tokTypes, r = e.TokContext, i = e.TokenType, o = new r("<tag", !1), s = new r("</tag", !1), c = new r("<tag>...</tag>", !0, !0), l = {
+					tc_oTag: o,
+					tc_cTag: s,
+					tc_expr: c
+				}, u = {
+					jsxName: new i("jsxName"),
+					jsxText: new i("jsxText", { beforeExpr: !0 }),
+					jsxTagStart: new i("jsxTagStart", { startsExpr: !0 }),
+					jsxTagEnd: new i("jsxTagEnd")
+				};
+				u.jsxTagStart.updateContext = function() {
+					this.context.push(c), this.context.push(o), this.exprAllowed = !1;
+				}, u.jsxTagEnd.updateContext = function(e) {
+					let t = this.context.pop();
+					t === o && e === n.slash || t === s ? (this.context.pop(), this.exprAllowed = this.curContext() === c) : this.exprAllowed = !0;
+				}, t = {
+					tokContexts: l,
+					tokTypes: u
+				}, a.set(e, t);
+			}
+			return t;
+		}
+		function s(e) {
+			if (!e) return e;
+			if (e.type === "JSXIdentifier") return e.name;
+			if (e.type === "JSXNamespacedName") return e.namespace.name + ":" + e.name.name;
+			if (e.type === "JSXMemberExpression") return s(e.object) + "." + s(e.property);
+		}
+		t.exports = function(e) {
+			return e ||= {}, function(t) {
+				return c({
+					allowNamespaces: e.allowNamespaces !== !1,
+					allowNamespacedObjects: !!e.allowNamespacedObjects
+				}, t);
+			};
+		}, Object.defineProperty(t.exports, "tokTypes", {
+			get: function() {
+				return o(void 0).tokTypes;
+			},
+			configurable: !0,
+			enumerable: !0
+		});
+		function c(e, t) {
+			let a = t.acorn || void 0, c = o(a), l = a.tokTypes, u = c.tokTypes, d = a.tokContexts, f = c.tokContexts.tc_oTag, p = c.tokContexts.tc_cTag, m = c.tokContexts.tc_expr, h = a.isNewLine, g = a.isIdentifierStart, _ = a.isIdentifierChar;
+			return class extends t {
+				static get acornJsx() {
+					return c;
+				}
+				jsx_readToken() {
+					let e = "", t = this.pos;
+					for (;;) {
+						this.pos >= this.input.length && this.raise(this.start, "Unterminated JSX contents");
+						let n = this.input.charCodeAt(this.pos);
+						switch (n) {
+							case 60:
+							case 123: return this.pos === this.start ? n === 60 && this.exprAllowed ? (++this.pos, this.finishToken(u.jsxTagStart)) : this.getTokenFromCode(n) : (e += this.input.slice(t, this.pos), this.finishToken(u.jsxText, e));
+							case 38:
+								e += this.input.slice(t, this.pos), e += this.jsx_readEntity(), t = this.pos;
+								break;
+							case 62:
+							case 125: this.raise(this.pos, "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" + (n === 62 ? "&gt;" : "&rbrace;") + "` or `{\"" + this.input[this.pos] + "\"}`?");
+							default: h(n) ? (e += this.input.slice(t, this.pos), e += this.jsx_readNewLine(!0), t = this.pos) : ++this.pos;
+						}
+					}
+				}
+				jsx_readNewLine(e) {
+					let t = this.input.charCodeAt(this.pos), n;
+					return ++this.pos, t === 13 && this.input.charCodeAt(this.pos) === 10 ? (++this.pos, n = e ? "\n" : "\r\n") : n = String.fromCharCode(t), this.options.locations && (++this.curLine, this.lineStart = this.pos), n;
+				}
+				jsx_readString(e) {
+					let t = "", n = ++this.pos;
+					for (;;) {
+						this.pos >= this.input.length && this.raise(this.start, "Unterminated string constant");
+						let r = this.input.charCodeAt(this.pos);
+						if (r === e) break;
+						r === 38 ? (t += this.input.slice(n, this.pos), t += this.jsx_readEntity(), n = this.pos) : h(r) ? (t += this.input.slice(n, this.pos), t += this.jsx_readNewLine(!1), n = this.pos) : ++this.pos;
+					}
+					return t += this.input.slice(n, this.pos++), this.finishToken(l.string, t);
+				}
+				jsx_readEntity() {
+					let e = "", t = 0, a, o = this.input[this.pos];
+					o !== "&" && this.raise(this.pos, "Entity must start with an ampersand");
+					let s = ++this.pos;
+					for (; this.pos < this.input.length && t++ < 10;) {
+						if (o = this.input[this.pos++], o === ";") {
+							e[0] === "#" ? e[1] === "x" ? (e = e.substr(2), r.test(e) && (a = String.fromCharCode(parseInt(e, 16)))) : (e = e.substr(1), i.test(e) && (a = String.fromCharCode(parseInt(e, 10)))) : a = n[e];
+							break;
+						}
+						e += o;
+					}
+					return a || (this.pos = s, "&");
+				}
+				jsx_readWord() {
+					let e, t = this.pos;
+					do
+						e = this.input.charCodeAt(++this.pos);
+					while (_(e) || e === 45);
+					return this.finishToken(u.jsxName, this.input.slice(t, this.pos));
+				}
+				jsx_parseIdentifier() {
+					let e = this.startNode();
+					return this.type === u.jsxName ? e.name = this.value : this.type.keyword ? e.name = this.type.keyword : this.unexpected(), this.next(), this.finishNode(e, "JSXIdentifier");
+				}
+				jsx_parseNamespacedName() {
+					let t = this.start, n = this.startLoc, r = this.jsx_parseIdentifier();
+					if (!e.allowNamespaces || !this.eat(l.colon)) return r;
+					var i = this.startNodeAt(t, n);
+					return i.namespace = r, i.name = this.jsx_parseIdentifier(), this.finishNode(i, "JSXNamespacedName");
+				}
+				jsx_parseElementName() {
+					if (this.type === u.jsxTagEnd) return "";
+					let t = this.start, n = this.startLoc, r = this.jsx_parseNamespacedName();
+					for (this.type === l.dot && r.type === "JSXNamespacedName" && !e.allowNamespacedObjects && this.unexpected(); this.eat(l.dot);) {
+						let e = this.startNodeAt(t, n);
+						e.object = r, e.property = this.jsx_parseIdentifier(), r = this.finishNode(e, "JSXMemberExpression");
+					}
+					return r;
+				}
+				jsx_parseAttributeValue() {
+					switch (this.type) {
+						case l.braceL:
+							let e = this.jsx_parseExpressionContainer();
+							return e.expression.type === "JSXEmptyExpression" && this.raise(e.start, "JSX attributes must only be assigned a non-empty expression"), e;
+						case u.jsxTagStart:
+						case l.string: return this.parseExprAtom();
+						default: this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
+					}
+				}
+				jsx_parseEmptyExpression() {
+					let e = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+					return this.finishNodeAt(e, "JSXEmptyExpression", this.start, this.startLoc);
+				}
+				jsx_parseExpressionContainer() {
+					let e = this.startNode();
+					return this.next(), e.expression = this.type === l.braceR ? this.jsx_parseEmptyExpression() : this.parseExpression(), this.expect(l.braceR), this.finishNode(e, "JSXExpressionContainer");
+				}
+				jsx_parseAttribute() {
+					let e = this.startNode();
+					return this.eat(l.braceL) ? (this.expect(l.ellipsis), e.argument = this.parseMaybeAssign(), this.expect(l.braceR), this.finishNode(e, "JSXSpreadAttribute")) : (e.name = this.jsx_parseNamespacedName(), e.value = this.eat(l.eq) ? this.jsx_parseAttributeValue() : null, this.finishNode(e, "JSXAttribute"));
+				}
+				jsx_parseOpeningElementAt(e, t) {
+					let n = this.startNodeAt(e, t);
+					n.attributes = [];
+					let r = this.jsx_parseElementName();
+					for (r && (n.name = r); this.type !== l.slash && this.type !== u.jsxTagEnd;) n.attributes.push(this.jsx_parseAttribute());
+					return n.selfClosing = this.eat(l.slash), this.expect(u.jsxTagEnd), this.finishNode(n, r ? "JSXOpeningElement" : "JSXOpeningFragment");
+				}
+				jsx_parseClosingElementAt(e, t) {
+					let n = this.startNodeAt(e, t), r = this.jsx_parseElementName();
+					return r && (n.name = r), this.expect(u.jsxTagEnd), this.finishNode(n, r ? "JSXClosingElement" : "JSXClosingFragment");
+				}
+				jsx_parseElementAt(e, t) {
+					let n = this.startNodeAt(e, t), r = [], i = this.jsx_parseOpeningElementAt(e, t), a = null;
+					if (!i.selfClosing) {
+						e: for (;;) switch (this.type) {
+							case u.jsxTagStart:
+								if (e = this.start, t = this.startLoc, this.next(), this.eat(l.slash)) {
+									a = this.jsx_parseClosingElementAt(e, t);
+									break e;
+								}
+								r.push(this.jsx_parseElementAt(e, t));
+								break;
+							case u.jsxText:
+								r.push(this.parseExprAtom());
+								break;
+							case l.braceL:
+								r.push(this.jsx_parseExpressionContainer());
+								break;
+							default: this.unexpected();
+						}
+						s(a.name) !== s(i.name) && this.raise(a.start, "Expected corresponding JSX closing tag for <" + s(i.name) + ">");
+					}
+					let o = i.name ? "Element" : "Fragment";
+					return n["opening" + o] = i, n["closing" + o] = a, n.children = r, this.type === l.relational && this.value === "<" && this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag"), this.finishNode(n, "JSX" + o);
+				}
+				jsx_parseText() {
+					let e = this.parseLiteral(this.value);
+					return e.type = "JSXText", e;
+				}
+				jsx_parseElement() {
+					let e = this.start, t = this.startLoc;
+					return this.next(), this.jsx_parseElementAt(e, t);
+				}
+				parseExprAtom(e) {
+					return this.type === u.jsxText ? this.jsx_parseText() : this.type === u.jsxTagStart ? this.jsx_parseElement() : super.parseExprAtom(e);
+				}
+				readToken(e) {
+					let t = this.curContext();
+					if (t === m) return this.jsx_readToken();
+					if (t === f || t === p) {
+						if (g(e)) return this.jsx_readWord();
+						if (e == 62) return ++this.pos, this.finishToken(u.jsxTagEnd);
+						if ((e === 34 || e === 39) && t == f) return this.jsx_readString(e);
+					}
+					return e === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33 ? (++this.pos, this.finishToken(u.jsxTagStart)) : super.readToken(e);
+				}
+				updateContext(e) {
+					if (this.type == l.braceL) {
+						var t = this.curContext();
+						t == f ? this.context.push(d.b_expr) : t == m ? this.context.push(d.b_tmpl) : super.updateContext(e), this.exprAllowed = !0;
+					} else if (this.type === l.slash && e === u.jsxTagStart) this.context.length -= 2, this.context.push(p), this.exprAllowed = !1;
+					else return super.updateContext(e);
+				}
+			};
+		}
+	}), gt = {}, dt(gt, { parsers: () => jr }), _t = [
+		509,
+		0,
+		227,
+		0,
+		150,
+		4,
+		294,
+		9,
+		1368,
+		2,
+		2,
+		1,
+		6,
+		3,
+		41,
+		2,
+		5,
+		0,
+		166,
+		1,
+		574,
+		3,
+		9,
+		9,
+		7,
+		9,
+		32,
+		4,
+		318,
+		1,
+		80,
+		3,
+		71,
+		10,
+		50,
+		3,
+		123,
+		2,
+		54,
+		14,
+		32,
+		10,
+		3,
+		1,
+		11,
+		3,
+		46,
+		10,
+		8,
+		0,
+		46,
+		9,
+		7,
+		2,
+		37,
+		13,
+		2,
+		9,
+		6,
+		1,
+		45,
+		0,
+		13,
+		2,
+		49,
+		13,
+		9,
+		3,
+		2,
+		11,
+		83,
+		11,
+		7,
+		0,
+		3,
+		0,
+		158,
+		11,
+		6,
+		9,
+		7,
+		3,
+		56,
+		1,
+		2,
+		6,
+		3,
+		1,
+		3,
+		2,
+		10,
+		0,
+		11,
+		1,
+		3,
+		6,
+		4,
+		4,
+		68,
+		8,
+		2,
+		0,
+		3,
+		0,
+		2,
+		3,
+		2,
+		4,
+		2,
+		0,
+		15,
+		1,
+		83,
+		17,
+		10,
+		9,
+		5,
+		0,
+		82,
+		19,
+		13,
+		9,
+		214,
+		6,
+		3,
+		8,
+		28,
+		1,
+		83,
+		16,
+		16,
+		9,
+		82,
+		12,
+		9,
+		9,
+		7,
+		19,
+		58,
+		14,
+		5,
+		9,
+		243,
+		14,
+		166,
+		9,
+		71,
+		5,
+		2,
+		1,
+		3,
+		3,
+		2,
+		0,
+		2,
+		1,
+		13,
+		9,
+		120,
+		6,
+		3,
+		6,
+		4,
+		0,
+		29,
+		9,
+		41,
+		6,
+		2,
+		3,
+		9,
+		0,
+		10,
+		10,
+		47,
+		15,
+		343,
+		9,
+		54,
+		7,
+		2,
+		7,
+		17,
+		9,
+		57,
+		21,
+		2,
+		13,
+		123,
+		5,
+		4,
+		0,
+		2,
+		1,
+		2,
+		6,
+		2,
+		0,
+		9,
+		9,
+		49,
+		4,
+		2,
+		1,
+		2,
+		4,
+		9,
+		9,
+		330,
+		3,
+		10,
+		1,
+		2,
+		0,
+		49,
+		6,
+		4,
+		4,
+		14,
+		10,
+		5350,
+		0,
+		7,
+		14,
+		11465,
+		27,
+		2343,
+		9,
+		87,
+		9,
+		39,
+		4,
+		60,
+		6,
+		26,
+		9,
+		535,
+		9,
+		470,
+		0,
+		2,
+		54,
+		8,
+		3,
+		82,
+		0,
+		12,
+		1,
+		19628,
+		1,
+		4178,
+		9,
+		519,
+		45,
+		3,
+		22,
+		543,
+		4,
+		4,
+		5,
+		9,
+		7,
+		3,
+		6,
+		31,
+		3,
+		149,
+		2,
+		1418,
+		49,
+		513,
+		54,
+		5,
+		49,
+		9,
+		0,
+		15,
+		0,
+		23,
+		4,
+		2,
+		14,
+		1361,
+		6,
+		2,
+		16,
+		3,
+		6,
+		2,
+		1,
+		2,
+		4,
+		101,
+		0,
+		161,
+		6,
+		10,
+		9,
+		357,
+		0,
+		62,
+		13,
+		499,
+		13,
+		245,
+		1,
+		2,
+		9,
+		726,
+		6,
+		110,
+		6,
+		6,
+		9,
+		4759,
+		9,
+		787719,
+		239
+	], vt = [
+		0,
+		11,
+		2,
+		25,
+		2,
+		18,
+		2,
+		1,
+		2,
+		14,
+		3,
+		13,
+		35,
+		122,
+		70,
+		52,
+		268,
+		28,
+		4,
+		48,
+		48,
+		31,
+		14,
+		29,
+		6,
+		37,
+		11,
+		29,
+		3,
+		35,
+		5,
+		7,
+		2,
+		4,
+		43,
+		157,
+		19,
+		35,
+		5,
+		35,
+		5,
+		39,
+		9,
+		51,
+		13,
+		10,
+		2,
+		14,
+		2,
+		6,
+		2,
+		1,
+		2,
+		10,
+		2,
+		14,
+		2,
+		6,
+		2,
+		1,
+		4,
+		51,
+		13,
+		310,
+		10,
+		21,
+		11,
+		7,
+		25,
+		5,
+		2,
+		41,
+		2,
+		8,
+		70,
+		5,
+		3,
+		0,
+		2,
+		43,
+		2,
+		1,
+		4,
+		0,
+		3,
+		22,
+		11,
+		22,
+		10,
+		30,
+		66,
+		18,
+		2,
+		1,
+		11,
+		21,
+		11,
+		25,
+		71,
+		55,
+		7,
+		1,
+		65,
+		0,
+		16,
+		3,
+		2,
+		2,
+		2,
+		28,
+		43,
+		28,
+		4,
+		28,
+		36,
+		7,
+		2,
+		27,
+		28,
+		53,
+		11,
+		21,
+		11,
+		18,
+		14,
+		17,
+		111,
+		72,
+		56,
+		50,
+		14,
+		50,
+		14,
+		35,
+		39,
+		27,
+		10,
+		22,
+		251,
+		41,
+		7,
+		1,
+		17,
+		2,
+		60,
+		28,
+		11,
+		0,
+		9,
+		21,
+		43,
+		17,
+		47,
+		20,
+		28,
+		22,
+		13,
+		52,
+		58,
+		1,
+		3,
+		0,
+		14,
+		44,
+		33,
+		24,
+		27,
+		35,
+		30,
+		0,
+		3,
+		0,
+		9,
+		34,
+		4,
+		0,
+		13,
+		47,
+		15,
+		3,
+		22,
+		0,
+		2,
+		0,
+		36,
+		17,
+		2,
+		24,
+		20,
+		1,
+		64,
+		6,
+		2,
+		0,
+		2,
+		3,
+		2,
+		14,
+		2,
+		9,
+		8,
+		46,
+		39,
+		7,
+		3,
+		1,
+		3,
+		21,
+		2,
+		6,
+		2,
+		1,
+		2,
+		4,
+		4,
+		0,
+		19,
+		0,
+		13,
+		4,
+		31,
+		9,
+		2,
+		0,
+		3,
+		0,
+		2,
+		37,
+		2,
+		0,
+		26,
+		0,
+		2,
+		0,
+		45,
+		52,
+		19,
+		3,
+		21,
+		2,
+		31,
+		47,
+		21,
+		1,
+		2,
+		0,
+		185,
+		46,
+		42,
+		3,
+		37,
+		47,
+		21,
+		0,
+		60,
+		42,
+		14,
+		0,
+		72,
+		26,
+		38,
+		6,
+		186,
+		43,
+		117,
+		63,
+		32,
+		7,
+		3,
+		0,
+		3,
+		7,
+		2,
+		1,
+		2,
+		23,
+		16,
+		0,
+		2,
+		0,
+		95,
+		7,
+		3,
+		38,
+		17,
+		0,
+		2,
+		0,
+		29,
+		0,
+		11,
+		39,
+		8,
+		0,
+		22,
+		0,
+		12,
+		45,
+		20,
+		0,
+		19,
+		72,
+		200,
+		32,
+		32,
+		8,
+		2,
+		36,
+		18,
+		0,
+		50,
+		29,
+		113,
+		6,
+		2,
+		1,
+		2,
+		37,
+		22,
+		0,
+		26,
+		5,
+		2,
+		1,
+		2,
+		31,
+		15,
+		0,
+		328,
+		18,
+		16,
+		0,
+		2,
+		12,
+		2,
+		33,
+		125,
+		0,
+		80,
+		921,
+		103,
+		110,
+		18,
+		195,
+		2637,
+		96,
+		16,
+		1071,
+		18,
+		5,
+		26,
+		3994,
+		6,
+		582,
+		6842,
+		29,
+		1763,
+		568,
+		8,
+		30,
+		18,
+		78,
+		18,
+		29,
+		19,
+		47,
+		17,
+		3,
+		32,
+		20,
+		6,
+		18,
+		433,
+		44,
+		212,
+		63,
+		129,
+		74,
+		6,
+		0,
+		67,
+		12,
+		65,
+		1,
+		2,
+		0,
+		29,
+		6135,
+		9,
+		1237,
+		42,
+		9,
+		8936,
+		3,
+		2,
+		6,
+		2,
+		1,
+		2,
+		290,
+		16,
+		0,
+		30,
+		2,
+		3,
+		0,
+		15,
+		3,
+		9,
+		395,
+		2309,
+		106,
+		6,
+		12,
+		4,
+		8,
+		8,
+		9,
+		5991,
+		84,
+		2,
+		70,
+		2,
+		1,
+		3,
+		0,
+		3,
+		1,
+		3,
+		3,
+		2,
+		11,
+		2,
+		0,
+		2,
+		6,
+		2,
+		64,
+		2,
+		3,
+		3,
+		7,
+		2,
+		6,
+		2,
+		27,
+		2,
+		3,
+		2,
+		4,
+		2,
+		0,
+		4,
+		6,
+		2,
+		339,
+		3,
+		24,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		30,
+		2,
+		24,
+		2,
+		7,
+		1845,
+		30,
+		7,
+		5,
+		262,
+		61,
+		147,
+		44,
+		11,
+		6,
+		17,
+		0,
+		322,
+		29,
+		19,
+		43,
+		485,
+		27,
+		229,
+		29,
+		3,
+		0,
+		496,
+		6,
+		2,
+		3,
+		2,
+		1,
+		2,
+		14,
+		2,
+		196,
+		60,
+		67,
+		8,
+		0,
+		1205,
+		3,
+		2,
+		26,
+		2,
+		1,
+		2,
+		0,
+		3,
+		0,
+		2,
+		9,
+		2,
+		3,
+		2,
+		0,
+		2,
+		0,
+		7,
+		0,
+		5,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		2,
+		2,
+		1,
+		2,
+		0,
+		3,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		0,
+		2,
+		1,
+		2,
+		0,
+		3,
+		3,
+		2,
+		6,
+		2,
+		3,
+		2,
+		3,
+		2,
+		0,
+		2,
+		9,
+		2,
+		16,
+		6,
+		2,
+		2,
+		4,
+		2,
+		16,
+		4421,
+		42719,
+		33,
+		4153,
+		7,
+		221,
+		3,
+		5761,
+		15,
+		7472,
+		16,
+		621,
+		2467,
+		541,
+		1507,
+		4938,
+		6,
+		4191
+	], yt = "‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-ᫎᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", bt = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-ࢎࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೝೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꟍꟐꟑꟓꟕ-Ƛꟲ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", xt = {
+		3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+		5: "class enum extends super const export import",
+		6: "enum",
+		strict: "implements interface let package private protected public static yield",
+		strictBind: "eval arguments"
+	}, St = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this", Ct = {
+		5: St,
+		"5module": St + " export import",
+		6: St + " const class extends export import super"
+	}, wt = /^in(stanceof)?$/, Tt = RegExp("[" + bt + "]"), Et = RegExp("[" + bt + yt + "]"), b = function(e, t) {
+		t === void 0 && (t = {}), this.label = e, this.keyword = t.keyword, this.beforeExpr = !!t.beforeExpr, this.startsExpr = !!t.startsExpr, this.isLoop = !!t.isLoop, this.isAssign = !!t.isAssign, this.prefix = !!t.prefix, this.postfix = !!t.postfix, this.binop = t.binop || null, this.updateContext = null;
+	}, x = { beforeExpr: !0 }, S = { startsExpr: !0 }, Dt = {}, C = {
+		num: new b("num", S),
+		regexp: new b("regexp", S),
+		string: new b("string", S),
+		name: new b("name", S),
+		privateId: new b("privateId", S),
+		eof: new b("eof"),
+		bracketL: new b("[", {
+			beforeExpr: !0,
+			startsExpr: !0
+		}),
+		bracketR: new b("]"),
+		braceL: new b("{", {
+			beforeExpr: !0,
+			startsExpr: !0
+		}),
+		braceR: new b("}"),
+		parenL: new b("(", {
+			beforeExpr: !0,
+			startsExpr: !0
+		}),
+		parenR: new b(")"),
+		comma: new b(",", x),
+		semi: new b(";", x),
+		colon: new b(":", x),
+		dot: new b("."),
+		question: new b("?", x),
+		questionDot: new b("?."),
+		arrow: new b("=>", x),
+		template: new b("template"),
+		invalidTemplate: new b("invalidTemplate"),
+		ellipsis: new b("...", x),
+		backQuote: new b("`", S),
+		dollarBraceL: new b("${", {
+			beforeExpr: !0,
+			startsExpr: !0
+		}),
+		eq: new b("=", {
+			beforeExpr: !0,
+			isAssign: !0
+		}),
+		assign: new b("_=", {
+			beforeExpr: !0,
+			isAssign: !0
+		}),
+		incDec: new b("++/--", {
+			prefix: !0,
+			postfix: !0,
+			startsExpr: !0
+		}),
+		prefix: new b("!/~", {
+			beforeExpr: !0,
+			prefix: !0,
+			startsExpr: !0
+		}),
+		logicalOR: i("||", 1),
+		logicalAND: i("&&", 2),
+		bitwiseOR: i("|", 3),
+		bitwiseXOR: i("^", 4),
+		bitwiseAND: i("&", 5),
+		equality: i("==/!=/===/!==", 6),
+		relational: i("</>/<=/>=", 7),
+		bitShift: i("<</>>/>>>", 8),
+		plusMin: new b("+/-", {
+			beforeExpr: !0,
+			binop: 9,
+			prefix: !0,
+			startsExpr: !0
+		}),
+		modulo: i("%", 10),
+		star: i("*", 10),
+		slash: i("/", 10),
+		starstar: new b("**", { beforeExpr: !0 }),
+		coalesce: i("??", 1),
+		_break: a("break"),
+		_case: a("case", x),
+		_catch: a("catch"),
+		_continue: a("continue"),
+		_debugger: a("debugger"),
+		_default: a("default", x),
+		_do: a("do", {
+			isLoop: !0,
+			beforeExpr: !0
+		}),
+		_else: a("else", x),
+		_finally: a("finally"),
+		_for: a("for", { isLoop: !0 }),
+		_function: a("function", S),
+		_if: a("if"),
+		_return: a("return", x),
+		_switch: a("switch"),
+		_throw: a("throw", x),
+		_try: a("try"),
+		_var: a("var"),
+		_const: a("const"),
+		_while: a("while", { isLoop: !0 }),
+		_with: a("with"),
+		_new: a("new", {
+			beforeExpr: !0,
+			startsExpr: !0
+		}),
+		_this: a("this", S),
+		_super: a("super", S),
+		_class: a("class", S),
+		_extends: a("extends", x),
+		_export: a("export"),
+		_import: a("import", S),
+		_null: a("null", S),
+		_true: a("true", S),
+		_false: a("false", S),
+		_in: a("in", {
+			beforeExpr: !0,
+			binop: 7
+		}),
+		_instanceof: a("instanceof", {
+			beforeExpr: !0,
+			binop: 7
+		}),
+		_typeof: a("typeof", {
+			beforeExpr: !0,
+			prefix: !0,
+			startsExpr: !0
+		}),
+		_void: a("void", {
+			beforeExpr: !0,
+			prefix: !0,
+			startsExpr: !0
+		}),
+		_delete: a("delete", {
+			beforeExpr: !0,
+			prefix: !0,
+			startsExpr: !0
+		})
+	}, w = /\r\n?|\n|\u2028|\u2029/, Ot = new RegExp(w.source, "g"), kt = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/, T = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g, At = Object.prototype, jt = At.hasOwnProperty, Mt = At.toString, E = Object.hasOwn || (function(e, t) {
+		return jt.call(e, t);
+	}), Nt = Array.isArray || (function(e) {
+		return Mt.call(e) === "[object Array]";
+	}), Pt = Object.create(null), Ft = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/, D = function(e, t) {
+		this.line = e, this.column = t;
+	}, D.prototype.offset = function(e) {
+		return new D(this.line, this.column + e);
+	}, It = function(e, t, n) {
+		this.start = t, this.end = n, e.sourceFile !== null && (this.source = e.sourceFile);
+	}, Lt = {
+		ecmaVersion: null,
+		sourceType: "script",
+		onInsertedSemicolon: null,
+		onTrailingComma: null,
+		allowReserved: null,
+		allowReturnOutsideFunction: !1,
+		allowImportExportEverywhere: !1,
+		allowAwaitOutsideFunction: null,
+		allowSuperOutsideMethod: null,
+		allowHashBang: !1,
+		checkPrivateFields: !0,
+		locations: !1,
+		onToken: null,
+		onComment: null,
+		ranges: !1,
+		program: null,
+		sourceFile: null,
+		directSourceFile: null,
+		preserveParens: !1
+	}, Rt = !1, O = 1, k = 2, zt = 4, Bt = 8, Vt = 16, Ht = 32, Ut = 64, Wt = 128, A = 256, j = 512, Gt = O | k | A, Kt = 0, qt = 1, M = 2, Jt = 3, Yt = 4, Xt = 5, N = function(e, t, n) {
+		this.options = e = d(e), this.sourceFile = e.sourceFile, this.keywords = c(Ct[e.ecmaVersion >= 6 ? 6 : e.sourceType === "module" ? "5module" : 5]);
+		var r = "";
+		e.allowReserved !== !0 && (r = xt[e.ecmaVersion >= 6 ? 6 : e.ecmaVersion === 5 ? 5 : 3], e.sourceType === "module" && (r += " await")), this.reservedWords = c(r);
+		var i = (r ? r + " " : "") + xt.strict;
+		this.reservedWordsStrict = c(i), this.reservedWordsStrictBind = c(i + " " + xt.strictBind), this.input = String(t), this.containsEsc = !1, n ? (this.pos = n, this.lineStart = this.input.lastIndexOf("\n", n - 1) + 1, this.curLine = this.input.slice(0, this.lineStart).split(w).length) : (this.pos = this.lineStart = 0, this.curLine = 1), this.type = C.eof, this.value = null, this.start = this.end = this.pos, this.startLoc = this.endLoc = this.curPosition(), this.lastTokEndLoc = this.lastTokStartLoc = null, this.lastTokStart = this.lastTokEnd = this.pos, this.context = this.initialContext(), this.exprAllowed = !0, this.inModule = e.sourceType === "module", this.strict = this.inModule || this.strictDirective(this.pos), this.potentialArrowAt = -1, this.potentialArrowInForAwait = !1, this.yieldPos = this.awaitPos = this.awaitIdentPos = 0, this.labels = [], this.undefinedExports = Object.create(null), this.pos === 0 && e.allowHashBang && this.input.slice(0, 2) === "#!" && this.skipLineComment(2), this.scopeStack = [], this.enterScope(O), this.regexpState = null, this.privateNameStack = [];
+	}, P = {
+		inFunction: { configurable: !0 },
+		inGenerator: { configurable: !0 },
+		inAsync: { configurable: !0 },
+		canAwait: { configurable: !0 },
+		allowSuper: { configurable: !0 },
+		allowDirectSuper: { configurable: !0 },
+		treatFunctionsAsVar: { configurable: !0 },
+		allowNewDotTarget: { configurable: !0 },
+		inClassStaticBlock: { configurable: !0 }
+	}, N.prototype.parse = function() {
+		var e = this.options.program || this.startNode();
+		return this.nextToken(), this.parseTopLevel(e);
+	}, P.inFunction.get = function() {
+		return (this.currentVarScope().flags & k) > 0;
+	}, P.inGenerator.get = function() {
+		return (this.currentVarScope().flags & Bt) > 0;
+	}, P.inAsync.get = function() {
+		return (this.currentVarScope().flags & zt) > 0;
+	}, P.canAwait.get = function() {
+		for (var e = this.scopeStack.length - 1; e >= 0; e--) {
+			var t = this.scopeStack[e].flags;
+			if (t & (A | j)) return !1;
+			if (t & k) return (t & zt) > 0;
+		}
+		return this.inModule && this.options.ecmaVersion >= 13 || this.options.allowAwaitOutsideFunction;
+	}, P.allowSuper.get = function() {
+		return (this.currentThisScope().flags & Ut) > 0 || this.options.allowSuperOutsideMethod;
+	}, P.allowDirectSuper.get = function() {
+		return (this.currentThisScope().flags & Wt) > 0;
+	}, P.treatFunctionsAsVar.get = function() {
+		return this.treatFunctionsAsVarInScope(this.currentScope());
+	}, P.allowNewDotTarget.get = function() {
+		for (var e = this.scopeStack.length - 1; e >= 0; e--) {
+			var t = this.scopeStack[e].flags;
+			if (t & (A | j) || t & k && !(t & Vt)) return !0;
+		}
+		return !1;
+	}, P.inClassStaticBlock.get = function() {
+		return (this.currentVarScope().flags & A) > 0;
+	}, N.extend = function() {
+		for (var e = [], t = arguments.length; t--;) e[t] = arguments[t];
+		for (var n = this, r = 0; r < e.length; r++) n = e[r](n);
+		return n;
+	}, N.parse = function(e, t) {
+		return new this(t, e).parse();
+	}, N.parseExpressionAt = function(e, t, n) {
+		var r = new this(n, e, t);
+		return r.nextToken(), r.parseExpression();
+	}, N.tokenizer = function(e, t) {
+		return new this(t, e);
+	}, Object.defineProperties(N.prototype, P), F = N.prototype, Zt = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/, F.strictDirective = function(e) {
+		if (this.options.ecmaVersion < 5) return !1;
+		for (;;) {
+			T.lastIndex = e, e += T.exec(this.input)[0].length;
+			var t = Zt.exec(this.input.slice(e));
+			if (!t) return !1;
+			if ((t[1] || t[2]) === "use strict") {
+				T.lastIndex = e + t[0].length;
+				var n = T.exec(this.input), r = n.index + n[0].length, i = this.input.charAt(r);
+				return i === ";" || i === "}" || w.test(n[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(i) || i === "!" && this.input.charAt(r + 1) === "=");
+			}
+			e += t[0].length, T.lastIndex = e, e += T.exec(this.input)[0].length, this.input[e] === ";" && e++;
+		}
+	}, F.eat = function(e) {
+		return this.type === e ? (this.next(), !0) : !1;
+	}, F.isContextual = function(e) {
+		return this.type === C.name && this.value === e && !this.containsEsc;
+	}, F.eatContextual = function(e) {
+		return this.isContextual(e) ? (this.next(), !0) : !1;
+	}, F.expectContextual = function(e) {
+		this.eatContextual(e) || this.unexpected();
+	}, F.canInsertSemicolon = function() {
+		return this.type === C.eof || this.type === C.braceR || w.test(this.input.slice(this.lastTokEnd, this.start));
+	}, F.insertSemicolon = function() {
+		if (this.canInsertSemicolon()) return this.options.onInsertedSemicolon && this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc), !0;
+	}, F.semicolon = function() {
+		!this.eat(C.semi) && !this.insertSemicolon() && this.unexpected();
+	}, F.afterTrailingComma = function(e, t) {
+		if (this.type === e) return this.options.onTrailingComma && this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc), t || this.next(), !0;
+	}, F.expect = function(e) {
+		this.eat(e) || this.unexpected();
+	}, F.unexpected = function(e) {
+		this.raise(e ?? this.start, "Unexpected token");
+	}, Qt = function() {
+		this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
+	}, F.checkPatternErrors = function(e, t) {
+		if (e) {
+			e.trailingComma > -1 && this.raiseRecoverable(e.trailingComma, "Comma is not permitted after the rest element");
+			var n = t ? e.parenthesizedAssign : e.parenthesizedBind;
+			n > -1 && this.raiseRecoverable(n, t ? "Assigning to rvalue" : "Parenthesized pattern");
+		}
+	}, F.checkExpressionErrors = function(e, t) {
+		if (!e) return !1;
+		var n = e.shorthandAssign, r = e.doubleProto;
+		if (!t) return n >= 0 || r >= 0;
+		n >= 0 && this.raise(n, "Shorthand property assignments are valid only in destructuring patterns"), r >= 0 && this.raiseRecoverable(r, "Redefinition of __proto__ property");
+	}, F.checkYieldAwaitInDefaultParams = function() {
+		this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos) && this.raise(this.yieldPos, "Yield expression cannot be a default value"), this.awaitPos && this.raise(this.awaitPos, "Await expression cannot be a default value");
+	}, F.isSimpleAssignTarget = function(e) {
+		return e.type === "ParenthesizedExpression" ? this.isSimpleAssignTarget(e.expression) : e.type === "Identifier" || e.type === "MemberExpression";
+	}, I = N.prototype, I.parseTopLevel = function(e) {
+		var t = Object.create(null);
+		for (e.body ||= []; this.type !== C.eof;) {
+			var n = this.parseStatement(null, !0, t);
+			e.body.push(n);
+		}
+		if (this.inModule) for (var r = 0, i = Object.keys(this.undefinedExports); r < i.length; r += 1) {
+			var a = i[r];
+			this.raiseRecoverable(this.undefinedExports[a].start, "Export '" + a + "' is not defined");
+		}
+		return this.adaptDirectivePrologue(e.body), this.next(), e.sourceType = this.options.sourceType, this.finishNode(e, "Program");
+	}, $t = { kind: "loop" }, en = { kind: "switch" }, I.isLet = function(e) {
+		if (this.options.ecmaVersion < 6 || !this.isContextual("let")) return !1;
+		T.lastIndex = this.pos;
+		var t = T.exec(this.input), i = this.pos + t[0].length, a = this.input.charCodeAt(i);
+		if (a === 91 || a === 92) return !0;
+		if (e) return !1;
+		if (a === 123 || a > 55295 && a < 56320) return !0;
+		if (n(a, !0)) {
+			for (var o = i + 1; r(a = this.input.charCodeAt(o), !0);) ++o;
+			if (a === 92 || a > 55295 && a < 56320) return !0;
+			var s = this.input.slice(i, o);
+			if (!wt.test(s)) return !0;
+		}
+		return !1;
+	}, I.isAsyncFunction = function() {
+		if (this.options.ecmaVersion < 8 || !this.isContextual("async")) return !1;
+		T.lastIndex = this.pos;
+		var e = T.exec(this.input), t = this.pos + e[0].length, n;
+		return !w.test(this.input.slice(this.pos, t)) && this.input.slice(t, t + 8) === "function" && (t + 8 === this.input.length || !(r(n = this.input.charCodeAt(t + 8)) || n > 55295 && n < 56320));
+	}, I.isUsingKeyword = function(e, t) {
+		if (this.options.ecmaVersion < 17 || !this.isContextual(e ? "await" : "using")) return !1;
+		T.lastIndex = this.pos;
+		var i = T.exec(this.input), a = this.pos + i[0].length;
+		if (w.test(this.input.slice(this.pos, a))) return !1;
+		if (e) {
+			var o = a + 5, s;
+			if (this.input.slice(a, o) !== "using" || o === this.input.length || r(s = this.input.charCodeAt(o)) || s > 55295 && s < 56320) return !1;
+			T.lastIndex = o;
+			var c = T.exec(this.input);
+			if (c && w.test(this.input.slice(o, o + c[0].length))) return !1;
+		}
+		if (t) {
+			var l = a + 2, u;
+			if (this.input.slice(a, l) === "of" && (l === this.input.length || !r(u = this.input.charCodeAt(l)) && !(u > 55295 && u < 56320))) return !1;
+		}
+		var d = this.input.charCodeAt(a);
+		return n(d, !0) || d === 92;
+	}, I.isAwaitUsing = function(e) {
+		return this.isUsingKeyword(!0, e);
+	}, I.isUsing = function(e) {
+		return this.isUsingKeyword(!1, e);
+	}, I.parseStatement = function(e, t, n) {
+		var r = this.type, i = this.startNode(), a;
+		switch (this.isLet(e) && (r = C._var, a = "let"), r) {
+			case C._break:
+			case C._continue: return this.parseBreakContinueStatement(i, r.keyword);
+			case C._debugger: return this.parseDebuggerStatement(i);
+			case C._do: return this.parseDoStatement(i);
+			case C._for: return this.parseForStatement(i);
+			case C._function: return e && (this.strict || e !== "if" && e !== "label") && this.options.ecmaVersion >= 6 && this.unexpected(), this.parseFunctionStatement(i, !1, !e);
+			case C._class: return e && this.unexpected(), this.parseClass(i, !0);
+			case C._if: return this.parseIfStatement(i);
+			case C._return: return this.parseReturnStatement(i);
+			case C._switch: return this.parseSwitchStatement(i);
+			case C._throw: return this.parseThrowStatement(i);
+			case C._try: return this.parseTryStatement(i);
+			case C._const:
+			case C._var: return a ||= this.value, e && a !== "var" && this.unexpected(), this.parseVarStatement(i, a);
+			case C._while: return this.parseWhileStatement(i);
+			case C._with: return this.parseWithStatement(i);
+			case C.braceL: return this.parseBlock(!0, i);
+			case C.semi: return this.parseEmptyStatement(i);
+			case C._export:
+			case C._import:
+				if (this.options.ecmaVersion > 10 && r === C._import) {
+					T.lastIndex = this.pos;
+					var o = T.exec(this.input), s = this.pos + o[0].length, c = this.input.charCodeAt(s);
+					if (c === 40 || c === 46) return this.parseExpressionStatement(i, this.parseExpression());
+				}
+				return this.options.allowImportExportEverywhere || (t || this.raise(this.start, "'import' and 'export' may only appear at the top level"), this.inModule || this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'")), r === C._import ? this.parseImport(i) : this.parseExport(i, n);
+			default:
+				if (this.isAsyncFunction()) return e && this.unexpected(), this.next(), this.parseFunctionStatement(i, !0, !e);
+				var l = this.isAwaitUsing(!1) ? "await using" : this.isUsing(!1) ? "using" : null;
+				if (l) return t && this.options.sourceType === "script" && this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script`"), l === "await using" && (this.canAwait || this.raise(this.start, "Await using cannot appear outside of async function"), this.next()), this.next(), this.parseVar(i, !1, l), this.semicolon(), this.finishNode(i, "VariableDeclaration");
+				var u = this.value, d = this.parseExpression();
+				return r === C.name && d.type === "Identifier" && this.eat(C.colon) ? this.parseLabeledStatement(i, u, d, e) : this.parseExpressionStatement(i, d);
+		}
+	}, I.parseBreakContinueStatement = function(e, t) {
+		var n = t === "break";
+		this.next(), this.eat(C.semi) || this.insertSemicolon() ? e.label = null : this.type === C.name ? (e.label = this.parseIdent(), this.semicolon()) : this.unexpected();
+		for (var r = 0; r < this.labels.length; ++r) {
+			var i = this.labels[r];
+			if ((e.label == null || i.name === e.label.name) && (i.kind != null && (n || i.kind === "loop") || e.label && n)) break;
+		}
+		return r === this.labels.length && this.raise(e.start, "Unsyntactic " + t), this.finishNode(e, n ? "BreakStatement" : "ContinueStatement");
+	}, I.parseDebuggerStatement = function(e) {
+		return this.next(), this.semicolon(), this.finishNode(e, "DebuggerStatement");
+	}, I.parseDoStatement = function(e) {
+		return this.next(), this.labels.push($t), e.body = this.parseStatement("do"), this.labels.pop(), this.expect(C._while), e.test = this.parseParenExpression(), this.options.ecmaVersion >= 6 ? this.eat(C.semi) : this.semicolon(), this.finishNode(e, "DoWhileStatement");
+	}, I.parseForStatement = function(e) {
+		this.next();
+		var t = this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await") ? this.lastTokStart : -1;
+		if (this.labels.push($t), this.enterScope(0), this.expect(C.parenL), this.type === C.semi) return t > -1 && this.unexpected(t), this.parseFor(e, null);
+		var n = this.isLet();
+		if (this.type === C._var || this.type === C._const || n) {
+			var r = this.startNode(), i = n ? "let" : this.value;
+			return this.next(), this.parseVar(r, !0, i), this.finishNode(r, "VariableDeclaration"), this.parseForAfterInit(e, r, t);
+		}
+		var a = this.isContextual("let"), o = !1, s = this.isUsing(!0) ? "using" : this.isAwaitUsing(!0) ? "await using" : null;
+		if (s) {
+			var c = this.startNode();
+			return this.next(), s === "await using" && this.next(), this.parseVar(c, !0, s), this.finishNode(c, "VariableDeclaration"), this.parseForAfterInit(e, c, t);
+		}
+		var l = this.containsEsc, u = new Qt(), d = this.start, f = t > -1 ? this.parseExprSubscripts(u, "await") : this.parseExpression(!0, u);
+		return this.type === C._in || (o = this.options.ecmaVersion >= 6 && this.isContextual("of")) ? (t > -1 ? (this.type === C._in && this.unexpected(t), e.await = !0) : o && this.options.ecmaVersion >= 8 && (f.start === d && !l && f.type === "Identifier" && f.name === "async" ? this.unexpected() : this.options.ecmaVersion >= 9 && (e.await = !1)), a && o && this.raise(f.start, "The left-hand side of a for-of loop may not start with 'let'."), this.toAssignable(f, !1, u), this.checkLValPattern(f), this.parseForIn(e, f)) : (this.checkExpressionErrors(u, !0), t > -1 && this.unexpected(t), this.parseFor(e, f));
+	}, I.parseForAfterInit = function(e, t, n) {
+		return (this.type === C._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && t.declarations.length === 1 ? (this.options.ecmaVersion >= 9 && (this.type === C._in ? n > -1 && this.unexpected(n) : e.await = n > -1), this.parseForIn(e, t)) : (n > -1 && this.unexpected(n), this.parseFor(e, t));
+	}, I.parseFunctionStatement = function(e, t, n) {
+		return this.next(), this.parseFunction(e, L | (n ? 0 : nn), !1, t);
+	}, I.parseIfStatement = function(e) {
+		return this.next(), e.test = this.parseParenExpression(), e.consequent = this.parseStatement("if"), e.alternate = this.eat(C._else) ? this.parseStatement("if") : null, this.finishNode(e, "IfStatement");
+	}, I.parseReturnStatement = function(e) {
+		return !this.inFunction && !this.options.allowReturnOutsideFunction && this.raise(this.start, "'return' outside of function"), this.next(), this.eat(C.semi) || this.insertSemicolon() ? e.argument = null : (e.argument = this.parseExpression(), this.semicolon()), this.finishNode(e, "ReturnStatement");
+	}, I.parseSwitchStatement = function(e) {
+		this.next(), e.discriminant = this.parseParenExpression(), e.cases = [], this.expect(C.braceL), this.labels.push(en), this.enterScope(0);
+		for (var t, n = !1; this.type !== C.braceR;) if (this.type === C._case || this.type === C._default) {
+			var r = this.type === C._case;
+			t && this.finishNode(t, "SwitchCase"), e.cases.push(t = this.startNode()), t.consequent = [], this.next(), r ? t.test = this.parseExpression() : (n && this.raiseRecoverable(this.lastTokStart, "Multiple default clauses"), n = !0, t.test = null), this.expect(C.colon);
+		} else t || this.unexpected(), t.consequent.push(this.parseStatement(null));
+		return this.exitScope(), t && this.finishNode(t, "SwitchCase"), this.next(), this.labels.pop(), this.finishNode(e, "SwitchStatement");
+	}, I.parseThrowStatement = function(e) {
+		return this.next(), w.test(this.input.slice(this.lastTokEnd, this.start)) && this.raise(this.lastTokEnd, "Illegal newline after throw"), e.argument = this.parseExpression(), this.semicolon(), this.finishNode(e, "ThrowStatement");
+	}, tn = [], I.parseCatchClauseParam = function() {
+		var e = this.parseBindingAtom(), t = e.type === "Identifier";
+		return this.enterScope(t ? Ht : 0), this.checkLValPattern(e, t ? Yt : M), this.expect(C.parenR), e;
+	}, I.parseTryStatement = function(e) {
+		if (this.next(), e.block = this.parseBlock(), e.handler = null, this.type === C._catch) {
+			var t = this.startNode();
+			this.next(), this.eat(C.parenL) ? t.param = this.parseCatchClauseParam() : (this.options.ecmaVersion < 10 && this.unexpected(), t.param = null, this.enterScope(0)), t.body = this.parseBlock(!1), this.exitScope(), e.handler = this.finishNode(t, "CatchClause");
+		}
+		return e.finalizer = this.eat(C._finally) ? this.parseBlock() : null, !e.handler && !e.finalizer && this.raise(e.start, "Missing catch or finally clause"), this.finishNode(e, "TryStatement");
+	}, I.parseVarStatement = function(e, t, n) {
+		return this.next(), this.parseVar(e, !1, t, n), this.semicolon(), this.finishNode(e, "VariableDeclaration");
+	}, I.parseWhileStatement = function(e) {
+		return this.next(), e.test = this.parseParenExpression(), this.labels.push($t), e.body = this.parseStatement("while"), this.labels.pop(), this.finishNode(e, "WhileStatement");
+	}, I.parseWithStatement = function(e) {
+		return this.strict && this.raise(this.start, "'with' in strict mode"), this.next(), e.object = this.parseParenExpression(), e.body = this.parseStatement("with"), this.finishNode(e, "WithStatement");
+	}, I.parseEmptyStatement = function(e) {
+		return this.next(), this.finishNode(e, "EmptyStatement");
+	}, I.parseLabeledStatement = function(e, t, n, r) {
+		for (var i = 0, a = this.labels; i < a.length; i += 1) a[i].name === t && this.raise(n.start, "Label '" + t + "' is already declared");
+		for (var o = this.type.isLoop ? "loop" : this.type === C._switch ? "switch" : null, s = this.labels.length - 1; s >= 0; s--) {
+			var c = this.labels[s];
+			if (c.statementStart === e.start) c.statementStart = this.start, c.kind = o;
+			else break;
+		}
+		return this.labels.push({
+			name: t,
+			kind: o,
+			statementStart: this.start
+		}), e.body = this.parseStatement(r ? r.indexOf("label") === -1 ? r + "label" : r : "label"), this.labels.pop(), e.label = n, this.finishNode(e, "LabeledStatement");
+	}, I.parseExpressionStatement = function(e, t) {
+		return e.expression = t, this.semicolon(), this.finishNode(e, "ExpressionStatement");
+	}, I.parseBlock = function(e, t, n) {
+		for (e === void 0 && (e = !0), t === void 0 && (t = this.startNode()), t.body = [], this.expect(C.braceL), e && this.enterScope(0); this.type !== C.braceR;) {
+			var r = this.parseStatement(null);
+			t.body.push(r);
+		}
+		return n && (this.strict = !1), this.next(), e && this.exitScope(), this.finishNode(t, "BlockStatement");
+	}, I.parseFor = function(e, t) {
+		return e.init = t, this.expect(C.semi), e.test = this.type === C.semi ? null : this.parseExpression(), this.expect(C.semi), e.update = this.type === C.parenR ? null : this.parseExpression(), this.expect(C.parenR), e.body = this.parseStatement("for"), this.exitScope(), this.labels.pop(), this.finishNode(e, "ForStatement");
+	}, I.parseForIn = function(e, t) {
+		var n = this.type === C._in;
+		return this.next(), t.type === "VariableDeclaration" && t.declarations[0].init != null && (!n || this.options.ecmaVersion < 8 || this.strict || t.kind !== "var" || t.declarations[0].id.type !== "Identifier") && this.raise(t.start, (n ? "for-in" : "for-of") + " loop variable declaration may not have an initializer"), e.left = t, e.right = n ? this.parseExpression() : this.parseMaybeAssign(), this.expect(C.parenR), e.body = this.parseStatement("for"), this.exitScope(), this.labels.pop(), this.finishNode(e, n ? "ForInStatement" : "ForOfStatement");
+	}, I.parseVar = function(e, t, n, r) {
+		for (e.declarations = [], e.kind = n;;) {
+			var i = this.startNode();
+			if (this.parseVarId(i, n), this.eat(C.eq) ? i.init = this.parseMaybeAssign(t) : !r && n === "const" && !(this.type === C._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) ? this.unexpected() : !r && (n === "using" || n === "await using") && this.options.ecmaVersion >= 17 && this.type !== C._in && !this.isContextual("of") ? this.raise(this.lastTokEnd, "Missing initializer in " + n + " declaration") : !r && i.id.type !== "Identifier" && !(t && (this.type === C._in || this.isContextual("of"))) ? this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value") : i.init = null, e.declarations.push(this.finishNode(i, "VariableDeclarator")), !this.eat(C.comma)) break;
+		}
+		return e;
+	}, I.parseVarId = function(e, t) {
+		e.id = t === "using" || t === "await using" ? this.parseIdent() : this.parseBindingAtom(), this.checkLValPattern(e.id, t === "var" ? qt : M, !1);
+	}, L = 1, nn = 2, rn = 4, I.parseFunction = function(e, t, n, r, i) {
+		this.initFunction(e), (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !r) && (this.type === C.star && t & nn && this.unexpected(), e.generator = this.eat(C.star)), this.options.ecmaVersion >= 8 && (e.async = !!r), t & L && (e.id = t & rn && this.type !== C.name ? null : this.parseIdent(), e.id && !(t & nn) && this.checkLValSimple(e.id, this.strict || e.generator || e.async ? this.treatFunctionsAsVar ? qt : M : Jt));
+		var a = this.yieldPos, o = this.awaitPos, s = this.awaitIdentPos;
+		return this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.enterScope(p(e.async, e.generator)), t & L || (e.id = this.type === C.name ? this.parseIdent() : null), this.parseFunctionParams(e), this.parseFunctionBody(e, n, !1, i), this.yieldPos = a, this.awaitPos = o, this.awaitIdentPos = s, this.finishNode(e, t & L ? "FunctionDeclaration" : "FunctionExpression");
+	}, I.parseFunctionParams = function(e) {
+		this.expect(C.parenL), e.params = this.parseBindingList(C.parenR, !1, this.options.ecmaVersion >= 8), this.checkYieldAwaitInDefaultParams();
+	}, I.parseClass = function(e, t) {
+		this.next();
+		var n = this.strict;
+		this.strict = !0, this.parseClassId(e, t), this.parseClassSuper(e);
+		var r = this.enterClassBody(), i = this.startNode(), a = !1;
+		for (i.body = [], this.expect(C.braceL); this.type !== C.braceR;) {
+			var o = this.parseClassElement(e.superClass !== null);
+			o && (i.body.push(o), o.type === "MethodDefinition" && o.kind === "constructor" ? (a && this.raiseRecoverable(o.start, "Duplicate constructor in the same class"), a = !0) : o.key && o.key.type === "PrivateIdentifier" && m(r, o) && this.raiseRecoverable(o.key.start, "Identifier '#" + o.key.name + "' has already been declared"));
+		}
+		return this.strict = n, this.next(), e.body = this.finishNode(i, "ClassBody"), this.exitClassBody(), this.finishNode(e, t ? "ClassDeclaration" : "ClassExpression");
+	}, I.parseClassElement = function(e) {
+		if (this.eat(C.semi)) return null;
+		var t = this.options.ecmaVersion, n = this.startNode(), r = "", i = !1, a = !1, o = "method", s = !1;
+		if (this.eatContextual("static")) {
+			if (t >= 13 && this.eat(C.braceL)) return this.parseClassStaticBlock(n), n;
+			this.isClassElementNameStart() || this.type === C.star ? s = !0 : r = "static";
+		}
+		if (n.static = s, !r && t >= 8 && this.eatContextual("async") && ((this.isClassElementNameStart() || this.type === C.star) && !this.canInsertSemicolon() ? a = !0 : r = "async"), !r && (t >= 9 || !a) && this.eat(C.star) && (i = !0), !r && !a && !i) {
+			var c = this.value;
+			(this.eatContextual("get") || this.eatContextual("set")) && (this.isClassElementNameStart() ? o = c : r = c);
+		}
+		if (r ? (n.computed = !1, n.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc), n.key.name = r, this.finishNode(n.key, "Identifier")) : this.parseClassElementName(n), t < 13 || this.type === C.parenL || o !== "method" || i || a) {
+			var l = !n.static && h(n, "constructor"), u = l && e;
+			l && o !== "method" && this.raise(n.key.start, "Constructor can't have get/set modifier"), n.kind = l ? "constructor" : o, this.parseClassMethod(n, i, a, u);
+		} else this.parseClassField(n);
+		return n;
+	}, I.isClassElementNameStart = function() {
+		return this.type === C.name || this.type === C.privateId || this.type === C.num || this.type === C.string || this.type === C.bracketL || this.type.keyword;
+	}, I.parseClassElementName = function(e) {
+		this.type === C.privateId ? (this.value === "constructor" && this.raise(this.start, "Classes can't have an element named '#constructor'"), e.computed = !1, e.key = this.parsePrivateIdent()) : this.parsePropertyName(e);
+	}, I.parseClassMethod = function(e, t, n, r) {
+		var i = e.key;
+		e.kind === "constructor" ? (t && this.raise(i.start, "Constructor can't be a generator"), n && this.raise(i.start, "Constructor can't be an async method")) : e.static && h(e, "prototype") && this.raise(i.start, "Classes may not have a static property named prototype");
+		var a = e.value = this.parseMethod(t, n, r);
+		return e.kind === "get" && a.params.length !== 0 && this.raiseRecoverable(a.start, "getter should have no params"), e.kind === "set" && a.params.length !== 1 && this.raiseRecoverable(a.start, "setter should have exactly one param"), e.kind === "set" && a.params[0].type === "RestElement" && this.raiseRecoverable(a.params[0].start, "Setter cannot use rest params"), this.finishNode(e, "MethodDefinition");
+	}, I.parseClassField = function(e) {
+		return h(e, "constructor") ? this.raise(e.key.start, "Classes can't have a field named 'constructor'") : e.static && h(e, "prototype") && this.raise(e.key.start, "Classes can't have a static field named 'prototype'"), this.eat(C.eq) ? (this.enterScope(j | Ut), e.value = this.parseMaybeAssign(), this.exitScope()) : e.value = null, this.semicolon(), this.finishNode(e, "PropertyDefinition");
+	}, I.parseClassStaticBlock = function(e) {
+		e.body = [];
+		var t = this.labels;
+		for (this.labels = [], this.enterScope(A | Ut); this.type !== C.braceR;) {
+			var n = this.parseStatement(null);
+			e.body.push(n);
+		}
+		return this.next(), this.exitScope(), this.labels = t, this.finishNode(e, "StaticBlock");
+	}, I.parseClassId = function(e, t) {
+		this.type === C.name ? (e.id = this.parseIdent(), t && this.checkLValSimple(e.id, M, !1)) : (t === !0 && this.unexpected(), e.id = null);
+	}, I.parseClassSuper = function(e) {
+		e.superClass = this.eat(C._extends) ? this.parseExprSubscripts(null, !1) : null;
+	}, I.enterClassBody = function() {
+		var e = {
+			declared: Object.create(null),
+			used: []
+		};
+		return this.privateNameStack.push(e), e.declared;
+	}, I.exitClassBody = function() {
+		var e = this.privateNameStack.pop(), t = e.declared, n = e.used;
+		if (this.options.checkPrivateFields) for (var r = this.privateNameStack.length, i = r === 0 ? null : this.privateNameStack[r - 1], a = 0; a < n.length; ++a) {
+			var o = n[a];
+			E(t, o.name) || (i ? i.used.push(o) : this.raiseRecoverable(o.start, "Private field '#" + o.name + "' must be declared in an enclosing class"));
+		}
+	}, I.parseExportAllDeclaration = function(e, t) {
+		return this.options.ecmaVersion >= 11 && (this.eatContextual("as") ? (e.exported = this.parseModuleExportName(), this.checkExport(t, e.exported, this.lastTokStart)) : e.exported = null), this.expectContextual("from"), this.type !== C.string && this.unexpected(), e.source = this.parseExprAtom(), this.options.ecmaVersion >= 16 && (e.attributes = this.parseWithClause()), this.semicolon(), this.finishNode(e, "ExportAllDeclaration");
+	}, I.parseExport = function(e, t) {
+		if (this.next(), this.eat(C.star)) return this.parseExportAllDeclaration(e, t);
+		if (this.eat(C._default)) return this.checkExport(t, "default", this.lastTokStart), e.declaration = this.parseExportDefaultDeclaration(), this.finishNode(e, "ExportDefaultDeclaration");
+		if (this.shouldParseExportStatement()) e.declaration = this.parseExportDeclaration(e), e.declaration.type === "VariableDeclaration" ? this.checkVariableExport(t, e.declaration.declarations) : this.checkExport(t, e.declaration.id, e.declaration.id.start), e.specifiers = [], e.source = null, this.options.ecmaVersion >= 16 && (e.attributes = []);
+		else {
+			if (e.declaration = null, e.specifiers = this.parseExportSpecifiers(t), this.eatContextual("from")) this.type !== C.string && this.unexpected(), e.source = this.parseExprAtom(), this.options.ecmaVersion >= 16 && (e.attributes = this.parseWithClause());
+			else {
+				for (var n = 0, r = e.specifiers; n < r.length; n += 1) {
+					var i = r[n];
+					this.checkUnreserved(i.local), this.checkLocalExport(i.local), i.local.type === "Literal" && this.raise(i.local.start, "A string literal cannot be used as an exported binding without `from`.");
+				}
+				e.source = null, this.options.ecmaVersion >= 16 && (e.attributes = []);
+			}
+			this.semicolon();
+		}
+		return this.finishNode(e, "ExportNamedDeclaration");
+	}, I.parseExportDeclaration = function(e) {
+		return this.parseStatement(null);
+	}, I.parseExportDefaultDeclaration = function() {
+		var e;
+		if (this.type === C._function || (e = this.isAsyncFunction())) {
+			var t = this.startNode();
+			return this.next(), e && this.next(), this.parseFunction(t, L | rn, !1, e);
+		} else if (this.type === C._class) {
+			var n = this.startNode();
+			return this.parseClass(n, "nullableID");
+		} else {
+			var r = this.parseMaybeAssign();
+			return this.semicolon(), r;
+		}
+	}, I.checkExport = function(e, t, n) {
+		e && (typeof t != "string" && (t = t.type === "Identifier" ? t.name : t.value), E(e, t) && this.raiseRecoverable(n, "Duplicate export '" + t + "'"), e[t] = !0);
+	}, I.checkPatternExport = function(e, t) {
+		var n = t.type;
+		if (n === "Identifier") this.checkExport(e, t, t.start);
+		else if (n === "ObjectPattern") for (var r = 0, i = t.properties; r < i.length; r += 1) {
+			var a = i[r];
+			this.checkPatternExport(e, a);
+		}
+		else if (n === "ArrayPattern") for (var o = 0, s = t.elements; o < s.length; o += 1) {
+			var c = s[o];
+			c && this.checkPatternExport(e, c);
+		}
+		else n === "Property" ? this.checkPatternExport(e, t.value) : n === "AssignmentPattern" ? this.checkPatternExport(e, t.left) : n === "RestElement" && this.checkPatternExport(e, t.argument);
+	}, I.checkVariableExport = function(e, t) {
+		if (e) for (var n = 0, r = t; n < r.length; n += 1) {
+			var i = r[n];
+			this.checkPatternExport(e, i.id);
+		}
+	}, I.shouldParseExportStatement = function() {
+		return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
+	}, I.parseExportSpecifier = function(e) {
+		var t = this.startNode();
+		return t.local = this.parseModuleExportName(), t.exported = this.eatContextual("as") ? this.parseModuleExportName() : t.local, this.checkExport(e, t.exported, t.exported.start), this.finishNode(t, "ExportSpecifier");
+	}, I.parseExportSpecifiers = function(e) {
+		var t = [], n = !0;
+		for (this.expect(C.braceL); !this.eat(C.braceR);) {
+			if (n) n = !1;
+			else if (this.expect(C.comma), this.afterTrailingComma(C.braceR)) break;
+			t.push(this.parseExportSpecifier(e));
+		}
+		return t;
+	}, I.parseImport = function(e) {
+		return this.next(), this.type === C.string ? (e.specifiers = tn, e.source = this.parseExprAtom()) : (e.specifiers = this.parseImportSpecifiers(), this.expectContextual("from"), e.source = this.type === C.string ? this.parseExprAtom() : this.unexpected()), this.options.ecmaVersion >= 16 && (e.attributes = this.parseWithClause()), this.semicolon(), this.finishNode(e, "ImportDeclaration");
+	}, I.parseImportSpecifier = function() {
+		var e = this.startNode();
+		return e.imported = this.parseModuleExportName(), this.eatContextual("as") ? e.local = this.parseIdent() : (this.checkUnreserved(e.imported), e.local = e.imported), this.checkLValSimple(e.local, M), this.finishNode(e, "ImportSpecifier");
+	}, I.parseImportDefaultSpecifier = function() {
+		var e = this.startNode();
+		return e.local = this.parseIdent(), this.checkLValSimple(e.local, M), this.finishNode(e, "ImportDefaultSpecifier");
+	}, I.parseImportNamespaceSpecifier = function() {
+		var e = this.startNode();
+		return this.next(), this.expectContextual("as"), e.local = this.parseIdent(), this.checkLValSimple(e.local, M), this.finishNode(e, "ImportNamespaceSpecifier");
+	}, I.parseImportSpecifiers = function() {
+		var e = [], t = !0;
+		if (this.type === C.name && (e.push(this.parseImportDefaultSpecifier()), !this.eat(C.comma))) return e;
+		if (this.type === C.star) return e.push(this.parseImportNamespaceSpecifier()), e;
+		for (this.expect(C.braceL); !this.eat(C.braceR);) {
+			if (t) t = !1;
+			else if (this.expect(C.comma), this.afterTrailingComma(C.braceR)) break;
+			e.push(this.parseImportSpecifier());
+		}
+		return e;
+	}, I.parseWithClause = function() {
+		var e = [];
+		if (!this.eat(C._with)) return e;
+		this.expect(C.braceL);
+		for (var t = {}, n = !0; !this.eat(C.braceR);) {
+			if (n) n = !1;
+			else if (this.expect(C.comma), this.afterTrailingComma(C.braceR)) break;
+			var r = this.parseImportAttribute(), i = r.key.type === "Identifier" ? r.key.name : r.key.value;
+			E(t, i) && this.raiseRecoverable(r.key.start, "Duplicate attribute key '" + i + "'"), t[i] = !0, e.push(r);
+		}
+		return e;
+	}, I.parseImportAttribute = function() {
+		var e = this.startNode();
+		return e.key = this.type === C.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never"), this.expect(C.colon), this.type !== C.string && this.unexpected(), e.value = this.parseExprAtom(), this.finishNode(e, "ImportAttribute");
+	}, I.parseModuleExportName = function() {
+		if (this.options.ecmaVersion >= 13 && this.type === C.string) {
+			var e = this.parseLiteral(this.value);
+			return Ft.test(e.value) && this.raise(e.start, "An export name cannot include a lone surrogate."), e;
+		}
+		return this.parseIdent(!0);
+	}, I.adaptDirectivePrologue = function(e) {
+		for (var t = 0; t < e.length && this.isDirectiveCandidate(e[t]); ++t) e[t].directive = e[t].expression.raw.slice(1, -1);
+	}, I.isDirectiveCandidate = function(e) {
+		return this.options.ecmaVersion >= 5 && e.type === "ExpressionStatement" && e.expression.type === "Literal" && typeof e.expression.value == "string" && (this.input[e.start] === "\"" || this.input[e.start] === "'");
+	}, R = N.prototype, R.toAssignable = function(e, t, n) {
+		if (this.options.ecmaVersion >= 6 && e) switch (e.type) {
+			case "Identifier":
+				this.inAsync && e.name === "await" && this.raise(e.start, "Cannot use 'await' as identifier inside an async function");
+				break;
+			case "ObjectPattern":
+			case "ArrayPattern":
+			case "AssignmentPattern":
+			case "RestElement": break;
+			case "ObjectExpression":
+				e.type = "ObjectPattern", n && this.checkPatternErrors(n, !0);
+				for (var r = 0, i = e.properties; r < i.length; r += 1) {
+					var a = i[r];
+					this.toAssignable(a, t), a.type === "RestElement" && (a.argument.type === "ArrayPattern" || a.argument.type === "ObjectPattern") && this.raise(a.argument.start, "Unexpected token");
+				}
+				break;
+			case "Property":
+				e.kind !== "init" && this.raise(e.key.start, "Object pattern can't contain getter or setter"), this.toAssignable(e.value, t);
+				break;
+			case "ArrayExpression":
+				e.type = "ArrayPattern", n && this.checkPatternErrors(n, !0), this.toAssignableList(e.elements, t);
+				break;
+			case "SpreadElement":
+				e.type = "RestElement", this.toAssignable(e.argument, t), e.argument.type === "AssignmentPattern" && this.raise(e.argument.start, "Rest elements cannot have a default value");
+				break;
+			case "AssignmentExpression":
+				e.operator !== "=" && this.raise(e.left.end, "Only '=' operator can be used for specifying default value."), e.type = "AssignmentPattern", delete e.operator, this.toAssignable(e.left, t);
+				break;
+			case "ParenthesizedExpression":
+				this.toAssignable(e.expression, t, n);
+				break;
+			case "ChainExpression":
+				this.raiseRecoverable(e.start, "Optional chaining cannot appear in left-hand side");
+				break;
+			case "MemberExpression": if (!t) break;
+			default: this.raise(e.start, "Assigning to rvalue");
+		}
+		else n && this.checkPatternErrors(n, !0);
+		return e;
+	}, R.toAssignableList = function(e, t) {
+		for (var n = e.length, r = 0; r < n; r++) {
+			var i = e[r];
+			i && this.toAssignable(i, t);
+		}
+		if (n) {
+			var a = e[n - 1];
+			this.options.ecmaVersion === 6 && t && a && a.type === "RestElement" && a.argument.type !== "Identifier" && this.unexpected(a.argument.start);
+		}
+		return e;
+	}, R.parseSpread = function(e) {
+		var t = this.startNode();
+		return this.next(), t.argument = this.parseMaybeAssign(!1, e), this.finishNode(t, "SpreadElement");
+	}, R.parseRestBinding = function() {
+		var e = this.startNode();
+		return this.next(), this.options.ecmaVersion === 6 && this.type !== C.name && this.unexpected(), e.argument = this.parseBindingAtom(), this.finishNode(e, "RestElement");
+	}, R.parseBindingAtom = function() {
+		if (this.options.ecmaVersion >= 6) switch (this.type) {
+			case C.bracketL:
+				var e = this.startNode();
+				return this.next(), e.elements = this.parseBindingList(C.bracketR, !0, !0), this.finishNode(e, "ArrayPattern");
+			case C.braceL: return this.parseObj(!0);
+		}
+		return this.parseIdent();
+	}, R.parseBindingList = function(e, t, n, r) {
+		for (var i = [], a = !0; !this.eat(e);) if (a ? a = !1 : this.expect(C.comma), t && this.type === C.comma) i.push(null);
+		else {
+			if (n && this.afterTrailingComma(e)) break;
+			if (this.type === C.ellipsis) {
+				var o = this.parseRestBinding();
+				this.parseBindingListItem(o), i.push(o), this.type === C.comma && this.raiseRecoverable(this.start, "Comma is not permitted after the rest element"), this.expect(e);
+				break;
+			} else i.push(this.parseAssignableListItem(r));
+		}
+		return i;
+	}, R.parseAssignableListItem = function(e) {
+		var t = this.parseMaybeDefault(this.start, this.startLoc);
+		return this.parseBindingListItem(t), t;
+	}, R.parseBindingListItem = function(e) {
+		return e;
+	}, R.parseMaybeDefault = function(e, t, n) {
+		if (n ||= this.parseBindingAtom(), this.options.ecmaVersion < 6 || !this.eat(C.eq)) return n;
+		var r = this.startNodeAt(e, t);
+		return r.left = n, r.right = this.parseMaybeAssign(), this.finishNode(r, "AssignmentPattern");
+	}, R.checkLValSimple = function(e, t, n) {
+		t === void 0 && (t = Kt);
+		var r = t !== Kt;
+		switch (e.type) {
+			case "Identifier":
+				this.strict && this.reservedWordsStrictBind.test(e.name) && this.raiseRecoverable(e.start, (r ? "Binding " : "Assigning to ") + e.name + " in strict mode"), r && (t === M && e.name === "let" && this.raiseRecoverable(e.start, "let is disallowed as a lexically bound name"), n && (E(n, e.name) && this.raiseRecoverable(e.start, "Argument name clash"), n[e.name] = !0), t !== Xt && this.declareName(e.name, t, e.start));
+				break;
+			case "ChainExpression":
+				this.raiseRecoverable(e.start, "Optional chaining cannot appear in left-hand side");
+				break;
+			case "MemberExpression":
+				r && this.raiseRecoverable(e.start, "Binding member expression");
+				break;
+			case "ParenthesizedExpression": return r && this.raiseRecoverable(e.start, "Binding parenthesized expression"), this.checkLValSimple(e.expression, t, n);
+			default: this.raise(e.start, (r ? "Binding" : "Assigning to") + " rvalue");
+		}
+	}, R.checkLValPattern = function(e, t, n) {
+		switch (t === void 0 && (t = Kt), e.type) {
+			case "ObjectPattern":
+				for (var r = 0, i = e.properties; r < i.length; r += 1) {
+					var a = i[r];
+					this.checkLValInnerPattern(a, t, n);
+				}
+				break;
+			case "ArrayPattern":
+				for (var o = 0, s = e.elements; o < s.length; o += 1) {
+					var c = s[o];
+					c && this.checkLValInnerPattern(c, t, n);
+				}
+				break;
+			default: this.checkLValSimple(e, t, n);
+		}
+	}, R.checkLValInnerPattern = function(e, t, n) {
+		switch (t === void 0 && (t = Kt), e.type) {
+			case "Property":
+				this.checkLValInnerPattern(e.value, t, n);
+				break;
+			case "AssignmentPattern":
+				this.checkLValPattern(e.left, t, n);
+				break;
+			case "RestElement":
+				this.checkLValPattern(e.argument, t, n);
+				break;
+			default: this.checkLValPattern(e, t, n);
+		}
+	}, z = function(e, t, n, r, i) {
+		this.token = e, this.isExpr = !!t, this.preserveSpace = !!n, this.override = r, this.generator = !!i;
+	}, B = {
+		b_stat: new z("{", !1),
+		b_expr: new z("{", !0),
+		b_tmpl: new z("${", !1),
+		p_stat: new z("(", !1),
+		p_expr: new z("(", !0),
+		q_tmpl: new z("`", !0, !0, function(e) {
+			return e.tryReadTemplateToken();
+		}),
+		f_stat: new z("function", !1),
+		f_expr: new z("function", !0),
+		f_expr_gen: new z("function", !0, !1, null, !0),
+		f_gen: new z("function", !1, !1, null, !0)
+	}, V = N.prototype, V.initialContext = function() {
+		return [B.b_stat];
+	}, V.curContext = function() {
+		return this.context[this.context.length - 1];
+	}, V.braceIsBlock = function(e) {
+		var t = this.curContext();
+		return t === B.f_expr || t === B.f_stat ? !0 : e === C.colon && (t === B.b_stat || t === B.b_expr) ? !t.isExpr : e === C._return || e === C.name && this.exprAllowed ? w.test(this.input.slice(this.lastTokEnd, this.start)) : e === C._else || e === C.semi || e === C.eof || e === C.parenR || e === C.arrow ? !0 : e === C.braceL ? t === B.b_stat : e === C._var || e === C._const || e === C.name ? !1 : !this.exprAllowed;
+	}, V.inGeneratorContext = function() {
+		for (var e = this.context.length - 1; e >= 1; e--) {
+			var t = this.context[e];
+			if (t.token === "function") return t.generator;
+		}
+		return !1;
+	}, V.updateContext = function(e) {
+		var t, n = this.type;
+		n.keyword && e === C.dot ? this.exprAllowed = !1 : (t = n.updateContext) ? t.call(this, e) : this.exprAllowed = n.beforeExpr;
+	}, V.overrideContext = function(e) {
+		this.curContext() !== e && (this.context[this.context.length - 1] = e);
+	}, C.parenR.updateContext = C.braceR.updateContext = function() {
+		if (this.context.length === 1) {
+			this.exprAllowed = !0;
+			return;
+		}
+		var e = this.context.pop();
+		e === B.b_stat && this.curContext().token === "function" && (e = this.context.pop()), this.exprAllowed = !e.isExpr;
+	}, C.braceL.updateContext = function(e) {
+		this.context.push(this.braceIsBlock(e) ? B.b_stat : B.b_expr), this.exprAllowed = !0;
+	}, C.dollarBraceL.updateContext = function() {
+		this.context.push(B.b_tmpl), this.exprAllowed = !0;
+	}, C.parenL.updateContext = function(e) {
+		var t = e === C._if || e === C._for || e === C._with || e === C._while;
+		this.context.push(t ? B.p_stat : B.p_expr), this.exprAllowed = !0;
+	}, C.incDec.updateContext = function() {}, C._function.updateContext = C._class.updateContext = function(e) {
+		e.beforeExpr && e !== C._else && !(e === C.semi && this.curContext() !== B.p_stat) && !(e === C._return && w.test(this.input.slice(this.lastTokEnd, this.start))) && !((e === C.colon || e === C.braceL) && this.curContext() === B.b_stat) ? this.context.push(B.f_expr) : this.context.push(B.f_stat), this.exprAllowed = !1;
+	}, C.colon.updateContext = function() {
+		this.curContext().token === "function" && this.context.pop(), this.exprAllowed = !0;
+	}, C.backQuote.updateContext = function() {
+		this.curContext() === B.q_tmpl ? this.context.pop() : this.context.push(B.q_tmpl), this.exprAllowed = !1;
+	}, C.star.updateContext = function(e) {
+		if (e === C._function) {
+			var t = this.context.length - 1;
+			this.context[t] === B.f_expr ? this.context[t] = B.f_expr_gen : this.context[t] = B.f_gen;
+		}
+		this.exprAllowed = !0;
+	}, C.name.updateContext = function(e) {
+		var t = !1;
+		this.options.ecmaVersion >= 6 && e !== C.dot && (this.value === "of" && !this.exprAllowed || this.value === "yield" && this.inGeneratorContext()) && (t = !0), this.exprAllowed = t;
+	}, H = N.prototype, H.checkPropClash = function(e, t, n) {
+		if (!(this.options.ecmaVersion >= 9 && e.type === "SpreadElement") && !(this.options.ecmaVersion >= 6 && (e.computed || e.method || e.shorthand))) {
+			var r = e.key, i;
+			switch (r.type) {
+				case "Identifier":
+					i = r.name;
+					break;
+				case "Literal":
+					i = String(r.value);
+					break;
+				default: return;
+			}
+			var a = e.kind;
+			if (this.options.ecmaVersion >= 6) {
+				i === "__proto__" && a === "init" && (t.proto && (n ? n.doubleProto < 0 && (n.doubleProto = r.start) : this.raiseRecoverable(r.start, "Redefinition of __proto__ property")), t.proto = !0);
+				return;
+			}
+			i = "$" + i;
+			var o = t[i];
+			o ? (a === "init" ? this.strict && o.init || o.get || o.set : o.init || o[a]) && this.raiseRecoverable(r.start, "Redefinition of property") : o = t[i] = {
+				init: !1,
+				get: !1,
+				set: !1
+			}, o[a] = !0;
+		}
+	}, H.parseExpression = function(e, t) {
+		var n = this.start, r = this.startLoc, i = this.parseMaybeAssign(e, t);
+		if (this.type === C.comma) {
+			var a = this.startNodeAt(n, r);
+			for (a.expressions = [i]; this.eat(C.comma);) a.expressions.push(this.parseMaybeAssign(e, t));
+			return this.finishNode(a, "SequenceExpression");
+		}
+		return i;
+	}, H.parseMaybeAssign = function(e, t, n) {
+		if (this.isContextual("yield")) {
+			if (this.inGenerator) return this.parseYield(e);
+			this.exprAllowed = !1;
+		}
+		var r = !1, i = -1, a = -1, o = -1;
+		t ? (i = t.parenthesizedAssign, a = t.trailingComma, o = t.doubleProto, t.parenthesizedAssign = t.trailingComma = -1) : (t = new Qt(), r = !0);
+		var s = this.start, c = this.startLoc;
+		(this.type === C.parenL || this.type === C.name) && (this.potentialArrowAt = this.start, this.potentialArrowInForAwait = e === "await");
+		var l = this.parseMaybeConditional(e, t);
+		if (n && (l = n.call(this, l, s, c)), this.type.isAssign) {
+			var u = this.startNodeAt(s, c);
+			return u.operator = this.value, this.type === C.eq && (l = this.toAssignable(l, !1, t)), r || (t.parenthesizedAssign = t.trailingComma = t.doubleProto = -1), t.shorthandAssign >= l.start && (t.shorthandAssign = -1), this.type === C.eq ? this.checkLValPattern(l) : this.checkLValSimple(l), u.left = l, this.next(), u.right = this.parseMaybeAssign(e), o > -1 && (t.doubleProto = o), this.finishNode(u, "AssignmentExpression");
+		} else r && this.checkExpressionErrors(t, !0);
+		return i > -1 && (t.parenthesizedAssign = i), a > -1 && (t.trailingComma = a), l;
+	}, H.parseMaybeConditional = function(e, t) {
+		var n = this.start, r = this.startLoc, i = this.parseExprOps(e, t);
+		if (this.checkExpressionErrors(t)) return i;
+		if (this.eat(C.question)) {
+			var a = this.startNodeAt(n, r);
+			return a.test = i, a.consequent = this.parseMaybeAssign(), this.expect(C.colon), a.alternate = this.parseMaybeAssign(e), this.finishNode(a, "ConditionalExpression");
+		}
+		return i;
+	}, H.parseExprOps = function(e, t) {
+		var n = this.start, r = this.startLoc, i = this.parseMaybeUnary(t, !1, !1, e);
+		return this.checkExpressionErrors(t) || i.start === n && i.type === "ArrowFunctionExpression" ? i : this.parseExprOp(i, n, r, -1, e);
+	}, H.parseExprOp = function(e, t, n, r, i) {
+		var a = this.type.binop;
+		if (a != null && (!i || this.type !== C._in) && a > r) {
+			var o = this.type === C.logicalOR || this.type === C.logicalAND, s = this.type === C.coalesce;
+			s && (a = C.logicalAND.binop);
+			var c = this.value;
+			this.next();
+			var l = this.start, u = this.startLoc, d = this.parseExprOp(this.parseMaybeUnary(null, !1, !1, i), l, u, a, i), f = this.buildBinary(t, n, e, d, c, o || s);
+			return (o && this.type === C.coalesce || s && (this.type === C.logicalOR || this.type === C.logicalAND)) && this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses"), this.parseExprOp(f, t, n, r, i);
+		}
+		return e;
+	}, H.buildBinary = function(e, t, n, r, i, a) {
+		r.type === "PrivateIdentifier" && this.raise(r.start, "Private identifier can only be left side of binary expression");
+		var o = this.startNodeAt(e, t);
+		return o.left = n, o.operator = i, o.right = r, this.finishNode(o, a ? "LogicalExpression" : "BinaryExpression");
+	}, H.parseMaybeUnary = function(e, t, n, r) {
+		var i = this.start, a = this.startLoc, o;
+		if (this.isContextual("await") && this.canAwait) o = this.parseAwait(r), t = !0;
+		else if (this.type.prefix) {
+			var s = this.startNode(), c = this.type === C.incDec;
+			s.operator = this.value, s.prefix = !0, this.next(), s.argument = this.parseMaybeUnary(null, !0, c, r), this.checkExpressionErrors(e, !0), c ? this.checkLValSimple(s.argument) : this.strict && s.operator === "delete" && g(s.argument) ? this.raiseRecoverable(s.start, "Deleting local variable in strict mode") : s.operator === "delete" && _(s.argument) ? this.raiseRecoverable(s.start, "Private fields can not be deleted") : t = !0, o = this.finishNode(s, c ? "UpdateExpression" : "UnaryExpression");
+		} else if (!t && this.type === C.privateId) (r || this.privateNameStack.length === 0) && this.options.checkPrivateFields && this.unexpected(), o = this.parsePrivateIdent(), this.type !== C._in && this.unexpected();
+		else {
+			if (o = this.parseExprSubscripts(e, r), this.checkExpressionErrors(e)) return o;
+			for (; this.type.postfix && !this.canInsertSemicolon();) {
+				var l = this.startNodeAt(i, a);
+				l.operator = this.value, l.prefix = !1, l.argument = o, this.checkLValSimple(o), this.next(), o = this.finishNode(l, "UpdateExpression");
+			}
+		}
+		if (!n && this.eat(C.starstar)) if (t) this.unexpected(this.lastTokStart);
+		else return this.buildBinary(i, a, o, this.parseMaybeUnary(null, !1, !1, r), "**", !1);
+		else return o;
+	}, H.parseExprSubscripts = function(e, t) {
+		var n = this.start, r = this.startLoc, i = this.parseExprAtom(e, t);
+		if (i.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")") return i;
+		var a = this.parseSubscripts(i, n, r, !1, t);
+		return e && a.type === "MemberExpression" && (e.parenthesizedAssign >= a.start && (e.parenthesizedAssign = -1), e.parenthesizedBind >= a.start && (e.parenthesizedBind = -1), e.trailingComma >= a.start && (e.trailingComma = -1)), a;
+	}, H.parseSubscripts = function(e, t, n, r, i) {
+		for (var a = this.options.ecmaVersion >= 8 && e.type === "Identifier" && e.name === "async" && this.lastTokEnd === e.end && !this.canInsertSemicolon() && e.end - e.start === 5 && this.potentialArrowAt === e.start, o = !1;;) {
+			var s = this.parseSubscript(e, t, n, r, a, o, i);
+			if (s.optional && (o = !0), s === e || s.type === "ArrowFunctionExpression") {
+				if (o) {
+					var c = this.startNodeAt(t, n);
+					c.expression = s, s = this.finishNode(c, "ChainExpression");
+				}
+				return s;
+			}
+			e = s;
+		}
+	}, H.shouldParseAsyncArrow = function() {
+		return !this.canInsertSemicolon() && this.eat(C.arrow);
+	}, H.parseSubscriptAsyncArrow = function(e, t, n, r) {
+		return this.parseArrowExpression(this.startNodeAt(e, t), n, !0, r);
+	}, H.parseSubscript = function(e, t, n, r, i, a, o) {
+		var s = this.options.ecmaVersion >= 11, c = s && this.eat(C.questionDot);
+		r && c && this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions");
+		var l = this.eat(C.bracketL);
+		if (l || c && this.type !== C.parenL && this.type !== C.backQuote || this.eat(C.dot)) {
+			var u = this.startNodeAt(t, n);
+			u.object = e, l ? (u.property = this.parseExpression(), this.expect(C.bracketR)) : this.type === C.privateId && e.type !== "Super" ? u.property = this.parsePrivateIdent() : u.property = this.parseIdent(this.options.allowReserved !== "never"), u.computed = !!l, s && (u.optional = c), e = this.finishNode(u, "MemberExpression");
+		} else if (!r && this.eat(C.parenL)) {
+			var d = new Qt(), f = this.yieldPos, p = this.awaitPos, m = this.awaitIdentPos;
+			this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0;
+			var h = this.parseExprList(C.parenR, this.options.ecmaVersion >= 8, !1, d);
+			if (i && !c && this.shouldParseAsyncArrow()) return this.checkPatternErrors(d, !1), this.checkYieldAwaitInDefaultParams(), this.awaitIdentPos > 0 && this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"), this.yieldPos = f, this.awaitPos = p, this.awaitIdentPos = m, this.parseSubscriptAsyncArrow(t, n, h, o);
+			this.checkExpressionErrors(d, !0), this.yieldPos = f || this.yieldPos, this.awaitPos = p || this.awaitPos, this.awaitIdentPos = m || this.awaitIdentPos;
+			var g = this.startNodeAt(t, n);
+			g.callee = e, g.arguments = h, s && (g.optional = c), e = this.finishNode(g, "CallExpression");
+		} else if (this.type === C.backQuote) {
+			(c || a) && this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
+			var _ = this.startNodeAt(t, n);
+			_.tag = e, _.quasi = this.parseTemplate({ isTagged: !0 }), e = this.finishNode(_, "TaggedTemplateExpression");
+		}
+		return e;
+	}, H.parseExprAtom = function(e, t, n) {
+		this.type === C.slash && this.readRegexp();
+		var r, i = this.potentialArrowAt === this.start;
+		switch (this.type) {
+			case C._super: return this.allowSuper || this.raise(this.start, "'super' keyword outside a method"), r = this.startNode(), this.next(), this.type === C.parenL && !this.allowDirectSuper && this.raise(r.start, "super() call outside constructor of a subclass"), this.type !== C.dot && this.type !== C.bracketL && this.type !== C.parenL && this.unexpected(), this.finishNode(r, "Super");
+			case C._this: return r = this.startNode(), this.next(), this.finishNode(r, "ThisExpression");
+			case C.name:
+				var a = this.start, o = this.startLoc, s = this.containsEsc, c = this.parseIdent(!1);
+				if (this.options.ecmaVersion >= 8 && !s && c.name === "async" && !this.canInsertSemicolon() && this.eat(C._function)) return this.overrideContext(B.f_expr), this.parseFunction(this.startNodeAt(a, o), 0, !1, !0, t);
+				if (i && !this.canInsertSemicolon()) {
+					if (this.eat(C.arrow)) return this.parseArrowExpression(this.startNodeAt(a, o), [c], !1, t);
+					if (this.options.ecmaVersion >= 8 && c.name === "async" && this.type === C.name && !s && (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) return c = this.parseIdent(!1), (this.canInsertSemicolon() || !this.eat(C.arrow)) && this.unexpected(), this.parseArrowExpression(this.startNodeAt(a, o), [c], !0, t);
+				}
+				return c;
+			case C.regexp:
+				var l = this.value;
+				return r = this.parseLiteral(l.value), r.regex = {
+					pattern: l.pattern,
+					flags: l.flags
+				}, r;
+			case C.num:
+			case C.string: return this.parseLiteral(this.value);
+			case C._null:
+			case C._true:
+			case C._false: return r = this.startNode(), r.value = this.type === C._null ? null : this.type === C._true, r.raw = this.type.keyword, this.next(), this.finishNode(r, "Literal");
+			case C.parenL:
+				var u = this.start, d = this.parseParenAndDistinguishExpression(i, t);
+				return e && (e.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(d) && (e.parenthesizedAssign = u), e.parenthesizedBind < 0 && (e.parenthesizedBind = u)), d;
+			case C.bracketL: return r = this.startNode(), this.next(), r.elements = this.parseExprList(C.bracketR, !0, !0, e), this.finishNode(r, "ArrayExpression");
+			case C.braceL: return this.overrideContext(B.b_expr), this.parseObj(!1, e);
+			case C._function: return r = this.startNode(), this.next(), this.parseFunction(r, 0);
+			case C._class: return this.parseClass(this.startNode(), !1);
+			case C._new: return this.parseNew();
+			case C.backQuote: return this.parseTemplate();
+			case C._import: return this.options.ecmaVersion >= 11 ? this.parseExprImport(n) : this.unexpected();
+			default: return this.parseExprAtomDefault();
+		}
+	}, H.parseExprAtomDefault = function() {
+		this.unexpected();
+	}, H.parseExprImport = function(e) {
+		var t = this.startNode();
+		if (this.containsEsc && this.raiseRecoverable(this.start, "Escape sequence in keyword import"), this.next(), this.type === C.parenL && !e) return this.parseDynamicImport(t);
+		if (this.type === C.dot) {
+			var n = this.startNodeAt(t.start, t.loc && t.loc.start);
+			return n.name = "import", t.meta = this.finishNode(n, "Identifier"), this.parseImportMeta(t);
+		} else this.unexpected();
+	}, H.parseDynamicImport = function(e) {
+		if (this.next(), e.source = this.parseMaybeAssign(), this.options.ecmaVersion >= 16) this.eat(C.parenR) ? e.options = null : (this.expect(C.comma), this.afterTrailingComma(C.parenR) ? e.options = null : (e.options = this.parseMaybeAssign(), this.eat(C.parenR) || (this.expect(C.comma), this.afterTrailingComma(C.parenR) || this.unexpected())));
+		else if (!this.eat(C.parenR)) {
+			var t = this.start;
+			this.eat(C.comma) && this.eat(C.parenR) ? this.raiseRecoverable(t, "Trailing comma is not allowed in import()") : this.unexpected(t);
+		}
+		return this.finishNode(e, "ImportExpression");
+	}, H.parseImportMeta = function(e) {
+		this.next();
+		var t = this.containsEsc;
+		return e.property = this.parseIdent(!0), e.property.name !== "meta" && this.raiseRecoverable(e.property.start, "The only valid meta property for import is 'import.meta'"), t && this.raiseRecoverable(e.start, "'import.meta' must not contain escaped characters"), this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere && this.raiseRecoverable(e.start, "Cannot use 'import.meta' outside a module"), this.finishNode(e, "MetaProperty");
+	}, H.parseLiteral = function(e) {
+		var t = this.startNode();
+		return t.value = e, t.raw = this.input.slice(this.start, this.end), t.raw.charCodeAt(t.raw.length - 1) === 110 && (t.bigint = t.value == null ? t.raw.slice(0, -1).replace(/_/g, "") : t.value.toString()), this.next(), this.finishNode(t, "Literal");
+	}, H.parseParenExpression = function() {
+		this.expect(C.parenL);
+		var e = this.parseExpression();
+		return this.expect(C.parenR), e;
+	}, H.shouldParseArrow = function(e) {
+		return !this.canInsertSemicolon();
+	}, H.parseParenAndDistinguishExpression = function(e, t) {
+		var n = this.start, r = this.startLoc, i, a = this.options.ecmaVersion >= 8;
+		if (this.options.ecmaVersion >= 6) {
+			this.next();
+			var o = this.start, s = this.startLoc, c = [], l = !0, u = !1, d = new Qt(), f = this.yieldPos, p = this.awaitPos, m;
+			for (this.yieldPos = 0, this.awaitPos = 0; this.type !== C.parenR;) if (l ? l = !1 : this.expect(C.comma), a && this.afterTrailingComma(C.parenR, !0)) {
+				u = !0;
+				break;
+			} else if (this.type === C.ellipsis) {
+				m = this.start, c.push(this.parseParenItem(this.parseRestBinding())), this.type === C.comma && this.raiseRecoverable(this.start, "Comma is not permitted after the rest element");
+				break;
+			} else c.push(this.parseMaybeAssign(!1, d, this.parseParenItem));
+			var h = this.lastTokEnd, g = this.lastTokEndLoc;
+			if (this.expect(C.parenR), e && this.shouldParseArrow(c) && this.eat(C.arrow)) return this.checkPatternErrors(d, !1), this.checkYieldAwaitInDefaultParams(), this.yieldPos = f, this.awaitPos = p, this.parseParenArrowList(n, r, c, t);
+			(!c.length || u) && this.unexpected(this.lastTokStart), m && this.unexpected(m), this.checkExpressionErrors(d, !0), this.yieldPos = f || this.yieldPos, this.awaitPos = p || this.awaitPos, c.length > 1 ? (i = this.startNodeAt(o, s), i.expressions = c, this.finishNodeAt(i, "SequenceExpression", h, g)) : i = c[0];
+		} else i = this.parseParenExpression();
+		if (this.options.preserveParens) {
+			var _ = this.startNodeAt(n, r);
+			return _.expression = i, this.finishNode(_, "ParenthesizedExpression");
+		} else return i;
+	}, H.parseParenItem = function(e) {
+		return e;
+	}, H.parseParenArrowList = function(e, t, n, r) {
+		return this.parseArrowExpression(this.startNodeAt(e, t), n, !1, r);
+	}, an = [], H.parseNew = function() {
+		this.containsEsc && this.raiseRecoverable(this.start, "Escape sequence in keyword new");
+		var e = this.startNode();
+		if (this.next(), this.options.ecmaVersion >= 6 && this.type === C.dot) {
+			var t = this.startNodeAt(e.start, e.loc && e.loc.start);
+			t.name = "new", e.meta = this.finishNode(t, "Identifier"), this.next();
+			var n = this.containsEsc;
+			return e.property = this.parseIdent(!0), e.property.name !== "target" && this.raiseRecoverable(e.property.start, "The only valid meta property for new is 'new.target'"), n && this.raiseRecoverable(e.start, "'new.target' must not contain escaped characters"), this.allowNewDotTarget || this.raiseRecoverable(e.start, "'new.target' can only be used in functions and class static block"), this.finishNode(e, "MetaProperty");
+		}
+		var r = this.start, i = this.startLoc;
+		return e.callee = this.parseSubscripts(this.parseExprAtom(null, !1, !0), r, i, !0, !1), this.eat(C.parenL) ? e.arguments = this.parseExprList(C.parenR, this.options.ecmaVersion >= 8, !1) : e.arguments = an, this.finishNode(e, "NewExpression");
+	}, H.parseTemplateElement = function(e) {
+		var t = e.isTagged, n = this.startNode();
+		return this.type === C.invalidTemplate ? (t || this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal"), n.value = {
+			raw: this.value.replace(/\r\n?/g, "\n"),
+			cooked: null
+		}) : n.value = {
+			raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
+			cooked: this.value
+		}, this.next(), n.tail = this.type === C.backQuote, this.finishNode(n, "TemplateElement");
+	}, H.parseTemplate = function(e) {
+		e === void 0 && (e = {});
+		var t = e.isTagged;
+		t === void 0 && (t = !1);
+		var n = this.startNode();
+		this.next(), n.expressions = [];
+		var r = this.parseTemplateElement({ isTagged: t });
+		for (n.quasis = [r]; !r.tail;) this.type === C.eof && this.raise(this.pos, "Unterminated template literal"), this.expect(C.dollarBraceL), n.expressions.push(this.parseExpression()), this.expect(C.braceR), n.quasis.push(r = this.parseTemplateElement({ isTagged: t }));
+		return this.next(), this.finishNode(n, "TemplateLiteral");
+	}, H.isAsyncProp = function(e) {
+		return !e.computed && e.key.type === "Identifier" && e.key.name === "async" && (this.type === C.name || this.type === C.num || this.type === C.string || this.type === C.bracketL || this.type.keyword || this.options.ecmaVersion >= 9 && this.type === C.star) && !w.test(this.input.slice(this.lastTokEnd, this.start));
+	}, H.parseObj = function(e, t) {
+		var n = this.startNode(), r = !0, i = {};
+		for (n.properties = [], this.next(); !this.eat(C.braceR);) {
+			if (r) r = !1;
+			else if (this.expect(C.comma), this.options.ecmaVersion >= 5 && this.afterTrailingComma(C.braceR)) break;
+			var a = this.parseProperty(e, t);
+			e || this.checkPropClash(a, i, t), n.properties.push(a);
+		}
+		return this.finishNode(n, e ? "ObjectPattern" : "ObjectExpression");
+	}, H.parseProperty = function(e, t) {
+		var n = this.startNode(), r, i, a, o;
+		if (this.options.ecmaVersion >= 9 && this.eat(C.ellipsis)) return e ? (n.argument = this.parseIdent(!1), this.type === C.comma && this.raiseRecoverable(this.start, "Comma is not permitted after the rest element"), this.finishNode(n, "RestElement")) : (n.argument = this.parseMaybeAssign(!1, t), this.type === C.comma && t && t.trailingComma < 0 && (t.trailingComma = this.start), this.finishNode(n, "SpreadElement"));
+		this.options.ecmaVersion >= 6 && (n.method = !1, n.shorthand = !1, (e || t) && (a = this.start, o = this.startLoc), e || (r = this.eat(C.star)));
+		var s = this.containsEsc;
+		return this.parsePropertyName(n), !e && !s && this.options.ecmaVersion >= 8 && !r && this.isAsyncProp(n) ? (i = !0, r = this.options.ecmaVersion >= 9 && this.eat(C.star), this.parsePropertyName(n)) : i = !1, this.parsePropertyValue(n, e, r, i, a, o, t, s), this.finishNode(n, "Property");
+	}, H.parseGetterSetter = function(e) {
+		var t = e.key.name;
+		this.parsePropertyName(e), e.value = this.parseMethod(!1), e.kind = t;
+		var n = e.kind === "get" ? 0 : 1;
+		if (e.value.params.length !== n) {
+			var r = e.value.start;
+			e.kind === "get" ? this.raiseRecoverable(r, "getter should have no params") : this.raiseRecoverable(r, "setter should have exactly one param");
+		} else e.kind === "set" && e.value.params[0].type === "RestElement" && this.raiseRecoverable(e.value.params[0].start, "Setter cannot use rest params");
+	}, H.parsePropertyValue = function(e, t, n, r, i, a, o, s) {
+		(n || r) && this.type === C.colon && this.unexpected(), this.eat(C.colon) ? (e.value = t ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(!1, o), e.kind = "init") : this.options.ecmaVersion >= 6 && this.type === C.parenL ? (t && this.unexpected(), e.method = !0, e.value = this.parseMethod(n, r), e.kind = "init") : !t && !s && this.options.ecmaVersion >= 5 && !e.computed && e.key.type === "Identifier" && (e.key.name === "get" || e.key.name === "set") && this.type !== C.comma && this.type !== C.braceR && this.type !== C.eq ? ((n || r) && this.unexpected(), this.parseGetterSetter(e)) : this.options.ecmaVersion >= 6 && !e.computed && e.key.type === "Identifier" ? ((n || r) && this.unexpected(), this.checkUnreserved(e.key), e.key.name === "await" && !this.awaitIdentPos && (this.awaitIdentPos = i), t ? e.value = this.parseMaybeDefault(i, a, this.copyNode(e.key)) : this.type === C.eq && o ? (o.shorthandAssign < 0 && (o.shorthandAssign = this.start), e.value = this.parseMaybeDefault(i, a, this.copyNode(e.key))) : e.value = this.copyNode(e.key), e.kind = "init", e.shorthand = !0) : this.unexpected();
+	}, H.parsePropertyName = function(e) {
+		if (this.options.ecmaVersion >= 6) {
+			if (this.eat(C.bracketL)) return e.computed = !0, e.key = this.parseMaybeAssign(), this.expect(C.bracketR), e.key;
+			e.computed = !1;
+		}
+		return e.key = this.type === C.num || this.type === C.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never");
+	}, H.initFunction = function(e) {
+		e.id = null, this.options.ecmaVersion >= 6 && (e.generator = e.expression = !1), this.options.ecmaVersion >= 8 && (e.async = !1);
+	}, H.parseMethod = function(e, t, n) {
+		var r = this.startNode(), i = this.yieldPos, a = this.awaitPos, o = this.awaitIdentPos;
+		return this.initFunction(r), this.options.ecmaVersion >= 6 && (r.generator = e), this.options.ecmaVersion >= 8 && (r.async = !!t), this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.enterScope(p(t, r.generator) | Ut | (n ? Wt : 0)), this.expect(C.parenL), r.params = this.parseBindingList(C.parenR, !1, this.options.ecmaVersion >= 8), this.checkYieldAwaitInDefaultParams(), this.parseFunctionBody(r, !1, !0, !1), this.yieldPos = i, this.awaitPos = a, this.awaitIdentPos = o, this.finishNode(r, "FunctionExpression");
+	}, H.parseArrowExpression = function(e, t, n, r) {
+		var i = this.yieldPos, a = this.awaitPos, o = this.awaitIdentPos;
+		return this.enterScope(p(n, !1) | Vt), this.initFunction(e), this.options.ecmaVersion >= 8 && (e.async = !!n), this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, e.params = this.toAssignableList(t, !0), this.parseFunctionBody(e, !0, !1, r), this.yieldPos = i, this.awaitPos = a, this.awaitIdentPos = o, this.finishNode(e, "ArrowFunctionExpression");
+	}, H.parseFunctionBody = function(e, t, n, r) {
+		var i = t && this.type !== C.braceL, a = this.strict, o = !1;
+		if (i) e.body = this.parseMaybeAssign(r), e.expression = !0, this.checkParams(e, !1);
+		else {
+			var s = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(e.params);
+			(!a || s) && (o = this.strictDirective(this.end), o && s && this.raiseRecoverable(e.start, "Illegal 'use strict' directive in function with non-simple parameter list"));
+			var c = this.labels;
+			this.labels = [], o && (this.strict = !0), this.checkParams(e, !a && !o && !t && !n && this.isSimpleParamList(e.params)), this.strict && e.id && this.checkLValSimple(e.id, Xt), e.body = this.parseBlock(!1, void 0, o && !a), e.expression = !1, this.adaptDirectivePrologue(e.body.body), this.labels = c;
+		}
+		this.exitScope();
+	}, H.isSimpleParamList = function(e) {
+		for (var t = 0, n = e; t < n.length; t += 1) if (n[t].type !== "Identifier") return !1;
+		return !0;
+	}, H.checkParams = function(e, t) {
+		for (var n = Object.create(null), r = 0, i = e.params; r < i.length; r += 1) {
+			var a = i[r];
+			this.checkLValInnerPattern(a, qt, t ? null : n);
+		}
+	}, H.parseExprList = function(e, t, n, r) {
+		for (var i = [], a = !0; !this.eat(e);) {
+			if (a) a = !1;
+			else if (this.expect(C.comma), t && this.afterTrailingComma(e)) break;
+			var o = void 0;
+			n && this.type === C.comma ? o = null : this.type === C.ellipsis ? (o = this.parseSpread(r), r && this.type === C.comma && r.trailingComma < 0 && (r.trailingComma = this.start)) : o = this.parseMaybeAssign(!1, r), i.push(o);
+		}
+		return i;
+	}, H.checkUnreserved = function(e) {
+		var t = e.start, n = e.end, r = e.name;
+		this.inGenerator && r === "yield" && this.raiseRecoverable(t, "Cannot use 'yield' as identifier inside a generator"), this.inAsync && r === "await" && this.raiseRecoverable(t, "Cannot use 'await' as identifier inside an async function"), !(this.currentThisScope().flags & Gt) && r === "arguments" && this.raiseRecoverable(t, "Cannot use 'arguments' in class field initializer"), this.inClassStaticBlock && (r === "arguments" || r === "await") && this.raise(t, "Cannot use " + r + " in class static initialization block"), this.keywords.test(r) && this.raise(t, "Unexpected keyword '" + r + "'"), !(this.options.ecmaVersion < 6 && this.input.slice(t, n).indexOf("\\") !== -1) && (this.strict ? this.reservedWordsStrict : this.reservedWords).test(r) && (!this.inAsync && r === "await" && this.raiseRecoverable(t, "Cannot use keyword 'await' outside an async function"), this.raiseRecoverable(t, "The keyword '" + r + "' is reserved"));
+	}, H.parseIdent = function(e) {
+		var t = this.parseIdentNode();
+		return this.next(!!e), this.finishNode(t, "Identifier"), e || (this.checkUnreserved(t), t.name === "await" && !this.awaitIdentPos && (this.awaitIdentPos = t.start)), t;
+	}, H.parseIdentNode = function() {
+		var e = this.startNode();
+		return this.type === C.name ? e.name = this.value : this.type.keyword ? (e.name = this.type.keyword, (e.name === "class" || e.name === "function") && (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46) && this.context.pop(), this.type = C.name) : this.unexpected(), e;
+	}, H.parsePrivateIdent = function() {
+		var e = this.startNode();
+		return this.type === C.privateId ? e.name = this.value : this.unexpected(), this.next(), this.finishNode(e, "PrivateIdentifier"), this.options.checkPrivateFields && (this.privateNameStack.length === 0 ? this.raise(e.start, "Private field '#" + e.name + "' must be declared in an enclosing class") : this.privateNameStack[this.privateNameStack.length - 1].used.push(e)), e;
+	}, H.parseYield = function(e) {
+		this.yieldPos ||= this.start;
+		var t = this.startNode();
+		return this.next(), this.type === C.semi || this.canInsertSemicolon() || this.type !== C.star && !this.type.startsExpr ? (t.delegate = !1, t.argument = null) : (t.delegate = this.eat(C.star), t.argument = this.parseMaybeAssign(e)), this.finishNode(t, "YieldExpression");
+	}, H.parseAwait = function(e) {
+		this.awaitPos ||= this.start;
+		var t = this.startNode();
+		return this.next(), t.argument = this.parseMaybeUnary(null, !0, !1, e), this.finishNode(t, "AwaitExpression");
+	}, on = N.prototype, on.raise = function(e, t) {
+		var n = u(this.input, e);
+		t += " (" + n.line + ":" + n.column + ")", this.sourceFile && (t += " in " + this.sourceFile);
+		var r = SyntaxError(t);
+		throw r.pos = e, r.loc = n, r.raisedAt = this.pos, r;
+	}, on.raiseRecoverable = on.raise, on.curPosition = function() {
+		if (this.options.locations) return new D(this.curLine, this.pos - this.lineStart);
+	}, U = N.prototype, sn = function(e) {
+		this.flags = e, this.var = [], this.lexical = [], this.functions = [];
+	}, U.enterScope = function(e) {
+		this.scopeStack.push(new sn(e));
+	}, U.exitScope = function() {
+		this.scopeStack.pop();
+	}, U.treatFunctionsAsVarInScope = function(e) {
+		return e.flags & k || !this.inModule && e.flags & O;
+	}, U.declareName = function(e, t, n) {
+		var r = !1;
+		if (t === M) {
+			var i = this.currentScope();
+			r = i.lexical.indexOf(e) > -1 || i.functions.indexOf(e) > -1 || i.var.indexOf(e) > -1, i.lexical.push(e), this.inModule && i.flags & O && delete this.undefinedExports[e];
+		} else if (t === Yt) this.currentScope().lexical.push(e);
+		else if (t === Jt) {
+			var a = this.currentScope();
+			r = this.treatFunctionsAsVar ? a.lexical.indexOf(e) > -1 : a.lexical.indexOf(e) > -1 || a.var.indexOf(e) > -1, a.functions.push(e);
+		} else for (var o = this.scopeStack.length - 1; o >= 0; --o) {
+			var s = this.scopeStack[o];
+			if (s.lexical.indexOf(e) > -1 && !(s.flags & Ht && s.lexical[0] === e) || !this.treatFunctionsAsVarInScope(s) && s.functions.indexOf(e) > -1) {
+				r = !0;
+				break;
+			}
+			if (s.var.push(e), this.inModule && s.flags & O && delete this.undefinedExports[e], s.flags & Gt) break;
+		}
+		r && this.raiseRecoverable(n, "Identifier '" + e + "' has already been declared");
+	}, U.checkLocalExport = function(e) {
+		this.scopeStack[0].lexical.indexOf(e.name) === -1 && this.scopeStack[0].var.indexOf(e.name) === -1 && (this.undefinedExports[e.name] = e);
+	}, U.currentScope = function() {
+		return this.scopeStack[this.scopeStack.length - 1];
+	}, U.currentVarScope = function() {
+		for (var e = this.scopeStack.length - 1;; e--) {
+			var t = this.scopeStack[e];
+			if (t.flags & (Gt | j | A)) return t;
+		}
+	}, U.currentThisScope = function() {
+		for (var e = this.scopeStack.length - 1;; e--) {
+			var t = this.scopeStack[e];
+			if (t.flags & (Gt | j | A) && !(t.flags & Vt)) return t;
+		}
+	}, cn = function(e, t, n) {
+		this.type = "", this.start = t, this.end = 0, e.options.locations && (this.loc = new It(e, n)), e.options.directSourceFile && (this.sourceFile = e.options.directSourceFile), e.options.ranges && (this.range = [t, 0]);
+	}, W = N.prototype, W.startNode = function() {
+		return new cn(this, this.start, this.startLoc);
+	}, W.startNodeAt = function(e, t) {
+		return new cn(this, e, t);
+	}, W.finishNode = function(e, t) {
+		return ee.call(this, e, t, this.lastTokEnd, this.lastTokEndLoc);
+	}, W.finishNodeAt = function(e, t, n, r) {
+		return ee.call(this, e, t, n, r);
+	}, W.copyNode = function(e) {
+		var t = new cn(this, e.start, this.startLoc);
+		for (var n in e) t[n] = e[n];
+		return t;
+	}, ln = "Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sunu Sunuwar Todhri Todr Tulu_Tigalari Tutg Unknown Zzzz", un = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS", dn = un + " Extended_Pictographic", fn = dn, pn = fn + " EBase EComp EMod EPres ExtPict", mn = pn, hn = mn, gn = {
+		9: un,
+		10: dn,
+		11: fn,
+		12: pn,
+		13: mn,
+		14: hn
+	}, _n = "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Flag_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence RGI_Emoji", vn = {
+		9: "",
+		10: "",
+		11: "",
+		12: "",
+		13: "",
+		14: _n
+	}, yn = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu", bn = "Adlam Adlm Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb", xn = bn + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd", Sn = xn + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho", Cn = Sn + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", wn = Cn + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith", Tn = wn + " " + ln, En = {
+		9: bn,
+		10: xn,
+		11: Sn,
+		12: Cn,
+		13: wn,
+		14: Tn
+	}, Dn = {}, kn = 0, An = [
+		9,
+		10,
+		11,
+		12,
+		13,
+		14
+	]; kn < An.length; kn += 1) On = An[kn], te(On);
+	G = N.prototype, jn = function(e, t) {
+		this.parent = e, this.base = t || this;
+	}, jn.prototype.separatedFrom = function(e) {
+		for (var t = this; t; t = t.parent) for (var n = e; n; n = n.parent) if (t.base === n.base && t !== n) return !0;
+		return !1;
+	}, jn.prototype.sibling = function() {
+		return new jn(this.parent, this.base);
+	}, K = function(e) {
+		this.parser = e, this.validFlags = "gim" + (e.options.ecmaVersion >= 6 ? "uy" : "") + (e.options.ecmaVersion >= 9 ? "s" : "") + (e.options.ecmaVersion >= 13 ? "d" : "") + (e.options.ecmaVersion >= 15 ? "v" : ""), this.unicodeProperties = Dn[e.options.ecmaVersion >= 14 ? 14 : e.options.ecmaVersion], this.source = "", this.flags = "", this.start = 0, this.switchU = !1, this.switchV = !1, this.switchN = !1, this.pos = 0, this.lastIntValue = 0, this.lastStringValue = "", this.lastAssertionIsQuantifiable = !1, this.numCapturingParens = 0, this.maxBackReference = 0, this.groupNames = Object.create(null), this.backReferenceNames = [], this.branchID = null;
+	}, K.prototype.reset = function(e, t, n) {
+		var r = n.indexOf("v") !== -1, i = n.indexOf("u") !== -1;
+		this.start = e | 0, this.source = t + "", this.flags = n, r && this.parser.options.ecmaVersion >= 15 ? (this.switchU = !0, this.switchV = !0, this.switchN = !0) : (this.switchU = i && this.parser.options.ecmaVersion >= 6, this.switchV = !1, this.switchN = i && this.parser.options.ecmaVersion >= 9);
+	}, K.prototype.raise = function(e) {
+		this.parser.raiseRecoverable(this.start, "Invalid regular expression: /" + this.source + "/: " + e);
+	}, K.prototype.at = function(e, t) {
+		t === void 0 && (t = !1);
+		var n = this.source, r = n.length;
+		if (e >= r) return -1;
+		var i = n.charCodeAt(e);
+		if (!(t || this.switchU) || i <= 55295 || i >= 57344 || e + 1 >= r) return i;
+		var a = n.charCodeAt(e + 1);
+		return a >= 56320 && a <= 57343 ? (i << 10) + a - 56613888 : i;
+	}, K.prototype.nextIndex = function(e, t) {
+		t === void 0 && (t = !1);
+		var n = this.source, r = n.length;
+		if (e >= r) return r;
+		var i = n.charCodeAt(e), a;
+		return !(t || this.switchU) || i <= 55295 || i >= 57344 || e + 1 >= r || (a = n.charCodeAt(e + 1)) < 56320 || a > 57343 ? e + 1 : e + 2;
+	}, K.prototype.current = function(e) {
+		return e === void 0 && (e = !1), this.at(this.pos, e);
+	}, K.prototype.lookahead = function(e) {
+		return e === void 0 && (e = !1), this.at(this.nextIndex(this.pos, e), e);
+	}, K.prototype.advance = function(e) {
+		e === void 0 && (e = !1), this.pos = this.nextIndex(this.pos, e);
+	}, K.prototype.eat = function(e, t) {
+		return t === void 0 && (t = !1), this.current(t) === e ? (this.advance(t), !0) : !1;
+	}, K.prototype.eatChars = function(e, t) {
+		t === void 0 && (t = !1);
+		for (var n = this.pos, r = 0, i = e; r < i.length; r += 1) {
+			var a = i[r], o = this.at(n, t);
+			if (o === -1 || o !== a) return !1;
+			n = this.nextIndex(n, t);
+		}
+		return this.pos = n, !0;
+	}, G.validateRegExpFlags = function(e) {
+		for (var t = e.validFlags, n = e.flags, r = !1, i = !1, a = 0; a < n.length; a++) {
+			var o = n.charAt(a);
+			t.indexOf(o) === -1 && this.raise(e.start, "Invalid regular expression flag"), n.indexOf(o, a + 1) > -1 && this.raise(e.start, "Duplicate regular expression flag"), o === "u" && (r = !0), o === "v" && (i = !0);
+		}
+		this.options.ecmaVersion >= 15 && r && i && this.raise(e.start, "Invalid regular expression flag");
+	}, G.validateRegExpPattern = function(e) {
+		this.regexp_pattern(e), !e.switchN && this.options.ecmaVersion >= 9 && ne(e.groupNames) && (e.switchN = !0, this.regexp_pattern(e));
+	}, G.regexp_pattern = function(e) {
+		e.pos = 0, e.lastIntValue = 0, e.lastStringValue = "", e.lastAssertionIsQuantifiable = !1, e.numCapturingParens = 0, e.maxBackReference = 0, e.groupNames = Object.create(null), e.backReferenceNames.length = 0, e.branchID = null, this.regexp_disjunction(e), e.pos !== e.source.length && (e.eat(41) && e.raise("Unmatched ')'"), (e.eat(93) || e.eat(125)) && e.raise("Lone quantifier brackets")), e.maxBackReference > e.numCapturingParens && e.raise("Invalid escape");
+		for (var t = 0, n = e.backReferenceNames; t < n.length; t += 1) {
+			var r = n[t];
+			e.groupNames[r] || e.raise("Invalid named capture referenced");
+		}
+	}, G.regexp_disjunction = function(e) {
+		var t = this.options.ecmaVersion >= 16;
+		for (t && (e.branchID = new jn(e.branchID, null)), this.regexp_alternative(e); e.eat(124);) t && (e.branchID = e.branchID.sibling()), this.regexp_alternative(e);
+		t && (e.branchID = e.branchID.parent), this.regexp_eatQuantifier(e, !0) && e.raise("Nothing to repeat"), e.eat(123) && e.raise("Lone quantifier brackets");
+	}, G.regexp_alternative = function(e) {
+		for (; e.pos < e.source.length && this.regexp_eatTerm(e););
+	}, G.regexp_eatTerm = function(e) {
+		return this.regexp_eatAssertion(e) ? (e.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(e) && e.switchU && e.raise("Invalid quantifier"), !0) : (e.switchU ? this.regexp_eatAtom(e) : this.regexp_eatExtendedAtom(e)) ? (this.regexp_eatQuantifier(e), !0) : !1;
+	}, G.regexp_eatAssertion = function(e) {
+		var t = e.pos;
+		if (e.lastAssertionIsQuantifiable = !1, e.eat(94) || e.eat(36)) return !0;
+		if (e.eat(92)) {
+			if (e.eat(66) || e.eat(98)) return !0;
+			e.pos = t;
+		}
+		if (e.eat(40) && e.eat(63)) {
+			var n = !1;
+			if (this.options.ecmaVersion >= 9 && (n = e.eat(60)), e.eat(61) || e.eat(33)) return this.regexp_disjunction(e), e.eat(41) || e.raise("Unterminated group"), e.lastAssertionIsQuantifiable = !n, !0;
+		}
+		return e.pos = t, !1;
+	}, G.regexp_eatQuantifier = function(e, t) {
+		return t === void 0 && (t = !1), this.regexp_eatQuantifierPrefix(e, t) ? (e.eat(63), !0) : !1;
+	}, G.regexp_eatQuantifierPrefix = function(e, t) {
+		return e.eat(42) || e.eat(43) || e.eat(63) || this.regexp_eatBracedQuantifier(e, t);
+	}, G.regexp_eatBracedQuantifier = function(e, t) {
+		var n = e.pos;
+		if (e.eat(123)) {
+			var r = 0, i = -1;
+			if (this.regexp_eatDecimalDigits(e) && (r = e.lastIntValue, e.eat(44) && this.regexp_eatDecimalDigits(e) && (i = e.lastIntValue), e.eat(125))) return i !== -1 && i < r && !t && e.raise("numbers out of order in {} quantifier"), !0;
+			e.switchU && !t && e.raise("Incomplete quantifier"), e.pos = n;
+		}
+		return !1;
+	}, G.regexp_eatAtom = function(e) {
+		return this.regexp_eatPatternCharacters(e) || e.eat(46) || this.regexp_eatReverseSolidusAtomEscape(e) || this.regexp_eatCharacterClass(e) || this.regexp_eatUncapturingGroup(e) || this.regexp_eatCapturingGroup(e);
+	}, G.regexp_eatReverseSolidusAtomEscape = function(e) {
+		var t = e.pos;
+		if (e.eat(92)) {
+			if (this.regexp_eatAtomEscape(e)) return !0;
+			e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatUncapturingGroup = function(e) {
+		var t = e.pos;
+		if (e.eat(40)) {
+			if (e.eat(63)) {
+				if (this.options.ecmaVersion >= 16) {
+					var n = this.regexp_eatModifiers(e), r = e.eat(45);
+					if (n || r) {
+						for (var i = 0; i < n.length; i++) {
+							var a = n.charAt(i);
+							n.indexOf(a, i + 1) > -1 && e.raise("Duplicate regular expression modifiers");
+						}
+						if (r) {
+							var o = this.regexp_eatModifiers(e);
+							!n && !o && e.current() === 58 && e.raise("Invalid regular expression modifiers");
+							for (var s = 0; s < o.length; s++) {
+								var c = o.charAt(s);
+								(o.indexOf(c, s + 1) > -1 || n.indexOf(c) > -1) && e.raise("Duplicate regular expression modifiers");
+							}
+						}
+					}
+				}
+				if (e.eat(58)) {
+					if (this.regexp_disjunction(e), e.eat(41)) return !0;
+					e.raise("Unterminated group");
+				}
+			}
+			e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatCapturingGroup = function(e) {
+		if (e.eat(40)) {
+			if (this.options.ecmaVersion >= 9 ? this.regexp_groupSpecifier(e) : e.current() === 63 && e.raise("Invalid group"), this.regexp_disjunction(e), e.eat(41)) return e.numCapturingParens += 1, !0;
+			e.raise("Unterminated group");
+		}
+		return !1;
+	}, G.regexp_eatModifiers = function(e) {
+		for (var t = "", n = 0; (n = e.current()) !== -1 && re(n);) t += l(n), e.advance();
+		return t;
+	}, G.regexp_eatExtendedAtom = function(e) {
+		return e.eat(46) || this.regexp_eatReverseSolidusAtomEscape(e) || this.regexp_eatCharacterClass(e) || this.regexp_eatUncapturingGroup(e) || this.regexp_eatCapturingGroup(e) || this.regexp_eatInvalidBracedQuantifier(e) || this.regexp_eatExtendedPatternCharacter(e);
+	}, G.regexp_eatInvalidBracedQuantifier = function(e) {
+		return this.regexp_eatBracedQuantifier(e, !0) && e.raise("Nothing to repeat"), !1;
+	}, G.regexp_eatSyntaxCharacter = function(e) {
+		var t = e.current();
+		return ie(t) ? (e.lastIntValue = t, e.advance(), !0) : !1;
+	}, G.regexp_eatPatternCharacters = function(e) {
+		for (var t = e.pos, n = 0; (n = e.current()) !== -1 && !ie(n);) e.advance();
+		return e.pos !== t;
+	}, G.regexp_eatExtendedPatternCharacter = function(e) {
+		var t = e.current();
+		return t !== -1 && t !== 36 && !(t >= 40 && t <= 43) && t !== 46 && t !== 63 && t !== 91 && t !== 94 && t !== 124 ? (e.advance(), !0) : !1;
+	}, G.regexp_groupSpecifier = function(e) {
+		if (e.eat(63)) {
+			this.regexp_eatGroupName(e) || e.raise("Invalid group");
+			var t = this.options.ecmaVersion >= 16, n = e.groupNames[e.lastStringValue];
+			if (n) if (t) for (var r = 0, i = n; r < i.length; r += 1) i[r].separatedFrom(e.branchID) || e.raise("Duplicate capture group name");
+			else e.raise("Duplicate capture group name");
+			t ? (n || (e.groupNames[e.lastStringValue] = [])).push(e.branchID) : e.groupNames[e.lastStringValue] = !0;
+		}
+	}, G.regexp_eatGroupName = function(e) {
+		if (e.lastStringValue = "", e.eat(60)) {
+			if (this.regexp_eatRegExpIdentifierName(e) && e.eat(62)) return !0;
+			e.raise("Invalid capture group name");
+		}
+		return !1;
+	}, G.regexp_eatRegExpIdentifierName = function(e) {
+		if (e.lastStringValue = "", this.regexp_eatRegExpIdentifierStart(e)) {
+			for (e.lastStringValue += l(e.lastIntValue); this.regexp_eatRegExpIdentifierPart(e);) e.lastStringValue += l(e.lastIntValue);
+			return !0;
+		}
+		return !1;
+	}, G.regexp_eatRegExpIdentifierStart = function(e) {
+		var t = e.pos, n = this.options.ecmaVersion >= 11, r = e.current(n);
+		return e.advance(n), r === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(e, n) && (r = e.lastIntValue), ae(r) ? (e.lastIntValue = r, !0) : (e.pos = t, !1);
+	}, G.regexp_eatRegExpIdentifierPart = function(e) {
+		var t = e.pos, n = this.options.ecmaVersion >= 11, r = e.current(n);
+		return e.advance(n), r === 92 && this.regexp_eatRegExpUnicodeEscapeSequence(e, n) && (r = e.lastIntValue), oe(r) ? (e.lastIntValue = r, !0) : (e.pos = t, !1);
+	}, G.regexp_eatAtomEscape = function(e) {
+		return this.regexp_eatBackReference(e) || this.regexp_eatCharacterClassEscape(e) || this.regexp_eatCharacterEscape(e) || e.switchN && this.regexp_eatKGroupName(e) ? !0 : (e.switchU && (e.current() === 99 && e.raise("Invalid unicode escape"), e.raise("Invalid escape")), !1);
+	}, G.regexp_eatBackReference = function(e) {
+		var t = e.pos;
+		if (this.regexp_eatDecimalEscape(e)) {
+			var n = e.lastIntValue;
+			if (e.switchU) return n > e.maxBackReference && (e.maxBackReference = n), !0;
+			if (n <= e.numCapturingParens) return !0;
+			e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatKGroupName = function(e) {
+		if (e.eat(107)) {
+			if (this.regexp_eatGroupName(e)) return e.backReferenceNames.push(e.lastStringValue), !0;
+			e.raise("Invalid named reference");
+		}
+		return !1;
+	}, G.regexp_eatCharacterEscape = function(e) {
+		return this.regexp_eatControlEscape(e) || this.regexp_eatCControlLetter(e) || this.regexp_eatZero(e) || this.regexp_eatHexEscapeSequence(e) || this.regexp_eatRegExpUnicodeEscapeSequence(e, !1) || !e.switchU && this.regexp_eatLegacyOctalEscapeSequence(e) || this.regexp_eatIdentityEscape(e);
+	}, G.regexp_eatCControlLetter = function(e) {
+		var t = e.pos;
+		if (e.eat(99)) {
+			if (this.regexp_eatControlLetter(e)) return !0;
+			e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatZero = function(e) {
+		return e.current() === 48 && !he(e.lookahead()) ? (e.lastIntValue = 0, e.advance(), !0) : !1;
+	}, G.regexp_eatControlEscape = function(e) {
+		var t = e.current();
+		return t === 116 ? (e.lastIntValue = 9, e.advance(), !0) : t === 110 ? (e.lastIntValue = 10, e.advance(), !0) : t === 118 ? (e.lastIntValue = 11, e.advance(), !0) : t === 102 ? (e.lastIntValue = 12, e.advance(), !0) : t === 114 ? (e.lastIntValue = 13, e.advance(), !0) : !1;
+	}, G.regexp_eatControlLetter = function(e) {
+		var t = e.current();
+		return se(t) ? (e.lastIntValue = t % 32, e.advance(), !0) : !1;
+	}, G.regexp_eatRegExpUnicodeEscapeSequence = function(e, t) {
+		t === void 0 && (t = !1);
+		var n = e.pos, r = t || e.switchU;
+		if (e.eat(117)) {
+			if (this.regexp_eatFixedHexDigits(e, 4)) {
+				var i = e.lastIntValue;
+				if (r && i >= 55296 && i <= 56319) {
+					var a = e.pos;
+					if (e.eat(92) && e.eat(117) && this.regexp_eatFixedHexDigits(e, 4)) {
+						var o = e.lastIntValue;
+						if (o >= 56320 && o <= 57343) return e.lastIntValue = (i - 55296) * 1024 + (o - 56320) + 65536, !0;
+					}
+					e.pos = a, e.lastIntValue = i;
+				}
+				return !0;
+			}
+			if (r && e.eat(123) && this.regexp_eatHexDigits(e) && e.eat(125) && ce(e.lastIntValue)) return !0;
+			r && e.raise("Invalid unicode escape"), e.pos = n;
+		}
+		return !1;
+	}, G.regexp_eatIdentityEscape = function(e) {
+		if (e.switchU) return this.regexp_eatSyntaxCharacter(e) ? !0 : e.eat(47) ? (e.lastIntValue = 47, !0) : !1;
+		var t = e.current();
+		return t !== 99 && (!e.switchN || t !== 107) ? (e.lastIntValue = t, e.advance(), !0) : !1;
+	}, G.regexp_eatDecimalEscape = function(e) {
+		e.lastIntValue = 0;
+		var t = e.current();
+		if (t >= 49 && t <= 57) {
+			do
+				e.lastIntValue = 10 * e.lastIntValue + (t - 48), e.advance();
+			while ((t = e.current()) >= 48 && t <= 57);
+			return !0;
+		}
+		return !1;
+	}, Mn = 0, q = 1, J = 2, G.regexp_eatCharacterClassEscape = function(e) {
+		var t = e.current();
+		if (le(t)) return e.lastIntValue = -1, e.advance(), q;
+		var n = !1;
+		if (e.switchU && this.options.ecmaVersion >= 9 && ((n = t === 80) || t === 112)) {
+			e.lastIntValue = -1, e.advance();
+			var r;
+			if (e.eat(123) && (r = this.regexp_eatUnicodePropertyValueExpression(e)) && e.eat(125)) return n && r === J && e.raise("Invalid property name"), r;
+			e.raise("Invalid property name");
+		}
+		return Mn;
+	}, G.regexp_eatUnicodePropertyValueExpression = function(e) {
+		var t = e.pos;
+		if (this.regexp_eatUnicodePropertyName(e) && e.eat(61)) {
+			var n = e.lastStringValue;
+			if (this.regexp_eatUnicodePropertyValue(e)) {
+				var r = e.lastStringValue;
+				return this.regexp_validateUnicodePropertyNameAndValue(e, n, r), q;
+			}
+		}
+		if (e.pos = t, this.regexp_eatLoneUnicodePropertyNameOrValue(e)) {
+			var i = e.lastStringValue;
+			return this.regexp_validateUnicodePropertyNameOrValue(e, i);
+		}
+		return Mn;
+	}, G.regexp_validateUnicodePropertyNameAndValue = function(e, t, n) {
+		E(e.unicodeProperties.nonBinary, t) || e.raise("Invalid property name"), e.unicodeProperties.nonBinary[t].test(n) || e.raise("Invalid property value");
+	}, G.regexp_validateUnicodePropertyNameOrValue = function(e, t) {
+		if (e.unicodeProperties.binary.test(t)) return q;
+		if (e.switchV && e.unicodeProperties.binaryOfStrings.test(t)) return J;
+		e.raise("Invalid property name");
+	}, G.regexp_eatUnicodePropertyName = function(e) {
+		var t = 0;
+		for (e.lastStringValue = ""; ue(t = e.current());) e.lastStringValue += l(t), e.advance();
+		return e.lastStringValue !== "";
+	}, G.regexp_eatUnicodePropertyValue = function(e) {
+		var t = 0;
+		for (e.lastStringValue = ""; de(t = e.current());) e.lastStringValue += l(t), e.advance();
+		return e.lastStringValue !== "";
+	}, G.regexp_eatLoneUnicodePropertyNameOrValue = function(e) {
+		return this.regexp_eatUnicodePropertyValue(e);
+	}, G.regexp_eatCharacterClass = function(e) {
+		if (e.eat(91)) {
+			var t = e.eat(94), n = this.regexp_classContents(e);
+			return e.eat(93) || e.raise("Unterminated character class"), t && n === J && e.raise("Negated character class may contain strings"), !0;
+		}
+		return !1;
+	}, G.regexp_classContents = function(e) {
+		return e.current() === 93 ? q : e.switchV ? this.regexp_classSetExpression(e) : (this.regexp_nonEmptyClassRanges(e), q);
+	}, G.regexp_nonEmptyClassRanges = function(e) {
+		for (; this.regexp_eatClassAtom(e);) {
+			var t = e.lastIntValue;
+			if (e.eat(45) && this.regexp_eatClassAtom(e)) {
+				var n = e.lastIntValue;
+				e.switchU && (t === -1 || n === -1) && e.raise("Invalid character class"), t !== -1 && n !== -1 && t > n && e.raise("Range out of order in character class");
+			}
+		}
+	}, G.regexp_eatClassAtom = function(e) {
+		var t = e.pos;
+		if (e.eat(92)) {
+			if (this.regexp_eatClassEscape(e)) return !0;
+			if (e.switchU) {
+				var n = e.current();
+				(n === 99 || ve(n)) && e.raise("Invalid class escape"), e.raise("Invalid escape");
+			}
+			e.pos = t;
+		}
+		var r = e.current();
+		return r === 93 ? !1 : (e.lastIntValue = r, e.advance(), !0);
+	}, G.regexp_eatClassEscape = function(e) {
+		var t = e.pos;
+		if (e.eat(98)) return e.lastIntValue = 8, !0;
+		if (e.switchU && e.eat(45)) return e.lastIntValue = 45, !0;
+		if (!e.switchU && e.eat(99)) {
+			if (this.regexp_eatClassControlLetter(e)) return !0;
+			e.pos = t;
+		}
+		return this.regexp_eatCharacterClassEscape(e) || this.regexp_eatCharacterEscape(e);
+	}, G.regexp_classSetExpression = function(e) {
+		var t = q, n;
+		if (!this.regexp_eatClassSetRange(e)) if (n = this.regexp_eatClassSetOperand(e)) {
+			n === J && (t = J);
+			for (var r = e.pos; e.eatChars([38, 38]);) {
+				if (e.current() !== 38 && (n = this.regexp_eatClassSetOperand(e))) {
+					n !== J && (t = q);
+					continue;
+				}
+				e.raise("Invalid character in character class");
+			}
+			if (r !== e.pos) return t;
+			for (; e.eatChars([45, 45]);) this.regexp_eatClassSetOperand(e) || e.raise("Invalid character in character class");
+			if (r !== e.pos) return t;
+		} else e.raise("Invalid character in character class");
+		for (;;) if (!this.regexp_eatClassSetRange(e)) {
+			if (n = this.regexp_eatClassSetOperand(e), !n) return t;
+			n === J && (t = J);
+		}
+	}, G.regexp_eatClassSetRange = function(e) {
+		var t = e.pos;
+		if (this.regexp_eatClassSetCharacter(e)) {
+			var n = e.lastIntValue;
+			if (e.eat(45) && this.regexp_eatClassSetCharacter(e)) {
+				var r = e.lastIntValue;
+				return n !== -1 && r !== -1 && n > r && e.raise("Range out of order in character class"), !0;
+			}
+			e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatClassSetOperand = function(e) {
+		return this.regexp_eatClassSetCharacter(e) ? q : this.regexp_eatClassStringDisjunction(e) || this.regexp_eatNestedClass(e);
+	}, G.regexp_eatNestedClass = function(e) {
+		var t = e.pos;
+		if (e.eat(91)) {
+			var n = e.eat(94), r = this.regexp_classContents(e);
+			if (e.eat(93)) return n && r === J && e.raise("Negated character class may contain strings"), r;
+			e.pos = t;
+		}
+		if (e.eat(92)) {
+			var i = this.regexp_eatCharacterClassEscape(e);
+			if (i) return i;
+			e.pos = t;
+		}
+		return null;
+	}, G.regexp_eatClassStringDisjunction = function(e) {
+		var t = e.pos;
+		if (e.eatChars([92, 113])) {
+			if (e.eat(123)) {
+				var n = this.regexp_classStringDisjunctionContents(e);
+				if (e.eat(125)) return n;
+			} else e.raise("Invalid escape");
+			e.pos = t;
+		}
+		return null;
+	}, G.regexp_classStringDisjunctionContents = function(e) {
+		for (var t = this.regexp_classString(e); e.eat(124);) this.regexp_classString(e) === J && (t = J);
+		return t;
+	}, G.regexp_classString = function(e) {
+		for (var t = 0; this.regexp_eatClassSetCharacter(e);) t++;
+		return t === 1 ? q : J;
+	}, G.regexp_eatClassSetCharacter = function(e) {
+		var t = e.pos;
+		if (e.eat(92)) return this.regexp_eatCharacterEscape(e) || this.regexp_eatClassSetReservedPunctuator(e) ? !0 : e.eat(98) ? (e.lastIntValue = 8, !0) : (e.pos = t, !1);
+		var n = e.current();
+		return n < 0 || n === e.lookahead() && fe(n) || pe(n) ? !1 : (e.advance(), e.lastIntValue = n, !0);
+	}, G.regexp_eatClassSetReservedPunctuator = function(e) {
+		var t = e.current();
+		return me(t) ? (e.lastIntValue = t, e.advance(), !0) : !1;
+	}, G.regexp_eatClassControlLetter = function(e) {
+		var t = e.current();
+		return he(t) || t === 95 ? (e.lastIntValue = t % 32, e.advance(), !0) : !1;
+	}, G.regexp_eatHexEscapeSequence = function(e) {
+		var t = e.pos;
+		if (e.eat(120)) {
+			if (this.regexp_eatFixedHexDigits(e, 2)) return !0;
+			e.switchU && e.raise("Invalid escape"), e.pos = t;
+		}
+		return !1;
+	}, G.regexp_eatDecimalDigits = function(e) {
+		var t = e.pos, n = 0;
+		for (e.lastIntValue = 0; he(n = e.current());) e.lastIntValue = 10 * e.lastIntValue + (n - 48), e.advance();
+		return e.pos !== t;
+	}, G.regexp_eatHexDigits = function(e) {
+		var t = e.pos, n = 0;
+		for (e.lastIntValue = 0; ge(n = e.current());) e.lastIntValue = 16 * e.lastIntValue + _e(n), e.advance();
+		return e.pos !== t;
+	}, G.regexp_eatLegacyOctalEscapeSequence = function(e) {
+		if (this.regexp_eatOctalDigit(e)) {
+			var t = e.lastIntValue;
+			if (this.regexp_eatOctalDigit(e)) {
+				var n = e.lastIntValue;
+				t <= 3 && this.regexp_eatOctalDigit(e) ? e.lastIntValue = t * 64 + n * 8 + e.lastIntValue : e.lastIntValue = t * 8 + n;
+			} else e.lastIntValue = t;
+			return !0;
+		}
+		return !1;
+	}, G.regexp_eatOctalDigit = function(e) {
+		var t = e.current();
+		return ve(t) ? (e.lastIntValue = t - 48, e.advance(), !0) : (e.lastIntValue = 0, !1);
+	}, G.regexp_eatFixedHexDigits = function(e, t) {
+		var n = e.pos;
+		e.lastIntValue = 0;
+		for (var r = 0; r < t; ++r) {
+			var i = e.current();
+			if (!ge(i)) return e.pos = n, !1;
+			e.lastIntValue = 16 * e.lastIntValue + _e(i), e.advance();
+		}
+		return !0;
+	}, Nn = function(e) {
+		this.type = e.type, this.value = e.value, this.start = e.start, this.end = e.end, e.options.locations && (this.loc = new It(e, e.startLoc, e.endLoc)), e.options.ranges && (this.range = [e.start, e.end]);
+	}, Y = N.prototype, Y.next = function(e) {
+		!e && this.type.keyword && this.containsEsc && this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword), this.options.onToken && this.options.onToken(new Nn(this)), this.lastTokEnd = this.end, this.lastTokStart = this.start, this.lastTokEndLoc = this.endLoc, this.lastTokStartLoc = this.startLoc, this.nextToken();
+	}, Y.getToken = function() {
+		return this.next(), new Nn(this);
+	}, typeof Symbol < "u" && (Y[Symbol.iterator] = function() {
+		var e = this;
+		return { next: function() {
+			var t = e.getToken();
+			return {
+				done: t.type === C.eof,
+				value: t
+			};
+		} };
+	}), Y.nextToken = function() {
+		var e = this.curContext();
+		if ((!e || !e.preserveSpace) && this.skipSpace(), this.start = this.pos, this.options.locations && (this.startLoc = this.curPosition()), this.pos >= this.input.length) return this.finishToken(C.eof);
+		if (e.override) return e.override(this);
+		this.readToken(this.fullCharCodeAtPos());
+	}, Y.readToken = function(e) {
+		return n(e, this.options.ecmaVersion >= 6) || e === 92 ? this.readWord() : this.getTokenFromCode(e);
+	}, Y.fullCharCodeAtPos = function() {
+		var e = this.input.charCodeAt(this.pos);
+		if (e <= 55295 || e >= 56320) return e;
+		var t = this.input.charCodeAt(this.pos + 1);
+		return t <= 56319 || t >= 57344 ? e : (e << 10) + t - 56613888;
+	}, Y.skipBlockComment = function() {
+		var e = this.options.onComment && this.curPosition(), t = this.pos, n = this.input.indexOf("*/", this.pos += 2);
+		if (n === -1 && this.raise(this.pos - 2, "Unterminated comment"), this.pos = n + 2, this.options.locations) for (var r = void 0, i = t; (r = s(this.input, i, this.pos)) > -1;) ++this.curLine, i = this.lineStart = r;
+		this.options.onComment && this.options.onComment(!0, this.input.slice(t + 2, n), t, this.pos, e, this.curPosition());
+	}, Y.skipLineComment = function(e) {
+		for (var t = this.pos, n = this.options.onComment && this.curPosition(), r = this.input.charCodeAt(this.pos += e); this.pos < this.input.length && !o(r);) r = this.input.charCodeAt(++this.pos);
+		this.options.onComment && this.options.onComment(!1, this.input.slice(t + e, this.pos), t, this.pos, n, this.curPosition());
+	}, Y.skipSpace = function() {
+		e: for (; this.pos < this.input.length;) {
+			var e = this.input.charCodeAt(this.pos);
+			switch (e) {
+				case 32:
+				case 160:
+					++this.pos;
+					break;
+				case 13: this.input.charCodeAt(this.pos + 1) === 10 && ++this.pos;
+				case 10:
+				case 8232:
+				case 8233:
+					++this.pos, this.options.locations && (++this.curLine, this.lineStart = this.pos);
+					break;
+				case 47:
+					switch (this.input.charCodeAt(this.pos + 1)) {
+						case 42:
+							this.skipBlockComment();
+							break;
+						case 47:
+							this.skipLineComment(2);
+							break;
+						default: break e;
+					}
+					break;
+				default: if (e > 8 && e < 14 || e >= 5760 && kt.test(String.fromCharCode(e))) ++this.pos;
+				else break e;
+			}
+		}
+	}, Y.finishToken = function(e, t) {
+		this.end = this.pos, this.options.locations && (this.endLoc = this.curPosition());
+		var n = this.type;
+		this.type = e, this.value = t, this.updateContext(n);
+	}, Y.readToken_dot = function() {
+		var e = this.input.charCodeAt(this.pos + 1);
+		if (e >= 48 && e <= 57) return this.readNumber(!0);
+		var t = this.input.charCodeAt(this.pos + 2);
+		return this.options.ecmaVersion >= 6 && e === 46 && t === 46 ? (this.pos += 3, this.finishToken(C.ellipsis)) : (++this.pos, this.finishToken(C.dot));
+	}, Y.readToken_slash = function() {
+		var e = this.input.charCodeAt(this.pos + 1);
+		return this.exprAllowed ? (++this.pos, this.readRegexp()) : e === 61 ? this.finishOp(C.assign, 2) : this.finishOp(C.slash, 1);
+	}, Y.readToken_mult_modulo_exp = function(e) {
+		var t = this.input.charCodeAt(this.pos + 1), n = 1, r = e === 42 ? C.star : C.modulo;
+		return this.options.ecmaVersion >= 7 && e === 42 && t === 42 && (++n, r = C.starstar, t = this.input.charCodeAt(this.pos + 2)), t === 61 ? this.finishOp(C.assign, n + 1) : this.finishOp(r, n);
+	}, Y.readToken_pipe_amp = function(e) {
+		var t = this.input.charCodeAt(this.pos + 1);
+		return t === e ? this.options.ecmaVersion >= 12 && this.input.charCodeAt(this.pos + 2) === 61 ? this.finishOp(C.assign, 3) : this.finishOp(e === 124 ? C.logicalOR : C.logicalAND, 2) : t === 61 ? this.finishOp(C.assign, 2) : this.finishOp(e === 124 ? C.bitwiseOR : C.bitwiseAND, 1);
+	}, Y.readToken_caret = function() {
+		return this.input.charCodeAt(this.pos + 1) === 61 ? this.finishOp(C.assign, 2) : this.finishOp(C.bitwiseXOR, 1);
+	}, Y.readToken_plus_min = function(e) {
+		var t = this.input.charCodeAt(this.pos + 1);
+		return t === e ? t === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 && (this.lastTokEnd === 0 || w.test(this.input.slice(this.lastTokEnd, this.pos))) ? (this.skipLineComment(3), this.skipSpace(), this.nextToken()) : this.finishOp(C.incDec, 2) : t === 61 ? this.finishOp(C.assign, 2) : this.finishOp(C.plusMin, 1);
+	}, Y.readToken_lt_gt = function(e) {
+		var t = this.input.charCodeAt(this.pos + 1), n = 1;
+		return t === e ? (n = e === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2, this.input.charCodeAt(this.pos + n) === 61 ? this.finishOp(C.assign, n + 1) : this.finishOp(C.bitShift, n)) : t === 33 && e === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 && this.input.charCodeAt(this.pos + 3) === 45 ? (this.skipLineComment(4), this.skipSpace(), this.nextToken()) : (t === 61 && (n = 2), this.finishOp(C.relational, n));
+	}, Y.readToken_eq_excl = function(e) {
+		var t = this.input.charCodeAt(this.pos + 1);
+		return t === 61 ? this.finishOp(C.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) : e === 61 && t === 62 && this.options.ecmaVersion >= 6 ? (this.pos += 2, this.finishToken(C.arrow)) : this.finishOp(e === 61 ? C.eq : C.prefix, 1);
+	}, Y.readToken_question = function() {
+		var e = this.options.ecmaVersion;
+		if (e >= 11) {
+			var t = this.input.charCodeAt(this.pos + 1);
+			if (t === 46) {
+				var n = this.input.charCodeAt(this.pos + 2);
+				if (n < 48 || n > 57) return this.finishOp(C.questionDot, 2);
+			}
+			if (t === 63) return e >= 12 && this.input.charCodeAt(this.pos + 2) === 61 ? this.finishOp(C.assign, 3) : this.finishOp(C.coalesce, 2);
+		}
+		return this.finishOp(C.question, 1);
+	}, Y.readToken_numberSign = function() {
+		var e = this.options.ecmaVersion, t = 35;
+		if (e >= 13 && (++this.pos, t = this.fullCharCodeAtPos(), n(t, !0) || t === 92)) return this.finishToken(C.privateId, this.readWord1());
+		this.raise(this.pos, "Unexpected character '" + l(t) + "'");
+	}, Y.getTokenFromCode = function(e) {
+		switch (e) {
+			case 46: return this.readToken_dot();
+			case 40: return ++this.pos, this.finishToken(C.parenL);
+			case 41: return ++this.pos, this.finishToken(C.parenR);
+			case 59: return ++this.pos, this.finishToken(C.semi);
+			case 44: return ++this.pos, this.finishToken(C.comma);
+			case 91: return ++this.pos, this.finishToken(C.bracketL);
+			case 93: return ++this.pos, this.finishToken(C.bracketR);
+			case 123: return ++this.pos, this.finishToken(C.braceL);
+			case 125: return ++this.pos, this.finishToken(C.braceR);
+			case 58: return ++this.pos, this.finishToken(C.colon);
+			case 96:
+				if (this.options.ecmaVersion < 6) break;
+				return ++this.pos, this.finishToken(C.backQuote);
+			case 48:
+				var t = this.input.charCodeAt(this.pos + 1);
+				if (t === 120 || t === 88) return this.readRadixNumber(16);
+				if (this.options.ecmaVersion >= 6) {
+					if (t === 111 || t === 79) return this.readRadixNumber(8);
+					if (t === 98 || t === 66) return this.readRadixNumber(2);
+				}
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57: return this.readNumber(!1);
+			case 34:
+			case 39: return this.readString(e);
+			case 47: return this.readToken_slash();
+			case 37:
+			case 42: return this.readToken_mult_modulo_exp(e);
+			case 124:
+			case 38: return this.readToken_pipe_amp(e);
+			case 94: return this.readToken_caret();
+			case 43:
+			case 45: return this.readToken_plus_min(e);
+			case 60:
+			case 62: return this.readToken_lt_gt(e);
+			case 61:
+			case 33: return this.readToken_eq_excl(e);
+			case 63: return this.readToken_question();
+			case 126: return this.finishOp(C.prefix, 1);
+			case 35: return this.readToken_numberSign();
+		}
+		this.raise(this.pos, "Unexpected character '" + l(e) + "'");
+	}, Y.finishOp = function(e, t) {
+		var n = this.input.slice(this.pos, this.pos + t);
+		return this.pos += t, this.finishToken(e, n);
+	}, Y.readRegexp = function() {
+		for (var e, t, n = this.pos;;) {
+			this.pos >= this.input.length && this.raise(n, "Unterminated regular expression");
+			var r = this.input.charAt(this.pos);
+			if (w.test(r) && this.raise(n, "Unterminated regular expression"), e) e = !1;
+			else {
+				if (r === "[") t = !0;
+				else if (r === "]" && t) t = !1;
+				else if (r === "/" && !t) break;
+				e = r === "\\";
+			}
+			++this.pos;
+		}
+		var i = this.input.slice(n, this.pos);
+		++this.pos;
+		var a = this.pos, o = this.readWord1();
+		this.containsEsc && this.unexpected(a);
+		var s = this.regexpState ||= new K(this);
+		s.reset(n, i, o), this.validateRegExpFlags(s), this.validateRegExpPattern(s);
+		var c = null;
+		try {
+			c = new RegExp(i, o);
+		} catch {}
+		return this.finishToken(C.regexp, {
+			pattern: i,
+			flags: o,
+			value: c
+		});
+	}, Y.readInt = function(e, t, n) {
+		for (var r = this.options.ecmaVersion >= 12 && t === void 0, i = n && this.input.charCodeAt(this.pos) === 48, a = this.pos, o = 0, s = 0, c = 0, l = t ?? Infinity; c < l; ++c, ++this.pos) {
+			var u = this.input.charCodeAt(this.pos), d = void 0;
+			if (r && u === 95) {
+				i && this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals"), s === 95 && this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore"), c === 0 && this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits"), s = u;
+				continue;
+			}
+			if (d = u >= 97 ? u - 97 + 10 : u >= 65 ? u - 65 + 10 : u >= 48 && u <= 57 ? u - 48 : Infinity, d >= e) break;
+			s = u, o = o * e + d;
+		}
+		return r && s === 95 && this.raiseRecoverable(this.pos - 1, "Numeric separator is not allowed at the last of digits"), this.pos === a || t != null && this.pos - a !== t ? null : o;
+	}, Y.readRadixNumber = function(e) {
+		var t = this.pos;
+		this.pos += 2;
+		var r = this.readInt(e);
+		return r ?? this.raise(this.start + 2, "Expected number in radix " + e), this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110 ? (r = be(this.input.slice(t, this.pos)), ++this.pos) : n(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number"), this.finishToken(C.num, r);
+	}, Y.readNumber = function(e) {
+		var t = this.pos;
+		!e && this.readInt(10, void 0, !0) === null && this.raise(t, "Invalid number");
+		var r = this.pos - t >= 2 && this.input.charCodeAt(t) === 48;
+		r && this.strict && this.raise(t, "Invalid number");
+		var i = this.input.charCodeAt(this.pos);
+		if (!r && !e && this.options.ecmaVersion >= 11 && i === 110) {
+			var a = be(this.input.slice(t, this.pos));
+			return ++this.pos, n(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number"), this.finishToken(C.num, a);
+		}
+		r && /[89]/.test(this.input.slice(t, this.pos)) && (r = !1), i === 46 && !r && (++this.pos, this.readInt(10), i = this.input.charCodeAt(this.pos)), (i === 69 || i === 101) && !r && (i = this.input.charCodeAt(++this.pos), (i === 43 || i === 45) && ++this.pos, this.readInt(10) === null && this.raise(t, "Invalid number")), n(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number");
+		var o = ye(this.input.slice(t, this.pos), r);
+		return this.finishToken(C.num, o);
+	}, Y.readCodePoint = function() {
+		var e = this.input.charCodeAt(this.pos), t;
+		if (e === 123) {
+			this.options.ecmaVersion < 6 && this.unexpected();
+			var n = ++this.pos;
+			t = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos), ++this.pos, t > 1114111 && this.invalidStringToken(n, "Code point out of bounds");
+		} else t = this.readHexChar(4);
+		return t;
+	}, Y.readString = function(e) {
+		for (var t = "", n = ++this.pos;;) {
+			this.pos >= this.input.length && this.raise(this.start, "Unterminated string constant");
+			var r = this.input.charCodeAt(this.pos);
+			if (r === e) break;
+			r === 92 ? (t += this.input.slice(n, this.pos), t += this.readEscapedChar(!1), n = this.pos) : r === 8232 || r === 8233 ? (this.options.ecmaVersion < 10 && this.raise(this.start, "Unterminated string constant"), ++this.pos, this.options.locations && (this.curLine++, this.lineStart = this.pos)) : (o(r) && this.raise(this.start, "Unterminated string constant"), ++this.pos);
+		}
+		return t += this.input.slice(n, this.pos++), this.finishToken(C.string, t);
+	}, Pn = {}, Y.tryReadTemplateToken = function() {
+		this.inTemplateElement = !0;
+		try {
+			this.readTmplToken();
+		} catch (e) {
+			if (e === Pn) this.readInvalidTemplateToken();
+			else throw e;
+		}
+		this.inTemplateElement = !1;
+	}, Y.invalidStringToken = function(e, t) {
+		if (this.inTemplateElement && this.options.ecmaVersion >= 9) throw Pn;
+		this.raise(e, t);
+	}, Y.readTmplToken = function() {
+		for (var e = "", t = this.pos;;) {
+			this.pos >= this.input.length && this.raise(this.start, "Unterminated template");
+			var n = this.input.charCodeAt(this.pos);
+			if (n === 96 || n === 36 && this.input.charCodeAt(this.pos + 1) === 123) return this.pos === this.start && (this.type === C.template || this.type === C.invalidTemplate) ? n === 36 ? (this.pos += 2, this.finishToken(C.dollarBraceL)) : (++this.pos, this.finishToken(C.backQuote)) : (e += this.input.slice(t, this.pos), this.finishToken(C.template, e));
+			if (n === 92) e += this.input.slice(t, this.pos), e += this.readEscapedChar(!0), t = this.pos;
+			else if (o(n)) {
+				switch (e += this.input.slice(t, this.pos), ++this.pos, n) {
+					case 13: this.input.charCodeAt(this.pos) === 10 && ++this.pos;
+					case 10:
+						e += "\n";
+						break;
+					default:
+						e += String.fromCharCode(n);
+						break;
+				}
+				this.options.locations && (++this.curLine, this.lineStart = this.pos), t = this.pos;
+			} else ++this.pos;
+		}
+	}, Y.readInvalidTemplateToken = function() {
+		for (; this.pos < this.input.length; this.pos++) switch (this.input[this.pos]) {
+			case "\\":
+				++this.pos;
+				break;
+			case "$": if (this.input[this.pos + 1] !== "{") break;
+			case "`": return this.finishToken(C.invalidTemplate, this.input.slice(this.start, this.pos));
+			case "\r": this.input[this.pos + 1] === "\n" && ++this.pos;
+			case "\n":
+			case "\u2028":
+			case "\u2029":
+				++this.curLine, this.lineStart = this.pos + 1;
+				break;
+		}
+		this.raise(this.start, "Unterminated template");
+	}, Y.readEscapedChar = function(e) {
+		var t = this.input.charCodeAt(++this.pos);
+		switch (++this.pos, t) {
+			case 110: return "\n";
+			case 114: return "\r";
+			case 120: return String.fromCharCode(this.readHexChar(2));
+			case 117: return l(this.readCodePoint());
+			case 116: return "	";
+			case 98: return "\b";
+			case 118: return "\v";
+			case 102: return "\f";
+			case 13: this.input.charCodeAt(this.pos) === 10 && ++this.pos;
+			case 10: return this.options.locations && (this.lineStart = this.pos, ++this.curLine), "";
+			case 56:
+			case 57: if (this.strict && this.invalidStringToken(this.pos - 1, "Invalid escape sequence"), e) {
+				var n = this.pos - 1;
+				this.invalidStringToken(n, "Invalid escape sequence in template string");
+			}
+			default:
+				if (t >= 48 && t <= 55) {
+					var r = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0], i = parseInt(r, 8);
+					return i > 255 && (r = r.slice(0, -1), i = parseInt(r, 8)), this.pos += r.length - 1, t = this.input.charCodeAt(this.pos), (r !== "0" || t === 56 || t === 57) && (this.strict || e) && this.invalidStringToken(this.pos - 1 - r.length, e ? "Octal literal in template string" : "Octal literal in strict mode"), String.fromCharCode(i);
+				}
+				return o(t) ? (this.options.locations && (this.lineStart = this.pos, ++this.curLine), "") : String.fromCharCode(t);
+		}
+	}, Y.readHexChar = function(e) {
+		var t = this.pos, n = this.readInt(16, e);
+		return n === null && this.invalidStringToken(t, "Bad character escape sequence"), n;
+	}, Y.readWord1 = function() {
+		this.containsEsc = !1;
+		for (var e = "", t = !0, i = this.pos, a = this.options.ecmaVersion >= 6; this.pos < this.input.length;) {
+			var o = this.fullCharCodeAtPos();
+			if (r(o, a)) this.pos += o <= 65535 ? 1 : 2;
+			else if (o === 92) {
+				this.containsEsc = !0, e += this.input.slice(i, this.pos);
+				var s = this.pos;
+				this.input.charCodeAt(++this.pos) !== 117 && this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX"), ++this.pos;
+				var c = this.readCodePoint();
+				(t ? n : r)(c, a) || this.invalidStringToken(s, "Invalid Unicode escape"), e += l(c), i = this.pos;
+			} else break;
+			t = !1;
+		}
+		return e + this.input.slice(i, this.pos);
+	}, Y.readWord = function() {
+		var e = this.readWord1(), t = C.name;
+		return this.keywords.test(e) && (t = Dt[e]), this.finishToken(t, e);
+	}, N.acorn = {
+		Parser: N,
+		version: "8.15.0",
+		defaultOptions: Lt,
+		Position: D,
+		SourceLocation: It,
+		getLineInfo: u,
+		Node: cn,
+		TokenType: b,
+		tokTypes: C,
+		keywordTypes: Dt,
+		TokContext: z,
+		tokContexts: B,
+		isIdentifierChar: r,
+		isIdentifierStart: n,
+		Token: Nn,
+		isNewLine: o,
+		lineBreak: w,
+		lineBreakG: Ot,
+		nonASCIIwhitespace: kt
+	}, Fn = pt(ht(), 1), In = xe, Ln = (e, t) => (n, r, ...i) => n | 1 && r == null ? void 0 : (t.call(r) ?? r[e]).apply(r, i), Rn = Array.prototype.findLast ?? function(e) {
+		for (let t = this.length - 1; t >= 0; t--) {
+			let n = this[t];
+			if (e(n, t, this)) return n;
+		}
+	}, zn = Ln("findLast", function() {
+		if (Array.isArray(this)) return Rn;
+	}), Bn = Ln("at", function() {
+		if (Array.isArray(this) || typeof this == "string") return Ce;
+	}), Vn = we, Hn = Vn([
+		"Block",
+		"CommentBlock",
+		"MultiLine"
+	]), Un = Vn([
+		"Line",
+		"CommentLine",
+		"SingleLine",
+		"HashbangComment",
+		"HTMLOpen",
+		"HTMLClose",
+		"Hashbang",
+		"InterpreterDirective"
+	]), Wn = /* @__PURE__ */ new WeakMap(), Gn = Te, Kn = /* @__PURE__ */ new WeakMap(), qn = De, Jn = Oe, Yn = ke, X = null, Xn = 10;
+	for (let e = 0; e <= Xn; e++) Ae();
+	Zn = Me, Z = [
+		[
+			"decorators",
+			"key",
+			"typeAnnotation",
+			"value"
+		],
+		[],
+		["elementType"],
+		["expression"],
+		["expression", "typeAnnotation"],
+		["left", "right"],
+		["argument"],
+		["directives", "body"],
+		["label"],
+		[
+			"callee",
+			"typeArguments",
+			"arguments"
+		],
+		["body"],
+		[
+			"decorators",
+			"id",
+			"typeParameters",
+			"superClass",
+			"superTypeArguments",
+			"mixins",
+			"implements",
+			"body",
+			"superTypeParameters"
+		],
+		["id", "typeParameters"],
+		[
+			"decorators",
+			"key",
+			"typeParameters",
+			"params",
+			"returnType",
+			"body"
+		],
+		[
+			"decorators",
+			"variance",
+			"key",
+			"typeAnnotation",
+			"value"
+		],
+		["name", "typeAnnotation"],
+		[
+			"test",
+			"consequent",
+			"alternate"
+		],
+		[
+			"checkType",
+			"extendsType",
+			"trueType",
+			"falseType"
+		],
+		["value"],
+		["id", "body"],
+		[
+			"declaration",
+			"specifiers",
+			"source",
+			"attributes"
+		],
+		["id"],
+		[
+			"id",
+			"typeParameters",
+			"extends",
+			"body"
+		],
+		["typeAnnotation"],
+		[
+			"id",
+			"typeParameters",
+			"right"
+		],
+		["body", "test"],
+		["members"],
+		["id", "init"],
+		["exported"],
+		[
+			"left",
+			"right",
+			"body"
+		],
+		[
+			"id",
+			"typeParameters",
+			"params",
+			"predicate",
+			"returnType",
+			"body"
+		],
+		[
+			"id",
+			"params",
+			"body",
+			"typeParameters",
+			"returnType"
+		],
+		["key", "value"],
+		["local"],
+		["objectType", "indexType"],
+		["typeParameter"],
+		["types"],
+		["node"],
+		["object", "property"],
+		["argument", "cases"],
+		[
+			"pattern",
+			"body",
+			"guard"
+		],
+		["literal"],
+		[
+			"decorators",
+			"key",
+			"value"
+		],
+		["expressions"],
+		["qualification", "id"],
+		[
+			"decorators",
+			"key",
+			"typeAnnotation"
+		],
+		[
+			"typeParameters",
+			"params",
+			"returnType"
+		],
+		["expression", "typeArguments"],
+		["params"],
+		["parameterName", "typeAnnotation"]
+	], Qn = Zn({
+		AccessorProperty: Z[0],
+		AnyTypeAnnotation: Z[1],
+		ArgumentPlaceholder: Z[1],
+		ArrayExpression: ["elements"],
+		ArrayPattern: [
+			"elements",
+			"typeAnnotation",
+			"decorators"
+		],
+		ArrayTypeAnnotation: Z[2],
+		ArrowFunctionExpression: [
+			"typeParameters",
+			"params",
+			"predicate",
+			"returnType",
+			"body"
+		],
+		AsConstExpression: Z[3],
+		AsExpression: Z[4],
+		AssignmentExpression: Z[5],
+		AssignmentPattern: [
+			"left",
+			"right",
+			"decorators",
+			"typeAnnotation"
+		],
+		AwaitExpression: Z[6],
+		BigIntLiteral: Z[1],
+		BigIntLiteralTypeAnnotation: Z[1],
+		BigIntTypeAnnotation: Z[1],
+		BinaryExpression: Z[5],
+		BindExpression: ["object", "callee"],
+		BlockStatement: Z[7],
+		BooleanLiteral: Z[1],
+		BooleanLiteralTypeAnnotation: Z[1],
+		BooleanTypeAnnotation: Z[1],
+		BreakStatement: Z[8],
+		CallExpression: Z[9],
+		CatchClause: ["param", "body"],
+		ChainExpression: Z[3],
+		ClassAccessorProperty: Z[0],
+		ClassBody: Z[10],
+		ClassDeclaration: Z[11],
+		ClassExpression: Z[11],
+		ClassImplements: Z[12],
+		ClassMethod: Z[13],
+		ClassPrivateMethod: Z[13],
+		ClassPrivateProperty: Z[14],
+		ClassProperty: Z[14],
+		ComponentDeclaration: [
+			"id",
+			"params",
+			"body",
+			"typeParameters",
+			"rendersType"
+		],
+		ComponentParameter: ["name", "local"],
+		ComponentTypeAnnotation: [
+			"params",
+			"rest",
+			"typeParameters",
+			"rendersType"
+		],
+		ComponentTypeParameter: Z[15],
+		ConditionalExpression: Z[16],
+		ConditionalTypeAnnotation: Z[17],
+		ContinueStatement: Z[8],
+		DebuggerStatement: Z[1],
+		DeclareClass: [
+			"id",
+			"typeParameters",
+			"extends",
+			"mixins",
+			"implements",
+			"body"
+		],
+		DeclareComponent: [
+			"id",
+			"params",
+			"rest",
+			"typeParameters",
+			"rendersType"
+		],
+		DeclaredPredicate: Z[18],
+		DeclareEnum: Z[19],
+		DeclareExportAllDeclaration: ["source", "attributes"],
+		DeclareExportDeclaration: Z[20],
+		DeclareFunction: ["id", "predicate"],
+		DeclareHook: Z[21],
+		DeclareInterface: Z[22],
+		DeclareModule: Z[19],
+		DeclareModuleExports: Z[23],
+		DeclareNamespace: Z[19],
+		DeclareOpaqueType: [
+			"id",
+			"typeParameters",
+			"supertype",
+			"lowerBound",
+			"upperBound"
+		],
+		DeclareTypeAlias: Z[24],
+		DeclareVariable: Z[21],
+		Decorator: Z[3],
+		Directive: Z[18],
+		DirectiveLiteral: Z[1],
+		DoExpression: Z[10],
+		DoWhileStatement: Z[25],
+		EmptyStatement: Z[1],
+		EmptyTypeAnnotation: Z[1],
+		EnumBigIntBody: Z[26],
+		EnumBigIntMember: Z[27],
+		EnumBooleanBody: Z[26],
+		EnumBooleanMember: Z[27],
+		EnumDeclaration: Z[19],
+		EnumDefaultedMember: Z[21],
+		EnumNumberBody: Z[26],
+		EnumNumberMember: Z[27],
+		EnumStringBody: Z[26],
+		EnumStringMember: Z[27],
+		EnumSymbolBody: Z[26],
+		ExistsTypeAnnotation: Z[1],
+		ExperimentalRestProperty: Z[6],
+		ExperimentalSpreadProperty: Z[6],
+		ExportAllDeclaration: [
+			"source",
+			"attributes",
+			"exported"
+		],
+		ExportDefaultDeclaration: ["declaration"],
+		ExportDefaultSpecifier: Z[28],
+		ExportNamedDeclaration: Z[20],
+		ExportNamespaceSpecifier: Z[28],
+		ExportSpecifier: ["local", "exported"],
+		ExpressionStatement: Z[3],
+		File: ["program"],
+		ForInStatement: Z[29],
+		ForOfStatement: Z[29],
+		ForStatement: [
+			"init",
+			"test",
+			"update",
+			"body"
+		],
+		FunctionDeclaration: Z[30],
+		FunctionExpression: Z[30],
+		FunctionTypeAnnotation: [
+			"typeParameters",
+			"this",
+			"params",
+			"rest",
+			"returnType"
+		],
+		FunctionTypeParam: Z[15],
+		GenericTypeAnnotation: Z[12],
+		HookDeclaration: Z[31],
+		HookTypeAnnotation: [
+			"params",
+			"returnType",
+			"rest",
+			"typeParameters"
+		],
+		Identifier: ["typeAnnotation", "decorators"],
+		IfStatement: Z[16],
+		ImportAttribute: Z[32],
+		ImportDeclaration: [
+			"specifiers",
+			"source",
+			"attributes"
+		],
+		ImportDefaultSpecifier: Z[33],
+		ImportExpression: ["source", "options"],
+		ImportNamespaceSpecifier: Z[33],
+		ImportSpecifier: ["imported", "local"],
+		IndexedAccessType: Z[34],
+		InferredPredicate: Z[1],
+		InferTypeAnnotation: Z[35],
+		InterfaceDeclaration: Z[22],
+		InterfaceExtends: Z[12],
+		InterfaceTypeAnnotation: ["extends", "body"],
+		InterpreterDirective: Z[1],
+		IntersectionTypeAnnotation: Z[36],
+		JsExpressionRoot: Z[37],
+		JsonRoot: Z[37],
+		JSXAttribute: ["name", "value"],
+		JSXClosingElement: ["name"],
+		JSXClosingFragment: Z[1],
+		JSXElement: [
+			"openingElement",
+			"children",
+			"closingElement"
+		],
+		JSXEmptyExpression: Z[1],
+		JSXExpressionContainer: Z[3],
+		JSXFragment: [
+			"openingFragment",
+			"children",
+			"closingFragment"
+		],
+		JSXIdentifier: Z[1],
+		JSXMemberExpression: Z[38],
+		JSXNamespacedName: ["namespace", "name"],
+		JSXOpeningElement: [
+			"name",
+			"typeArguments",
+			"attributes"
+		],
+		JSXOpeningFragment: Z[1],
+		JSXSpreadAttribute: Z[6],
+		JSXSpreadChild: Z[3],
+		JSXText: Z[1],
+		KeyofTypeAnnotation: Z[6],
+		LabeledStatement: ["label", "body"],
+		Literal: Z[1],
+		LogicalExpression: Z[5],
+		MatchArrayPattern: ["elements", "rest"],
+		MatchAsPattern: ["pattern", "target"],
+		MatchBindingPattern: Z[21],
+		MatchExpression: Z[39],
+		MatchExpressionCase: Z[40],
+		MatchIdentifierPattern: Z[21],
+		MatchLiteralPattern: Z[41],
+		MatchMemberPattern: ["base", "property"],
+		MatchObjectPattern: ["properties", "rest"],
+		MatchObjectPatternProperty: ["key", "pattern"],
+		MatchOrPattern: ["patterns"],
+		MatchRestPattern: Z[6],
+		MatchStatement: Z[39],
+		MatchStatementCase: Z[40],
+		MatchUnaryPattern: Z[6],
+		MatchWildcardPattern: Z[1],
+		MemberExpression: Z[38],
+		MetaProperty: ["meta", "property"],
+		MethodDefinition: Z[42],
+		MixedTypeAnnotation: Z[1],
+		ModuleExpression: Z[10],
+		NeverTypeAnnotation: Z[1],
+		NewExpression: Z[9],
+		NGChainedExpression: Z[43],
+		NGEmptyExpression: Z[1],
+		NGMicrosyntax: Z[10],
+		NGMicrosyntaxAs: ["key", "alias"],
+		NGMicrosyntaxExpression: ["expression", "alias"],
+		NGMicrosyntaxKey: Z[1],
+		NGMicrosyntaxKeyedExpression: ["key", "expression"],
+		NGMicrosyntaxLet: Z[32],
+		NGPipeExpression: [
+			"left",
+			"right",
+			"arguments"
+		],
+		NGRoot: Z[37],
+		NullableTypeAnnotation: Z[23],
+		NullLiteral: Z[1],
+		NullLiteralTypeAnnotation: Z[1],
+		NumberLiteralTypeAnnotation: Z[1],
+		NumberTypeAnnotation: Z[1],
+		NumericLiteral: Z[1],
+		ObjectExpression: ["properties"],
+		ObjectMethod: Z[13],
+		ObjectPattern: [
+			"decorators",
+			"properties",
+			"typeAnnotation"
+		],
+		ObjectProperty: Z[42],
+		ObjectTypeAnnotation: [
+			"properties",
+			"indexers",
+			"callProperties",
+			"internalSlots"
+		],
+		ObjectTypeCallProperty: Z[18],
+		ObjectTypeIndexer: [
+			"variance",
+			"id",
+			"key",
+			"value"
+		],
+		ObjectTypeInternalSlot: ["id", "value"],
+		ObjectTypeMappedTypeProperty: [
+			"keyTparam",
+			"propType",
+			"sourceType",
+			"variance"
+		],
+		ObjectTypeProperty: [
+			"key",
+			"value",
+			"variance"
+		],
+		ObjectTypeSpreadProperty: Z[6],
+		OpaqueType: [
+			"id",
+			"typeParameters",
+			"supertype",
+			"impltype",
+			"lowerBound",
+			"upperBound"
+		],
+		OptionalCallExpression: Z[9],
+		OptionalIndexedAccessType: Z[34],
+		OptionalMemberExpression: Z[38],
+		ParenthesizedExpression: Z[3],
+		PipelineBareFunction: ["callee"],
+		PipelinePrimaryTopicReference: Z[1],
+		PipelineTopicExpression: Z[3],
+		Placeholder: Z[1],
+		PrivateIdentifier: Z[1],
+		PrivateName: Z[21],
+		Program: Z[7],
+		Property: Z[32],
+		PropertyDefinition: Z[14],
+		QualifiedTypeIdentifier: Z[44],
+		QualifiedTypeofIdentifier: Z[44],
+		RegExpLiteral: Z[1],
+		RestElement: [
+			"argument",
+			"typeAnnotation",
+			"decorators"
+		],
+		ReturnStatement: Z[6],
+		SatisfiesExpression: Z[4],
+		SequenceExpression: Z[43],
+		SpreadElement: Z[6],
+		StaticBlock: Z[10],
+		StringLiteral: Z[1],
+		StringLiteralTypeAnnotation: Z[1],
+		StringTypeAnnotation: Z[1],
+		Super: Z[1],
+		SwitchCase: ["test", "consequent"],
+		SwitchStatement: ["discriminant", "cases"],
+		SymbolTypeAnnotation: Z[1],
+		TaggedTemplateExpression: [
+			"tag",
+			"typeArguments",
+			"quasi"
+		],
+		TemplateElement: Z[1],
+		TemplateLiteral: ["quasis", "expressions"],
+		ThisExpression: Z[1],
+		ThisTypeAnnotation: Z[1],
+		ThrowStatement: Z[6],
+		TopicReference: Z[1],
+		TryStatement: [
+			"block",
+			"handler",
+			"finalizer"
+		],
+		TSAbstractAccessorProperty: Z[45],
+		TSAbstractKeyword: Z[1],
+		TSAbstractMethodDefinition: Z[32],
+		TSAbstractPropertyDefinition: Z[45],
+		TSAnyKeyword: Z[1],
+		TSArrayType: Z[2],
+		TSAsExpression: Z[4],
+		TSAsyncKeyword: Z[1],
+		TSBigIntKeyword: Z[1],
+		TSBooleanKeyword: Z[1],
+		TSCallSignatureDeclaration: Z[46],
+		TSClassImplements: Z[47],
+		TSConditionalType: Z[17],
+		TSConstructorType: Z[46],
+		TSConstructSignatureDeclaration: Z[46],
+		TSDeclareFunction: Z[31],
+		TSDeclareKeyword: Z[1],
+		TSDeclareMethod: [
+			"decorators",
+			"key",
+			"typeParameters",
+			"params",
+			"returnType"
+		],
+		TSEmptyBodyFunctionExpression: [
+			"id",
+			"typeParameters",
+			"params",
+			"returnType"
+		],
+		TSEnumBody: Z[26],
+		TSEnumDeclaration: Z[19],
+		TSEnumMember: ["id", "initializer"],
+		TSExportAssignment: Z[3],
+		TSExportKeyword: Z[1],
+		TSExternalModuleReference: Z[3],
+		TSFunctionType: Z[46],
+		TSImportEqualsDeclaration: ["id", "moduleReference"],
+		TSImportType: [
+			"options",
+			"qualifier",
+			"typeArguments",
+			"source"
+		],
+		TSIndexedAccessType: Z[34],
+		TSIndexSignature: ["parameters", "typeAnnotation"],
+		TSInferType: Z[35],
+		TSInstantiationExpression: Z[47],
+		TSInterfaceBody: Z[10],
+		TSInterfaceDeclaration: Z[22],
+		TSInterfaceHeritage: Z[47],
+		TSIntersectionType: Z[36],
+		TSIntrinsicKeyword: Z[1],
+		TSJSDocAllType: Z[1],
+		TSJSDocNonNullableType: Z[23],
+		TSJSDocNullableType: Z[23],
+		TSJSDocUnknownType: Z[1],
+		TSLiteralType: Z[41],
+		TSMappedType: [
+			"key",
+			"constraint",
+			"nameType",
+			"typeAnnotation"
+		],
+		TSMethodSignature: [
+			"key",
+			"typeParameters",
+			"params",
+			"returnType"
+		],
+		TSModuleBlock: Z[10],
+		TSModuleDeclaration: Z[19],
+		TSNamedTupleMember: ["label", "elementType"],
+		TSNamespaceExportDeclaration: Z[21],
+		TSNeverKeyword: Z[1],
+		TSNonNullExpression: Z[3],
+		TSNullKeyword: Z[1],
+		TSNumberKeyword: Z[1],
+		TSObjectKeyword: Z[1],
+		TSOptionalType: Z[23],
+		TSParameterProperty: ["parameter", "decorators"],
+		TSParenthesizedType: Z[23],
+		TSPrivateKeyword: Z[1],
+		TSPropertySignature: ["key", "typeAnnotation"],
+		TSProtectedKeyword: Z[1],
+		TSPublicKeyword: Z[1],
+		TSQualifiedName: Z[5],
+		TSReadonlyKeyword: Z[1],
+		TSRestType: Z[23],
+		TSSatisfiesExpression: Z[4],
+		TSStaticKeyword: Z[1],
+		TSStringKeyword: Z[1],
+		TSSymbolKeyword: Z[1],
+		TSTemplateLiteralType: ["quasis", "types"],
+		TSThisType: Z[1],
+		TSTupleType: ["elementTypes"],
+		TSTypeAliasDeclaration: [
+			"id",
+			"typeParameters",
+			"typeAnnotation"
+		],
+		TSTypeAnnotation: Z[23],
+		TSTypeAssertion: Z[4],
+		TSTypeLiteral: Z[26],
+		TSTypeOperator: Z[23],
+		TSTypeParameter: [
+			"name",
+			"constraint",
+			"default"
+		],
+		TSTypeParameterDeclaration: Z[48],
+		TSTypeParameterInstantiation: Z[48],
+		TSTypePredicate: Z[49],
+		TSTypeQuery: ["exprName", "typeArguments"],
+		TSTypeReference: ["typeName", "typeArguments"],
+		TSUndefinedKeyword: Z[1],
+		TSUnionType: Z[36],
+		TSUnknownKeyword: Z[1],
+		TSVoidKeyword: Z[1],
+		TupleTypeAnnotation: ["types", "elementTypes"],
+		TupleTypeLabeledElement: [
+			"label",
+			"elementType",
+			"variance"
+		],
+		TupleTypeSpreadElement: ["label", "typeAnnotation"],
+		TypeAlias: Z[24],
+		TypeAnnotation: Z[23],
+		TypeCastExpression: Z[4],
+		TypeofTypeAnnotation: ["argument", "typeArguments"],
+		TypeOperator: Z[23],
+		TypeParameter: [
+			"bound",
+			"default",
+			"variance"
+		],
+		TypeParameterDeclaration: Z[48],
+		TypeParameterInstantiation: Z[48],
+		TypePredicate: Z[49],
+		UnaryExpression: Z[6],
+		UndefinedTypeAnnotation: Z[1],
+		UnionTypeAnnotation: Z[36],
+		UnknownTypeAnnotation: Z[1],
+		UpdateExpression: Z[6],
+		V8IntrinsicIdentifier: Z[1],
+		VariableDeclaration: ["declarations"],
+		VariableDeclarator: Z[27],
+		Variance: Z[1],
+		VoidPattern: Z[1],
+		VoidTypeAnnotation: Z[1],
+		WhileStatement: Z[25],
+		WithStatement: ["object", "body"],
+		YieldExpression: Z[6]
+	}), $n = Ne, Vn([
+		"RegExpLiteral",
+		"BigIntLiteral",
+		"NumericLiteral",
+		"StringLiteral",
+		"DirectiveLiteral",
+		"Literal",
+		"JSXText",
+		"TemplateElement",
+		"StringLiteralTypeAnnotation",
+		"NumberLiteralTypeAnnotation",
+		"BigIntLiteralTypeAnnotation"
+	]), er = Pe, tr = String.prototype.replaceAll ?? function(e, t) {
+		return e.global ? this.replace(e, t) : this.split(e).join(t);
+	}, nr = Ln("replaceAll", function() {
+		if (typeof this == "string") return tr;
+	}), rr = /\*\/$/, ir = /^\/\*\*?/, ar = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, or = /(^|\s+)\/\/([^\n\r]*)/g, sr = /^(\r?\n)+/, cr = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g, lr = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g, ur = /(\r?\n|^) *\* ?/g, dr = [], fr = ["noformat", "noprettier"], pr = ["format", "prettier"], mr = ze, hr = Ue, gr = "module", _r = "script", vr = "commonjs", yr = [gr, vr], br = {
+		ecmaVersion: "latest",
+		allowReserved: !0,
+		allowReturnOutsideFunction: !0,
+		allowSuperOutsideMethod: !0,
+		checkPrivateFields: !1,
+		locations: !1,
+		ranges: !0,
+		preserveParens: !0
+	}, Sr = () => (xr ??= N.extend((0, Fn.default)()), xr), Cr = hr(qe), wr = pt(ht(), 1), Q = {
+		Boolean: "Boolean",
+		EOF: "<end>",
+		Identifier: "Identifier",
+		PrivateIdentifier: "PrivateIdentifier",
+		Keyword: "Keyword",
+		Null: "Null",
+		Numeric: "Numeric",
+		Punctuator: "Punctuator",
+		String: "String",
+		RegularExpression: "RegularExpression",
+		Template: "Template",
+		JSXIdentifier: "JSXIdentifier",
+		JSXText: "JSXText"
+	}, Ye.prototype = {
+		constructor: Ye,
+		translate(e, t) {
+			let n = e.type, r = this._acornTokTypes;
+			if (n === r.name) e.type = Q.Identifier, e.value === "static" && (e.type = Q.Keyword), t.ecmaVersion > 5 && (e.value === "yield" || e.value === "let") && (e.type = Q.Keyword);
+			else if (n === r.privateId) e.type = Q.PrivateIdentifier;
+			else if (n === r.semi || n === r.comma || n === r.parenL || n === r.parenR || n === r.braceL || n === r.braceR || n === r.dot || n === r.bracketL || n === r.colon || n === r.question || n === r.bracketR || n === r.ellipsis || n === r.arrow || n === r.jsxTagStart || n === r.incDec || n === r.starstar || n === r.jsxTagEnd || n === r.prefix || n === r.questionDot || n.binop && !n.keyword || n.isAssign) e.type = Q.Punctuator, e.value = this._code.slice(e.start, e.end);
+			else if (n === r.jsxName) e.type = Q.JSXIdentifier;
+			else if (n.label === "jsxText" || n === r.jsxAttrValueToken) e.type = Q.JSXText;
+			else if (n.keyword) n.keyword === "true" || n.keyword === "false" ? e.type = Q.Boolean : n.keyword === "null" ? e.type = Q.Null : e.type = Q.Keyword;
+			else if (n === r.num) e.type = Q.Numeric, e.value = this._code.slice(e.start, e.end);
+			else if (n === r.string) t.jsxAttrValueToken ? (t.jsxAttrValueToken = !1, e.type = Q.JSXText) : e.type = Q.String, e.value = this._code.slice(e.start, e.end);
+			else if (n === r.regexp) {
+				e.type = Q.RegularExpression;
+				let t = e.value;
+				e.regex = {
+					flags: t.flags,
+					pattern: t.pattern
+				}, e.value = `/${t.pattern}/${t.flags}`;
+			}
+			return e;
+		},
+		onToken(e, t) {
+			let n = this._acornTokTypes, r = t.tokens, i = this._tokens, a = () => {
+				r.push(Je(this._tokens, this._code)), this._tokens = [];
+			};
+			if (e.type === n.eof) {
+				this._curlyBrace && r.push(this.translate(this._curlyBrace, t));
+				return;
+			}
+			if (e.type === n.backQuote) {
+				this._curlyBrace &&= (r.push(this.translate(this._curlyBrace, t)), null), i.push(e), i.length > 1 && a();
+				return;
+			}
+			if (e.type === n.dollarBraceL) {
+				i.push(e), a();
+				return;
+			}
+			if (e.type === n.braceR) {
+				this._curlyBrace && r.push(this.translate(this._curlyBrace, t)), this._curlyBrace = e;
+				return;
+			}
+			if (e.type === n.template || e.type === n.invalidTemplate) {
+				this._curlyBrace &&= (i.push(this._curlyBrace), null), i.push(e);
+				return;
+			}
+			this._curlyBrace &&= (r.push(this.translate(this._curlyBrace, t)), null), r.push(this.translate(e, t));
+		}
+	}, Tr = Ye, Er = [
+		3,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15,
+		16,
+		17
+	], $ = Symbol("espree's internal state"), Dr = Symbol("espree's esprimaFinishNode"), Or = () => (e) => {
+		let t = Object.assign({}, e.acorn.tokTypes);
+		return e.acornJsx && Object.assign(t, e.acornJsx.tokTypes), class extends e {
+			constructor(e, n) {
+				(typeof e != "object" || !e) && (e = {}), typeof n != "string" && !(n instanceof String) && (n = String(n));
+				let r = e.sourceType, i = $e(e), a = i.ecmaFeatures || {}, o = i.tokens === !0 ? new Tr(t, n) : null, s = {
+					originalSourceType: r || i.sourceType,
+					tokens: o ? [] : null,
+					comments: i.comment === !0 ? [] : null,
+					impliedStrict: a.impliedStrict === !0 && i.ecmaVersion >= 5,
+					ecmaVersion: i.ecmaVersion,
+					jsxAttrValueToken: !1,
+					lastToken: null,
+					templateElements: []
+				};
+				super({
+					ecmaVersion: i.ecmaVersion,
+					sourceType: i.sourceType,
+					ranges: i.ranges,
+					locations: i.locations,
+					allowReserved: i.allowReserved,
+					allowReturnOutsideFunction: i.allowReturnOutsideFunction,
+					onToken(e) {
+						o && o.onToken(e, s), e.type !== t.eof && (s.lastToken = e);
+					},
+					onComment(e, t, r, i, a, o) {
+						if (s.comments) {
+							let c = et(e, t, r, i, a, o, n);
+							s.comments.push(c);
+						}
+					}
+				}, n), this[$] = s;
+			}
+			tokenize() {
+				do
+					this.next();
+				while (this.type !== t.eof);
+				this.next();
+				let e = this[$], n = e.tokens;
+				return e.comments && (n.comments = e.comments), n;
+			}
+			finishNode(...e) {
+				let t = super.finishNode(...e);
+				return this[Dr](t);
+			}
+			finishNodeAt(...e) {
+				let t = super.finishNodeAt(...e);
+				return this[Dr](t);
+			}
+			parse() {
+				let e = this[$], t = super.parse();
+				return t.sourceType = e.originalSourceType, e.comments && (t.comments = e.comments), e.tokens && (t.tokens = e.tokens), this[$].templateElements.forEach((e) => {
+					let t = e.tail ? 1 : 2;
+					e.start += -1, e.end += t, e.range && (e.range[0] += -1, e.range[1] += t), e.loc && (e.loc.start.column += -1, e.loc.end.column += t);
+				}), t;
+			}
+			parseTopLevel(e) {
+				return this[$].impliedStrict && (this.strict = !0), super.parseTopLevel(e);
+			}
+			raise(t, n) {
+				let r = e.acorn.getLineInfo(this.input, t), i = SyntaxError(n);
+				throw i.index = t, i.lineNumber = r.line, i.column = r.column + 1, i;
+			}
+			raiseRecoverable(e, t) {
+				this.raise(e, t);
+			}
+			unexpected(e) {
+				let t = "Unexpected token";
+				if (e != null) {
+					if (this.pos = e, this.options.locations) for (; this.pos < this.lineStart;) this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1, --this.curLine;
+					this.nextToken();
+				}
+				this.end > this.start && (t += ` ${this.input.slice(this.start, this.end)}`), this.raise(this.start, t);
+			}
+			jsx_readString(e) {
+				let n = super.jsx_readString(e);
+				return this.type === t.string && (this[$].jsxAttrValueToken = !0), n;
+			}
+			[Dr](e) {
+				return e.type === "TemplateElement" && this[$].templateElements.push(e), e.type.includes("Function") && !e.generator && (e.generator = !1), e;
+			}
+		};
+	}, kr = {
+		_regular: null,
+		_jsx: null,
+		get regular() {
+			return this._regular === null && (this._regular = N.extend(Or())), this._regular;
+		},
+		get jsx() {
+			return this._jsx === null && (this._jsx = N.extend((0, wr.default)(), Or())), this._jsx;
+		},
+		get(e) {
+			return e && e.ecmaFeatures && e.ecmaFeatures.jsx ? this.jsx : this.regular;
+		}
+	}, Ar = {
+		ecmaVersion: "latest",
+		range: !0,
+		loc: !1,
+		comment: !0,
+		tokens: !1,
+		ecmaFeatures: {
+			jsx: !0,
+			impliedStrict: !1
+		}
+	}, jr = {
+		acorn: Cr,
+		espree: hr(rt)
+	};
+}))();
+export { gt as default, jr as parsers };