driftjs-compiler 0.0.0

package/dist/index-es.js

@@ -0,0 +1,4804 @@
+//#region types/token.ts
+var e = {
+	TagOpen: "TagOpen",
+	TagOpenSlash: "TagOpenSlash",
+	TagClose: "TagClose",
+	TagSelfClose: "TagSelfClose",
+	Equals: "Equals",
+	Identifier: "Identifier",
+	StringLiteral: "StringLiteral",
+	Text: "Text",
+	Interpolation: "Interpolation",
+	Comment: "Comment",
+	DirectiveIf: "DirectiveIf",
+	DirectiveElseIf: "DirectiveElseIf",
+	DirectiveElse: "DirectiveElse",
+	DirectiveFor: "DirectiveFor",
+	DirectiveSwitch: "DirectiveSwitch",
+	DirectiveCase: "DirectiveCase",
+	DirectiveDefault: "DirectiveDefault",
+	BlockOpen: "BlockOpen",
+	BlockClose: "BlockClose",
+	EOF: "EOF"
+}, t = {
+	Data: "Data",
+	TagOpen: "TagOpen",
+	EndTagOpen: "EndTagOpen",
+	BeforeAttributeName: "BeforeAttributeName",
+	AttributeName: "AttributeName",
+	AfterAttributeName: "AfterAttributeName",
+	BeforeAttributeValue: "BeforeAttributeValue",
+	AttributeValueQuoted: "AttributeValueQuoted",
+	AttributeValueInterpolation: "AttributeValueInterpolation",
+	Comment: "Comment",
+	Interpolation: "Interpolation",
+	RawText: "RawText",
+	EOF: "EOF"
+}, n = {
+	Program: "Program",
+	Element: "Element",
+	Text: "Text",
+	Interpolation: "Interpolation",
+	Attribute: "Attribute",
+	Comment: "Comment",
+	If: "If",
+	For: "For",
+	Switch: "Switch"
+}, r = class extends Error {
+	line;
+	column;
+	offset;
+	constructor(e, t, n, r) {
+		super(`LexerError [${t}:${n}]: ${e}`), this.line = t, this.column = n, this.offset = r, this.name = "DriftLexerError";
+	}
+}, i = class extends Error {
+	line;
+	column;
+	offset;
+	constructor(e, t, n, r) {
+		super(`ParserError [${t}:${n}]: ${e}`), this.line = t, this.column = n, this.offset = r, this.name = "DriftParserError";
+	}
+}, a = /* @__PURE__ */ function(e) {
+	return e[e.RETURN = 0] = "RETURN", e[e.CREATE_ELEMENT = 1] = "CREATE_ELEMENT", e[e.CREATE_TEXT = 2] = "CREATE_TEXT", e[e.CREATE_COMMENT = 3] = "CREATE_COMMENT", e[e.APPEND_CHILD = 4] = "APPEND_CHILD", e[e.SET_ATTR = 5] = "SET_ATTR", e[e.CREATE_FRAGMENT = 6] = "CREATE_FRAGMENT", e[e.INTERPOLATE_TEXT = 7] = "INTERPOLATE_TEXT", e[e.JUMP = 8] = "JUMP", e[e.JUMP_IF_FALSE = 9] = "JUMP_IF_FALSE", e[e.EVAL_EXPR = 10] = "EVAL_EXPR", e[e.LOOP_ITER = 11] = "LOOP_ITER", e[e.EXEC_SCRIPT = 12] = "EXEC_SCRIPT", e[e.REACTIVE_IF = 13] = "REACTIVE_IF", e[e.REACTIVE_FOR = 14] = "REACTIVE_FOR", e;
+}({}), o = {
+	[t.Data]: [
+		{
+			to: t.Comment,
+			when: "The next characters are <!--",
+			emits: "Comment"
+		},
+		{
+			to: t.EndTagOpen,
+			when: "The next characters are </",
+			emits: "TagOpenSlash"
+		},
+		{
+			to: t.TagOpen,
+			when: "The next character is '<' for a start tag",
+			emits: "TagOpen"
+		},
+		{
+			to: t.Interpolation,
+			when: "The next character is '{' in element content",
+			emits: "Interpolation"
+		},
+		{
+			to: t.Data,
+			when: "Plain content is consumed up to the next control delimiter",
+			emits: "Text"
+		},
+		{
+			to: t.EOF,
+			when: "The source has been fully consumed",
+			emits: "EOF"
+		}
+	],
+	[t.TagOpen]: [{
+		to: t.BeforeAttributeName,
+		when: "A valid opening tag name is consumed",
+		emits: "Identifier"
+	}],
+	[t.EndTagOpen]: [{
+		to: t.BeforeAttributeName,
+		when: "A valid closing tag name is consumed",
+		emits: "Identifier"
+	}],
+	[t.BeforeAttributeName]: [
+		{
+			to: t.AttributeName,
+			when: "An attribute name begins in an opening tag",
+			emits: "Identifier"
+		},
+		{
+			to: t.Data,
+			when: "A tag is closed with '>' and raw-text mode does not apply",
+			emits: "TagClose"
+		},
+		{
+			to: t.RawText,
+			when: "A script/style start tag is closed with '>'",
+			emits: "TagClose"
+		},
+		{
+			to: t.Data,
+			when: "A tag is self-closed with '/>'",
+			emits: "TagSelfClose"
+		}
+	],
+	[t.AttributeName]: [{
+		to: t.AfterAttributeName,
+		when: "The attribute identifier has been fully consumed",
+		emits: "Identifier"
+	}],
+	[t.AfterAttributeName]: [{
+		to: t.BeforeAttributeValue,
+		when: "The next character is '='",
+		emits: "Equals"
+	}, {
+		to: t.BeforeAttributeName,
+		when: "The attribute is boolean and the lexer moves to the next attribute or tag boundary",
+		emits: "No token"
+	}],
+	[t.BeforeAttributeValue]: [{
+		to: t.AttributeValueQuoted,
+		when: "The attribute value starts with a quote",
+		emits: "StringLiteral"
+	}, {
+		to: t.AttributeValueInterpolation,
+		when: "The attribute value starts with '{'",
+		emits: "Interpolation"
+	}],
+	[t.AttributeValueQuoted]: [{
+		to: t.BeforeAttributeName,
+		when: "The closing quote is consumed",
+		emits: "StringLiteral"
+	}],
+	[t.AttributeValueInterpolation]: [{
+		to: t.BeforeAttributeName,
+		when: "The interpolation closes and the attribute value is complete",
+		emits: "Interpolation"
+	}],
+	[t.Comment]: [{
+		to: t.Data,
+		when: "The terminating --> delimiter is consumed",
+		emits: "Comment"
+	}],
+	[t.Interpolation]: [{
+		to: t.Data,
+		when: "A content interpolation closes with a matching brace",
+		emits: "Interpolation"
+	}, {
+		to: t.BeforeAttributeName,
+		when: "An attribute interpolation closes with a matching brace",
+		emits: "Interpolation"
+	}],
+	[t.RawText]: [
+		{
+			to: t.RawText,
+			when: "Plain raw-text content is consumed before the matching closing tag",
+			emits: "Text"
+		},
+		{
+			to: t.EndTagOpen,
+			when: "The matching raw-text closing tag begins with </",
+			emits: "TagOpenSlash"
+		},
+		{
+			to: t.EOF,
+			when: "The raw-text block reaches end of input before a closing tag appears",
+			emits: "EOF"
+		}
+	],
+	[t.EOF]: [{
+		to: t.EOF,
+		when: "Additional parser requests are made after end of input",
+		emits: "EOF"
+	}]
+};
+function s(e) {
+	return e === "script" || e === "style";
+}
+var c = /* @__PURE__ */ new Set([
+	"if",
+	"else",
+	"for",
+	"switch",
+	"case",
+	"default"
+]), l = class {
+	source;
+	offset = 0;
+	line = 1;
+	column = 1;
+	emittedTokenCount = 0;
+	eofToken = null;
+	state = { kind: t.Data };
+	blockDepth = 0;
+	constructor(e) {
+		this.source = e;
+	}
+	nextToken() {
+		let e = this.readNextToken();
+		return this.emittedTokenCount++, e;
+	}
+	getCurrentState() {
+		return this.state;
+	}
+	getEmittedTokenCount() {
+		return this.emittedTokenCount;
+	}
+	readNextToken() {
+		switch (this.state.kind) {
+			case t.Data: return this.readDataToken();
+			case t.TagOpen: return this.readTagNameToken(!1);
+			case t.EndTagOpen: return this.readTagNameToken(!0);
+			case t.BeforeAttributeName: return this.readBeforeAttributeNameToken();
+			case t.AttributeName: return this.readAttributeNameToken();
+			case t.AfterAttributeName: return this.readAfterAttributeNameToken();
+			case t.BeforeAttributeValue: return this.readBeforeAttributeValueToken();
+			case t.Comment:
+			case t.Interpolation:
+			case t.AttributeValueQuoted:
+			case t.AttributeValueInterpolation: throw Error(`Lexer entered transient state '${this.state.kind}' unexpectedly.`);
+			case t.RawText: return this.readRawTextToken();
+			case t.EOF: return this.getOrCreateEOFToken();
+		}
+	}
+	readDataToken() {
+		let n = this.getLocation();
+		return this.isAtEnd() ? (this.transitionTo({ kind: t.EOF }), this.getOrCreateEOFToken(n)) : this.startsWith("<!--") ? (this.consumePattern("<!--"), this.transitionTo({ kind: t.Comment }), this.readCommentToken(n)) : this.startsWith("</") ? (this.consumePattern("</"), this.transitionTo({ kind: t.EndTagOpen }), this.createToken(e.TagOpenSlash, "</", n)) : this.peek() === "<" ? (this.advance(), this.transitionTo({ kind: t.TagOpen }), this.createToken(e.TagOpen, "<", n)) : this.peek() === "{" ? (this.advance(), this.transitionTo({
+			kind: t.Interpolation,
+			context: "content",
+			tagName: null
+		}), this.readInterpolationToken(n, "content", null)) : this.peek() === "}" && this.blockDepth > 0 ? (this.advance(), this.blockDepth--, this.createToken(e.BlockClose, "}", n)) : this.peek() === "@" ? this.readDirectiveToken(n) : this.readTextToken();
+	}
+	readDirectiveToken(t) {
+		this.advance();
+		let n = "";
+		for (; !this.isAtEnd() && /[a-zA-Z]/.test(this.peek());) n += this.advance();
+		if (!c.has(n)) throw new r(`Unknown directive '@${n}'`, t.line, t.column, t.offset);
+		if (n === "if") return this.readDirectiveHeader(t, e.DirectiveIf);
+		if (n === "else") {
+			if (this.skipWhitespace(), this.startsWith("if") && !/[a-zA-Z0-9_]/.test(this.peek(2))) return this.consumePattern("if"), this.readDirectiveHeader(t, e.DirectiveElseIf);
+			if (this.skipWhitespace(), this.peek() === "{") return this.advance(), this.blockDepth++, this.createToken(e.DirectiveElse, "", t);
+			throw new r("Expected '{' after @else directive", t.line, t.column, t.offset);
+		} else if (n === "for") return this.readDirectiveHeader(t, e.DirectiveFor);
+		else if (n === "switch") return this.readDirectiveHeader(t, e.DirectiveSwitch);
+		else if (n === "case") return this.readDirectiveHeader(t, e.DirectiveCase);
+		else return this.skipWhitespace(), this.peek() === "{" && (this.advance(), this.blockDepth++), this.createToken(e.DirectiveDefault, "", t);
+	}
+	readDirectiveHeader(e, t) {
+		this.skipWhitespace();
+		let n = "", i = 0, a = null, o = !1, s = !1, c = !1, l = !1, u = !1;
+		for (; !this.isAtEnd();) {
+			let r = this.advance();
+			if (s) {
+				n += r, r === "\n" && (s = !1);
+				continue;
+			}
+			if (c) {
+				n += r, r === "/" && n.endsWith("*/") && (c = !1);
+				continue;
+			}
+			if (l) {
+				n += r, o ? o = !1 : r === "\\" ? o = !0 : r === "[" ? u = !0 : r === "]" && u ? u = !1 : r === "/" && !u && (l = !1);
+				continue;
+			}
+			if (a !== null) {
+				n += r, o ? o = !1 : r === "\\" ? o = !0 : r === a && (a = null);
+				continue;
+			}
+			if (r === "/" && !o) {
+				let e = this.peek();
+				if (e === "/") {
+					s = !0, n += r;
+					continue;
+				} else if (e === "*") {
+					c = !0, n += r;
+					continue;
+				} else if (this.isRegexStart(n)) {
+					l = !0, u = !1, n += r;
+					continue;
+				}
+			}
+			if (r === "\"" || r === "'" || r === "`") {
+				a = r, n += r;
+				continue;
+			}
+			if (r === "(") {
+				i++, n += r;
+				continue;
+			}
+			if (r === ")") {
+				i > 0 && i--, n += r;
+				continue;
+			}
+			if (r === "{" && i === 0) return this.blockDepth++, this.createToken(t, n.trim(), e);
+			n += r;
+		}
+		throw new r("Unterminated directive header, expected '{'", e.line, e.column, e.offset);
+	}
+	readTagNameToken(n) {
+		if (this.isAtEnd()) throw this.createUnexpectedEOFError(n ? "after closing tag opener" : "after opening tag opener");
+		let i = this.getLocation(), a = this.peek();
+		if (!this.isIdentifierStart(a)) throw new r(`Expected tag name but found '${a || "EOF"}'`, i.line, i.column, i.offset);
+		let o = this.readIdentifierValue(), c = !n && s(o);
+		return this.transitionTo({
+			kind: t.BeforeAttributeName,
+			tagName: o,
+			isClosingTag: n,
+			entersRawText: c
+		}), this.createToken(e.Identifier, o, i);
+	}
+	readBeforeAttributeNameToken() {
+		let n = this.state;
+		if (n.kind !== t.BeforeAttributeName) throw Error(`Expected BeforeAttributeName state but found '${n.kind}'.`);
+		if (this.skipWhitespace(), this.isAtEnd()) throw this.createUnexpectedEOFError(`inside tag <${n.tagName}>`);
+		let i = this.getLocation();
+		if (n.isClosingTag) {
+			if (this.peek() !== ">") throw new r(`Unexpected character '${this.peek()}' inside closing tag </${n.tagName}>`, i.line, i.column, i.offset);
+			return this.advance(), this.transitionTo({ kind: t.Data }), this.createToken(e.TagClose, ">", i);
+		}
+		if (this.peek() === ">") return this.advance(), n.entersRawText && s(n.tagName) ? this.transitionTo({
+			kind: t.RawText,
+			tagName: n.tagName
+		}) : this.transitionTo({ kind: t.Data }), this.createToken(e.TagClose, ">", i);
+		if (this.peek() === "/" && this.peek(1) === ">") return this.advance(), this.advance(), this.transitionTo({ kind: t.Data }), this.createToken(e.TagSelfClose, "/>", i);
+		if (!this.isIdentifierStart(this.peek())) throw new r(`Unexpected character '${this.peek()}' inside tag <${n.tagName}>`, i.line, i.column, i.offset);
+		return this.transitionTo({
+			kind: t.AttributeName,
+			tagName: n.tagName,
+			attributeName: null
+		}), this.readAttributeNameToken();
+	}
+	readAttributeNameToken() {
+		let n = this.state;
+		if (n.kind !== t.AttributeName) throw Error(`Expected AttributeName state but found '${n.kind}'.`);
+		let i = this.getLocation();
+		if (!this.isIdentifierStart(this.peek())) throw new r(`Expected attribute name but found '${this.peek() || "EOF"}'`, i.line, i.column, i.offset);
+		let a = this.readIdentifierValue(), o = n.tagName;
+		return this.transitionTo({
+			kind: t.AfterAttributeName,
+			tagName: o,
+			attributeName: a
+		}), this.createToken(e.Identifier, a, i);
+	}
+	readAfterAttributeNameToken() {
+		let n = this.state;
+		if (n.kind !== t.AfterAttributeName) throw Error(`Expected AfterAttributeName state but found '${n.kind}'.`);
+		let r = n.tagName, i = n.attributeName;
+		if (this.skipWhitespace(), this.isAtEnd()) throw this.createUnexpectedEOFError(`after attribute '${i}' in <${r}>`);
+		if (this.peek() === "=") {
+			let n = this.getLocation();
+			return this.advance(), this.transitionTo({
+				kind: t.BeforeAttributeValue,
+				tagName: r,
+				attributeName: i
+			}), this.createToken(e.Equals, "=", n);
+		}
+		return this.transitionTo({
+			kind: t.BeforeAttributeName,
+			tagName: r,
+			isClosingTag: !1,
+			entersRawText: s(r)
+		}), this.readBeforeAttributeNameToken();
+	}
+	readBeforeAttributeValueToken() {
+		let e = this.state;
+		if (e.kind !== t.BeforeAttributeValue) throw Error(`Expected BeforeAttributeValue state but found '${e.kind}'.`);
+		let n = e.tagName, i = e.attributeName;
+		if (this.skipWhitespace(), this.isAtEnd()) throw this.createUnexpectedEOFError(`before value for attribute '${i}' in <${n}>`);
+		let a = this.getLocation(), o = this.peek();
+		if (o === "\"" || o === "'") return this.advance(), this.transitionTo({
+			kind: t.AttributeValueQuoted,
+			tagName: n,
+			attributeName: i,
+			quote: o
+		}), this.readQuotedStringToken(a, o, n);
+		if (o === "{") return this.advance(), this.transitionTo({
+			kind: t.AttributeValueInterpolation,
+			tagName: n,
+			attributeName: i
+		}), this.readInterpolationToken(a, "attribute", n);
+		throw new r(`Expected quoted string or interpolation for attribute '${i}' in <${n}>`, a.line, a.column, a.offset);
+	}
+	readCommentToken(n) {
+		let i = "";
+		for (; !this.isAtEnd();) {
+			if (this.startsWith("-->")) return this.consumePattern("-->"), this.transitionTo({ kind: t.Data }), this.createToken(e.Comment, i, n);
+			i += this.advance();
+		}
+		throw new r("Unterminated XML comment", n.line, n.column, n.offset);
+	}
+	isRegexStart(e) {
+		let t = e.trimEnd();
+		if (t.length === 0) return !0;
+		let n = t[t.length - 1];
+		if ("=(,:;!&|?[{}+-*%<>~^".includes(n)) return !0;
+		let r = t.split(/\s+/).pop();
+		return !!(r && [
+			"return",
+			"yield",
+			"await",
+			"case",
+			"typeof",
+			"void",
+			"delete",
+			"instanceof",
+			"in",
+			"do"
+		].includes(r));
+	}
+	readInterpolationToken(n, i, a) {
+		let o = 1, c = null, l = !1, u = !1, d = !1, f = !1, p = !1, m = [], h = "";
+		for (; !this.isAtEnd();) {
+			let r = this.advance();
+			if (u) {
+				h += r, r === "\n" && (u = !1);
+				continue;
+			}
+			if (d) {
+				h += r, r === "/" && h.endsWith("*/") && (d = !1);
+				continue;
+			}
+			if (f) {
+				h += r, l ? l = !1 : r === "\\" ? l = !0 : r === "[" ? p = !0 : r === "]" && p ? p = !1 : r === "/" && !p && (f = !1);
+				continue;
+			}
+			if (c !== null) {
+				h += r, l ? l = !1 : r === "\\" ? l = !0 : r === c ? c = null : c === "`" && r === "{" && h.endsWith("${") && (m.push(o), c = null, o++);
+				continue;
+			}
+			if (r === "/" && !l) {
+				let e = this.peek();
+				if (e === "/") {
+					u = !0, h += r;
+					continue;
+				} else if (e === "*") {
+					d = !0, h += r;
+					continue;
+				} else if (this.isRegexStart(h)) {
+					f = !0, p = !1, h += r;
+					continue;
+				}
+			}
+			if (r === "\"" || r === "'" || r === "`") {
+				c = r, h += r;
+				continue;
+			}
+			if (r === "{") {
+				o++, h += r;
+				continue;
+			}
+			if (r === "}") {
+				if (o--, m.length > 0 && o === m[m.length - 1] && (m.pop(), c = "`"), o === 0) return i === "attribute" && a !== null ? this.transitionTo({
+					kind: t.BeforeAttributeName,
+					tagName: a,
+					isClosingTag: !1,
+					entersRawText: s(a)
+				}) : this.transitionTo({ kind: t.Data }), this.createToken(e.Interpolation, h, n);
+				h += r;
+				continue;
+			}
+			h += r;
+		}
+		throw new r("Unterminated interpolation expression, expected closing brace '}'", n.line, n.column, n.offset);
+	}
+	readRawTextToken() {
+		let n = this.state;
+		if (n.kind !== t.RawText) throw Error(`Expected RawText state but found '${n.kind}'.`);
+		let r = this.getLocation(), i = `</${n.tagName}`;
+		if (this.isAtEnd()) return this.transitionTo({ kind: t.EOF }), this.getOrCreateEOFToken(r);
+		if (this.isRawTextClosingTagAhead(i)) return this.consumePattern("</"), this.transitionTo({ kind: t.EndTagOpen }), this.createToken(e.TagOpenSlash, "</", r);
+		let a = "";
+		for (; !this.isAtEnd() && !this.isRawTextClosingTagAhead(i);) a += this.advance();
+		return a.length > 0 ? this.createToken(e.Text, a, r) : (this.transitionTo({ kind: t.EOF }), this.getOrCreateEOFToken(r));
+	}
+	readTextToken() {
+		let t = this.getLocation(), n = "";
+		for (; !this.isAtEnd();) {
+			let e = this.peek();
+			if (e === "<" || e === "{" || e === "@" || e === "}" && this.blockDepth > 0) break;
+			n += this.advance();
+		}
+		return this.createToken(e.Text, n, t);
+	}
+	readQuotedStringToken(n, i, a) {
+		let o = "";
+		for (; !this.isAtEnd();) {
+			if (this.peek() === i) return this.advance(), this.transitionTo({
+				kind: t.BeforeAttributeName,
+				tagName: a,
+				isClosingTag: !1,
+				entersRawText: s(a)
+			}), this.createToken(e.StringLiteral, o, n);
+			o += this.advance();
+		}
+		throw new r(`Unterminated string literal, expected closing quote ${i}`, n.line, n.column, n.offset);
+	}
+	readIdentifierValue() {
+		let e = "";
+		for (; !this.isAtEnd() && this.isIdentifierChar(this.peek());) e += this.advance();
+		return e;
+	}
+	getOrCreateEOFToken(t = this.getLocation()) {
+		return this.eofToken === null && (this.eofToken = {
+			type: e.EOF,
+			value: "",
+			loc: {
+				start: t,
+				end: t
+			}
+		}), this.eofToken;
+	}
+	createToken(e, t, n) {
+		return {
+			type: e,
+			value: t,
+			loc: {
+				start: n,
+				end: this.getLocation()
+			}
+		};
+	}
+	createUnexpectedEOFError(e) {
+		let t = this.getLocation();
+		return new r(`Unexpected end of input ${e}`, t.line, t.column, t.offset);
+	}
+	transitionTo(e) {
+		if (!o[this.state.kind].some((t) => t.to === e.kind)) throw Error(`Invalid lexer transition from '${this.state.kind}' to '${e.kind}'.`);
+		this.state = e;
+	}
+	getLocation() {
+		return {
+			line: this.line,
+			column: this.column,
+			offset: this.offset
+		};
+	}
+	isAtEnd() {
+		return this.offset >= this.source.length;
+	}
+	peek(e = 0) {
+		let t = this.offset + e;
+		return t >= this.source.length ? "" : this.source[t] ?? "";
+	}
+	advance() {
+		let e = this.source[this.offset] ?? "";
+		return this.offset++, e === "\n" ? (this.line++, this.column = 1) : this.column++, e;
+	}
+	startsWith(e) {
+		return this.source.startsWith(e, this.offset);
+	}
+	consumePattern(e) {
+		for (let t = 0; t < e.length; t++) this.advance();
+	}
+	skipWhitespace() {
+		for (; !this.isAtEnd();) {
+			let e = this.peek();
+			if (e === " " || e === "	" || e === "\r" || e === "\n") this.advance();
+			else break;
+		}
+	}
+	isIdentifierStart(e) {
+		if (e.length === 0) return !1;
+		let t = e.charCodeAt(0);
+		return t >= 65 && t <= 90 || t >= 97 && t <= 122;
+	}
+	isIdentifierChar(e) {
+		if (e.length === 0) return !1;
+		let t = e.charCodeAt(0);
+		return t >= 65 && t <= 90 || t >= 97 && t <= 122 || t >= 48 && t <= 57 || t === 95 || t === 45;
+	}
+	isRawTextClosingTagAhead(e) {
+		if (!this.startsWith(e)) return !1;
+		let t = this.peek(e.length);
+		return t === "" || t === ">" || t === " " || t === "	" || t === "\r" || t === "\n";
+	}
+}, u = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]), d = class {
+	tokens;
+	current = 0;
+	constructor(e) {
+		this.tokens = e;
+	}
+	nextToken() {
+		if (this.current >= this.tokens.length) return this.tokens[this.tokens.length - 1];
+		let e = this.tokens[this.current];
+		return this.current++, e;
+	}
+}, f = class {
+	tokenSource;
+	lookahead = [];
+	constructor(e) {
+		this.tokenSource = Array.isArray(e) ? new d(e) : e;
+	}
+	parse() {
+		return this.lookahead.length = 0, this.parseProgram();
+	}
+	parseProgram() {
+		let e = this.peek().loc.start, t = [];
+		for (; !this.isAtEnd();) t.push(this.parseChild());
+		let r = this.peek().loc.end;
+		return {
+			type: n.Program,
+			body: t,
+			loc: {
+				start: e,
+				end: r
+			}
+		};
+	}
+	parseChild() {
+		let t = this.peek();
+		if (t.type === e.Comment) return this.advance(), {
+			type: n.Comment,
+			content: t.value,
+			loc: t.loc
+		};
+		if (t.type === e.Interpolation) return this.advance(), {
+			type: n.Interpolation,
+			expression: t.value,
+			loc: t.loc
+		};
+		if (t.type === e.TagOpen) return this.parseElement();
+		if (t.type === e.DirectiveIf) return this.parseIfDirective();
+		if (t.type === e.DirectiveFor) return this.parseForDirective();
+		if (t.type === e.DirectiveSwitch) return this.parseSwitchDirective();
+		if (t.type === e.Text) return this.advance(), {
+			type: n.Text,
+			content: t.value,
+			loc: t.loc
+		};
+		throw t.type === e.TagOpenSlash ? new i(`Unexpected closing tag '</${this.peek(1).value}>' without opening tag`, t.loc.start.line, t.loc.start.column, t.loc.start.offset) : new i(`Unexpected token '${t.value}' of type '${t.type}'`, t.loc.start.line, t.loc.start.column, t.loc.start.offset);
+	}
+	parseElement() {
+		let t = this.consume(e.TagOpen, "Expected opening tag bracket").loc.start, r = this.consume(e.Identifier, "Expected tag name after opening bracket").value, a = [];
+		for (; !this.check(e.TagClose) && !this.check(e.TagSelfClose) && !this.isAtEnd();) a.push(this.parseAttribute());
+		if (this.check(e.TagSelfClose)) {
+			let e = this.advance();
+			return {
+				type: n.Element,
+				tagName: r,
+				attributes: a,
+				children: [],
+				isSelfClosing: !0,
+				loc: {
+					start: t,
+					end: e.loc.end
+				}
+			};
+		}
+		let o = this.consume(e.TagClose, "Expected closing bracket after attributes");
+		if (u.has(r.toLowerCase())) return {
+			type: n.Element,
+			tagName: r,
+			attributes: a,
+			children: [],
+			isSelfClosing: !0,
+			loc: {
+				start: t,
+				end: o.loc.end
+			}
+		};
+		let s = [];
+		for (; !this.check(e.TagOpenSlash) && !this.isAtEnd();) s.push(this.parseChild());
+		if (this.isAtEnd()) throw new i(`Unclosed element '<${r}>', expected closing tag '</${r}>'`, t.line, t.column, t.offset);
+		this.consume(e.TagOpenSlash, `Expected closing tag '</${r}>'`);
+		let c = this.consume(e.Identifier, "Expected closing tag name");
+		if (c.value !== r) throw new i(`Mismatched closing tag. Expected '</${r}>' but got '</${c.value}>'`, c.loc.start.line, c.loc.start.column, c.loc.start.offset);
+		let l = this.consume(e.TagClose, "Expected '>' after closing tag name");
+		return {
+			type: n.Element,
+			tagName: r,
+			attributes: a,
+			children: s,
+			isSelfClosing: !1,
+			loc: {
+				start: t,
+				end: l.loc.end
+			}
+		};
+	}
+	parseAttribute() {
+		let t = this.consume(e.Identifier, "Expected attribute name"), r = t.loc.start, a = t.value;
+		if (this.matchToken(e.Equals)) {
+			let t = this.peek();
+			if (t.type === e.StringLiteral) return this.advance(), {
+				type: n.Attribute,
+				name: a,
+				value: t.value,
+				loc: {
+					start: r,
+					end: t.loc.end
+				}
+			};
+			if (t.type === e.Interpolation) {
+				this.advance();
+				let e = {
+					type: n.Interpolation,
+					expression: t.value,
+					loc: t.loc
+				};
+				return {
+					type: n.Attribute,
+					name: a,
+					value: e,
+					loc: {
+						start: r,
+						end: t.loc.end
+					}
+				};
+			}
+			throw new i(`Expected string literal or interpolation after '=' for attribute '${a}'`, t.loc.start.line, t.loc.start.column, t.loc.start.offset);
+		}
+		return {
+			type: n.Attribute,
+			name: a,
+			value: null,
+			loc: {
+				start: r,
+				end: t.loc.end
+			}
+		};
+	}
+	parseIfDirective() {
+		let t = this.consume(e.DirectiveIf, "Expected @if directive"), r = t.loc.start, i = t.value, a = [];
+		for (; !this.check(e.BlockClose) && !this.isAtEnd();) a.push(this.parseChild());
+		let o = this.consume(e.BlockClose, "Expected closing brace } for @if block"), s = null, c = o.loc.end;
+		if (this.skipWhitespaceTokens(), this.check(e.DirectiveElseIf)) s = this.parseElseIfChain(), c = s.loc.end;
+		else if (this.check(e.DirectiveElse)) {
+			this.advance();
+			let t = [];
+			for (; !this.check(e.BlockClose) && !this.isAtEnd();) t.push(this.parseChild());
+			let n = this.consume(e.BlockClose, "Expected closing brace } for @else block");
+			s = t, c = n.loc.end;
+		}
+		return {
+			type: n.If,
+			test: i,
+			consequent: a,
+			alternate: s,
+			loc: {
+				start: r,
+				end: c
+			}
+		};
+	}
+	parseElseIfChain() {
+		let t = this.consume(e.DirectiveElseIf, "Expected @else if directive"), r = t.loc.start, i = t.value, a = [];
+		for (; !this.check(e.BlockClose) && !this.isAtEnd();) a.push(this.parseChild());
+		let o = this.consume(e.BlockClose, "Expected closing brace } for @else if block"), s = null, c = o.loc.end;
+		if (this.skipWhitespaceTokens(), this.check(e.DirectiveElseIf)) s = this.parseElseIfChain(), c = s.loc.end;
+		else if (this.check(e.DirectiveElse)) {
+			this.advance();
+			let t = [];
+			for (; !this.check(e.BlockClose) && !this.isAtEnd();) t.push(this.parseChild());
+			let n = this.consume(e.BlockClose, "Expected closing brace } for @else block");
+			s = t, c = n.loc.end;
+		}
+		return {
+			type: n.If,
+			test: i,
+			consequent: a,
+			alternate: s,
+			loc: {
+				start: r,
+				end: c
+			}
+		};
+	}
+	parseForDirective() {
+		let t = this.consume(e.DirectiveFor, "Expected @for directive"), r = t.loc.start, a = t.value, o = (() => {
+			let e = 0;
+			for (let t = 0; t <= a.length - 4; t++) {
+				let n = a[t];
+				if (n === "(") e++;
+				else if (n === ")") e--;
+				else if (e === 0 && a.slice(t, t + 4) === " in ") return t;
+			}
+			return -1;
+		})();
+		if (o === -1) throw new i(`Invalid @for header syntax '${a}'. Expected format: 'item in list' or '(item, index) in list'`, t.loc.start.line, t.loc.start.column, t.loc.start.offset);
+		let s = a.slice(0, o).trim(), c = a.slice(o + 4).trim(), l = null, u = c.match(/\s+key\s+(.+)$/);
+		u && (l = u[1].trim(), c = c.slice(0, u.index).trim());
+		let d = c, f = s, p = null;
+		if (s.startsWith("(") && s.endsWith(")")) {
+			let e = s.slice(1, -1).split(",").map((e) => e.trim());
+			f = e[0] || "", p = e[1] || null;
+		}
+		let m = [];
+		for (; !this.check(e.BlockClose) && !this.isAtEnd();) m.push(this.parseChild());
+		let h = this.consume(e.BlockClose, "Expected closing brace } for @for block");
+		return {
+			type: n.For,
+			item: f,
+			index: p,
+			iterable: d,
+			key: l,
+			body: m,
+			loc: {
+				start: r,
+				end: h.loc.end
+			}
+		};
+	}
+	parseSwitchDirective() {
+		let t = this.consume(e.DirectiveSwitch, "Expected @switch directive"), r = t.loc.start, a = t.value, o = [];
+		for (this.skipWhitespaceTokens(); !this.check(e.BlockClose) && !this.isAtEnd();) {
+			if (this.check(e.DirectiveCase)) {
+				let t = this.advance(), n = [];
+				for (; !this.check(e.BlockClose) && !this.isAtEnd();) n.push(this.parseChild());
+				let r = this.consume(e.BlockClose, "Expected closing brace } for @case block");
+				o.push({
+					expression: t.value,
+					body: n,
+					loc: {
+						start: t.loc.start,
+						end: r.loc.end
+					}
+				});
+			} else if (this.check(e.DirectiveDefault)) {
+				let t = this.advance(), n = [];
+				for (; !this.check(e.BlockClose) && !this.isAtEnd();) n.push(this.parseChild());
+				let r = this.consume(e.BlockClose, "Expected closing brace } for @default block");
+				o.push({
+					expression: null,
+					body: n,
+					loc: {
+						start: t.loc.start,
+						end: r.loc.end
+					}
+				});
+			} else throw new i(`Unexpected token '${this.peek().value}' inside @switch block. Expected @case or @default.`, this.peek().loc.start.line, this.peek().loc.start.column, this.peek().loc.start.offset);
+			this.skipWhitespaceTokens();
+		}
+		let s = this.consume(e.BlockClose, "Expected closing brace } for @switch block");
+		return {
+			type: n.Switch,
+			discriminant: a,
+			cases: o,
+			loc: {
+				start: r,
+				end: s.loc.end
+			}
+		};
+	}
+	skipWhitespaceTokens() {
+		for (; this.check(e.Text) && this.peek().value.trim().length === 0;) this.advance();
+	}
+	isAtEnd() {
+		return this.peek().type === e.EOF;
+	}
+	peek(e = 0) {
+		return this.ensureLookahead(e), this.lookahead[Math.min(e, this.lookahead.length - 1)];
+	}
+	advance() {
+		let t = this.peek();
+		return t.type !== e.EOF && this.lookahead.shift(), t;
+	}
+	check(e) {
+		return this.peek().type === e;
+	}
+	matchToken(e) {
+		return this.check(e) ? (this.advance(), !0) : !1;
+	}
+	consume(e, t) {
+		if (this.check(e)) return this.advance();
+		let n = this.peek();
+		throw new i(t, n.loc.start.line, n.loc.start.column, n.loc.start.offset);
+	}
+	ensureLookahead(t) {
+		for (; this.lookahead.length <= t;) {
+			let t = this.tokenSource.nextToken();
+			if (this.lookahead.push(t), t.type === e.EOF) break;
+		}
+	}
+}, p = [
+	509,
+	0,
+	227,
+	0,
+	150,
+	4,
+	294,
+	9,
+	1368,
+	2,
+	2,
+	1,
+	6,
+	3,
+	41,
+	2,
+	5,
+	0,
+	166,
+	1,
+	574,
+	3,
+	9,
+	9,
+	7,
+	9,
+	32,
+	4,
+	318,
+	1,
+	78,
+	5,
+	71,
+	10,
+	50,
+	3,
+	123,
+	2,
+	54,
+	14,
+	32,
+	10,
+	3,
+	1,
+	11,
+	3,
+	46,
+	10,
+	8,
+	0,
+	46,
+	9,
+	7,
+	2,
+	37,
+	13,
+	2,
+	9,
+	6,
+	1,
+	45,
+	0,
+	13,
+	2,
+	49,
+	13,
+	9,
+	3,
+	2,
+	11,
+	83,
+	11,
+	7,
+	0,
+	3,
+	0,
+	158,
+	11,
+	6,
+	9,
+	7,
+	3,
+	56,
+	1,
+	2,
+	6,
+	3,
+	1,
+	3,
+	2,
+	10,
+	0,
+	11,
+	1,
+	3,
+	6,
+	4,
+	4,
+	68,
+	8,
+	2,
+	0,
+	3,
+	0,
+	2,
+	3,
+	2,
+	4,
+	2,
+	0,
+	15,
+	1,
+	83,
+	17,
+	10,
+	9,
+	5,
+	0,
+	82,
+	19,
+	13,
+	9,
+	214,
+	6,
+	3,
+	8,
+	28,
+	1,
+	83,
+	16,
+	16,
+	9,
+	82,
+	12,
+	9,
+	9,
+	7,
+	19,
+	58,
+	14,
+	5,
+	9,
+	243,
+	14,
+	166,
+	9,
+	71,
+	5,
+	2,
+	1,
+	3,
+	3,
+	2,
+	0,
+	2,
+	1,
+	13,
+	9,
+	120,
+	6,
+	3,
+	6,
+	4,
+	0,
+	29,
+	9,
+	41,
+	6,
+	2,
+	3,
+	9,
+	0,
+	10,
+	10,
+	47,
+	15,
+	199,
+	7,
+	137,
+	9,
+	54,
+	7,
+	2,
+	7,
+	17,
+	9,
+	57,
+	21,
+	2,
+	13,
+	123,
+	5,
+	4,
+	0,
+	2,
+	1,
+	2,
+	6,
+	2,
+	0,
+	9,
+	9,
+	49,
+	4,
+	2,
+	1,
+	2,
+	4,
+	9,
+	9,
+	55,
+	9,
+	266,
+	3,
+	10,
+	1,
+	2,
+	0,
+	49,
+	6,
+	4,
+	4,
+	14,
+	10,
+	5350,
+	0,
+	7,
+	14,
+	11465,
+	27,
+	2343,
+	9,
+	87,
+	9,
+	39,
+	4,
+	60,
+	6,
+	26,
+	9,
+	535,
+	9,
+	470,
+	0,
+	2,
+	54,
+	8,
+	3,
+	82,
+	0,
+	12,
+	1,
+	19628,
+	1,
+	4178,
+	9,
+	519,
+	45,
+	3,
+	22,
+	543,
+	4,
+	4,
+	5,
+	9,
+	7,
+	3,
+	6,
+	31,
+	3,
+	149,
+	2,
+	1418,
+	49,
+	513,
+	54,
+	5,
+	49,
+	9,
+	0,
+	15,
+	0,
+	23,
+	4,
+	2,
+	14,
+	1361,
+	6,
+	2,
+	16,
+	3,
+	6,
+	2,
+	1,
+	2,
+	4,
+	101,
+	0,
+	161,
+	6,
+	10,
+	9,
+	357,
+	0,
+	62,
+	13,
+	499,
+	13,
+	245,
+	1,
+	2,
+	9,
+	233,
+	0,
+	3,
+	0,
+	8,
+	1,
+	6,
+	0,
+	475,
+	6,
+	110,
+	6,
+	6,
+	9,
+	4759,
+	9,
+	787719,
+	239
+], m = [
+	0,
+	11,
+	2,
+	25,
+	2,
+	18,
+	2,
+	1,
+	2,
+	14,
+	3,
+	13,
+	35,
+	122,
+	70,
+	52,
+	268,
+	28,
+	4,
+	48,
+	48,
+	31,
+	14,
+	29,
+	6,
+	37,
+	11,
+	29,
+	3,
+	35,
+	5,
+	7,
+	2,
+	4,
+	43,
+	157,
+	19,
+	35,
+	5,
+	35,
+	5,
+	39,
+	9,
+	51,
+	13,
+	10,
+	2,
+	14,
+	2,
+	6,
+	2,
+	1,
+	2,
+	10,
+	2,
+	14,
+	2,
+	6,
+	2,
+	1,
+	4,
+	51,
+	13,
+	310,
+	10,
+	21,
+	11,
+	7,
+	25,
+	5,
+	2,
+	41,
+	2,
+	8,
+	70,
+	5,
+	3,
+	0,
+	2,
+	43,
+	2,
+	1,
+	4,
+	0,
+	3,
+	22,
+	11,
+	22,
+	10,
+	30,
+	66,
+	18,
+	2,
+	1,
+	11,
+	21,
+	11,
+	25,
+	7,
+	25,
+	39,
+	55,
+	7,
+	1,
+	65,
+	0,
+	16,
+	3,
+	2,
+	2,
+	2,
+	28,
+	43,
+	28,
+	4,
+	28,
+	36,
+	7,
+	2,
+	27,
+	28,
+	53,
+	11,
+	21,
+	11,
+	18,
+	14,
+	17,
+	111,
+	72,
+	56,
+	50,
+	14,
+	50,
+	14,
+	35,
+	39,
+	27,
+	10,
+	22,
+	251,
+	41,
+	7,
+	1,
+	17,
+	5,
+	57,
+	28,
+	11,
+	0,
+	9,
+	21,
+	43,
+	17,
+	47,
+	20,
+	28,
+	22,
+	13,
+	52,
+	58,
+	1,
+	3,
+	0,
+	14,
+	44,
+	33,
+	24,
+	27,
+	35,
+	30,
+	0,
+	3,
+	0,
+	9,
+	34,
+	4,
+	0,
+	13,
+	47,
+	15,
+	3,
+	22,
+	0,
+	2,
+	0,
+	36,
+	17,
+	2,
+	24,
+	20,
+	1,
+	64,
+	6,
+	2,
+	0,
+	2,
+	3,
+	2,
+	14,
+	2,
+	9,
+	8,
+	46,
+	39,
+	7,
+	3,
+	1,
+	3,
+	21,
+	2,
+	6,
+	2,
+	1,
+	2,
+	4,
+	4,
+	0,
+	19,
+	0,
+	13,
+	4,
+	31,
+	9,
+	2,
+	0,
+	3,
+	0,
+	2,
+	37,
+	2,
+	0,
+	26,
+	0,
+	2,
+	0,
+	45,
+	52,
+	19,
+	3,
+	21,
+	2,
+	31,
+	47,
+	21,
+	1,
+	2,
+	0,
+	185,
+	46,
+	42,
+	3,
+	37,
+	47,
+	21,
+	0,
+	60,
+	42,
+	14,
+	0,
+	72,
+	26,
+	38,
+	6,
+	186,
+	43,
+	117,
+	63,
+	32,
+	7,
+	3,
+	0,
+	3,
+	7,
+	2,
+	1,
+	2,
+	23,
+	16,
+	0,
+	2,
+	0,
+	95,
+	7,
+	3,
+	38,
+	17,
+	0,
+	2,
+	0,
+	29,
+	0,
+	11,
+	39,
+	8,
+	0,
+	22,
+	0,
+	12,
+	45,
+	20,
+	0,
+	19,
+	72,
+	200,
+	32,
+	32,
+	8,
+	2,
+	36,
+	18,
+	0,
+	50,
+	29,
+	113,
+	6,
+	2,
+	1,
+	2,
+	37,
+	22,
+	0,
+	26,
+	5,
+	2,
+	1,
+	2,
+	31,
+	15,
+	0,
+	24,
+	43,
+	261,
+	18,
+	16,
+	0,
+	2,
+	12,
+	2,
+	33,
+	125,
+	0,
+	80,
+	921,
+	103,
+	110,
+	18,
+	195,
+	2637,
+	96,
+	16,
+	1071,
+	18,
+	5,
+	26,
+	3994,
+	6,
+	582,
+	6842,
+	29,
+	1763,
+	568,
+	8,
+	30,
+	18,
+	78,
+	18,
+	29,
+	19,
+	47,
+	17,
+	3,
+	32,
+	20,
+	6,
+	18,
+	433,
+	44,
+	212,
+	63,
+	33,
+	24,
+	3,
+	24,
+	45,
+	74,
+	6,
+	0,
+	67,
+	12,
+	65,
+	1,
+	2,
+	0,
+	15,
+	4,
+	10,
+	7381,
+	42,
+	31,
+	98,
+	114,
+	8702,
+	3,
+	2,
+	6,
+	2,
+	1,
+	2,
+	290,
+	16,
+	0,
+	30,
+	2,
+	3,
+	0,
+	15,
+	3,
+	9,
+	395,
+	2309,
+	106,
+	6,
+	12,
+	4,
+	8,
+	8,
+	9,
+	5991,
+	84,
+	2,
+	70,
+	2,
+	1,
+	3,
+	0,
+	3,
+	1,
+	3,
+	3,
+	2,
+	11,
+	2,
+	0,
+	2,
+	6,
+	2,
+	64,
+	2,
+	3,
+	3,
+	7,
+	2,
+	6,
+	2,
+	27,
+	2,
+	3,
+	2,
+	4,
+	2,
+	0,
+	4,
+	6,
+	2,
+	339,
+	3,
+	24,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	7,
+	1845,
+	30,
+	7,
+	5,
+	262,
+	61,
+	147,
+	44,
+	11,
+	6,
+	17,
+	0,
+	322,
+	29,
+	19,
+	43,
+	485,
+	27,
+	229,
+	29,
+	3,
+	0,
+	208,
+	30,
+	2,
+	2,
+	2,
+	1,
+	2,
+	6,
+	3,
+	4,
+	10,
+	1,
+	225,
+	6,
+	2,
+	3,
+	2,
+	1,
+	2,
+	14,
+	2,
+	196,
+	60,
+	67,
+	8,
+	0,
+	1205,
+	3,
+	2,
+	26,
+	2,
+	1,
+	2,
+	0,
+	3,
+	0,
+	2,
+	9,
+	2,
+	3,
+	2,
+	0,
+	2,
+	0,
+	7,
+	0,
+	5,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	2,
+	2,
+	1,
+	2,
+	0,
+	3,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	1,
+	2,
+	0,
+	3,
+	3,
+	2,
+	6,
+	2,
+	3,
+	2,
+	3,
+	2,
+	0,
+	2,
+	9,
+	2,
+	16,
+	6,
+	2,
+	2,
+	4,
+	2,
+	16,
+	4421,
+	42719,
+	33,
+	4381,
+	3,
+	5773,
+	3,
+	7472,
+	16,
+	621,
+	2467,
+	541,
+	1507,
+	4938,
+	6,
+	8489
+], h = "‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", g = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", _ = {
+	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"
+}, ee = "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", te = {
+	5: ee,
+	"5module": ee + " export import",
+	6: ee + " const class extends export import super"
+}, ne = /^in(stanceof)?$/, re = RegExp("[" + g + "]"), ie = RegExp("[" + g + h + "]");
+function ae(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 v(e, t) {
+	return e < 65 ? e === 36 : e < 91 ? !0 : e < 97 ? e === 95 : e < 123 ? !0 : e <= 65535 ? e >= 170 && re.test(String.fromCharCode(e)) : t !== !1 && ae(e, m);
+}
+function y(e, t) {
+	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 && ie.test(String.fromCharCode(e)) : t === !1 ? !1 : ae(e, m) || ae(e, p);
+}
+var 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;
+};
+function x(e, t) {
+	return new b(e, {
+		beforeExpr: !0,
+		binop: t
+	});
+}
+var S = { beforeExpr: !0 }, C = { startsExpr: !0 }, oe = {};
+function w(e, t) {
+	return t === void 0 && (t = {}), t.keyword = e, oe[e] = new b(e, t);
+}
+var T = {
+	num: new b("num", C),
+	regexp: new b("regexp", C),
+	string: new b("string", C),
+	name: new b("name", C),
+	privateId: new b("privateId", C),
+	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(",", S),
+	semi: new b(";", S),
+	colon: new b(":", S),
+	dot: new b("."),
+	question: new b("?", S),
+	questionDot: new b("?."),
+	arrow: new b("=>", S),
+	template: new b("template"),
+	invalidTemplate: new b("invalidTemplate"),
+	ellipsis: new b("...", S),
+	backQuote: new b("`", C),
+	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: x("||", 1),
+	logicalAND: x("&&", 2),
+	bitwiseOR: x("|", 3),
+	bitwiseXOR: x("^", 4),
+	bitwiseAND: x("&", 5),
+	equality: x("==/!=/===/!==", 6),
+	relational: x("</>/<=/>=", 7),
+	bitShift: x("<</>>/>>>", 8),
+	plusMin: new b("+/-", {
+		beforeExpr: !0,
+		binop: 9,
+		prefix: !0,
+		startsExpr: !0
+	}),
+	modulo: x("%", 10),
+	star: x("*", 10),
+	slash: x("/", 10),
+	starstar: new b("**", { beforeExpr: !0 }),
+	coalesce: x("??", 1),
+	_break: w("break"),
+	_case: w("case", S),
+	_catch: w("catch"),
+	_continue: w("continue"),
+	_debugger: w("debugger"),
+	_default: w("default", S),
+	_do: w("do", {
+		isLoop: !0,
+		beforeExpr: !0
+	}),
+	_else: w("else", S),
+	_finally: w("finally"),
+	_for: w("for", { isLoop: !0 }),
+	_function: w("function", C),
+	_if: w("if"),
+	_return: w("return", S),
+	_switch: w("switch"),
+	_throw: w("throw", S),
+	_try: w("try"),
+	_var: w("var"),
+	_const: w("const"),
+	_while: w("while", { isLoop: !0 }),
+	_with: w("with"),
+	_new: w("new", {
+		beforeExpr: !0,
+		startsExpr: !0
+	}),
+	_this: w("this", C),
+	_super: w("super", C),
+	_class: w("class", C),
+	_extends: w("extends", S),
+	_export: w("export"),
+	_import: w("import", C),
+	_null: w("null", C),
+	_true: w("true", C),
+	_false: w("false", C),
+	_in: w("in", {
+		beforeExpr: !0,
+		binop: 7
+	}),
+	_instanceof: w("instanceof", {
+		beforeExpr: !0,
+		binop: 7
+	}),
+	_typeof: w("typeof", {
+		beforeExpr: !0,
+		prefix: !0,
+		startsExpr: !0
+	}),
+	_void: w("void", {
+		beforeExpr: !0,
+		prefix: !0,
+		startsExpr: !0
+	}),
+	_delete: w("delete", {
+		beforeExpr: !0,
+		prefix: !0,
+		startsExpr: !0
+	})
+}, E = /\r\n?|\n|\u2028|\u2029/, se = new RegExp(E.source, "g");
+function D(e) {
+	return e === 10 || e === 13 || e === 8232 || e === 8233;
+}
+function ce(e, t, n) {
+	n === void 0 && (n = e.length);
+	for (var r = t; r < n; r++) {
+		var i = e.charCodeAt(r);
+		if (D(i)) return r < n - 1 && i === 13 && e.charCodeAt(r + 1) === 10 ? r + 2 : r + 1;
+	}
+	return -1;
+}
+var le = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/, O = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g, ue = Object.prototype, de = ue.hasOwnProperty, fe = ue.toString, k = Object.hasOwn || (function(e, t) {
+	return de.call(e, t);
+}), pe = Array.isArray || (function(e) {
+	return fe.call(e) === "[object Array]";
+}), me = Object.create(null);
+function A(e) {
+	return me[e] || (me[e] = RegExp("^(?:" + e.replace(/ /g, "|") + ")$"));
+}
+function j(e) {
+	return e <= 65535 ? String.fromCharCode(e) : (e -= 65536, String.fromCharCode((e >> 10) + 55296, (e & 1023) + 56320));
+}
+var he = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/, M = function(e, t) {
+	this.line = e, this.column = t;
+};
+M.prototype.offset = function(e) {
+	return new M(this.line, this.column + e);
+};
+var ge = function(e, t, n) {
+	this.start = t, this.end = n, e.sourceFile !== null && (this.source = e.sourceFile);
+};
+function _e(e, t) {
+	for (var n = 1, r = 0;;) {
+		var i = ce(e, r, t);
+		if (i < 0) return new M(n, t - r);
+		++n, r = i;
+	}
+}
+var ve = {
+	ecmaVersion: null,
+	sourceType: "script",
+	strict: !1,
+	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
+}, ye = !1;
+function be(e) {
+	var t = {};
+	for (var n in ve) t[n] = e && k(e, n) ? e[n] : ve[n];
+	if (t.ecmaVersion === "latest" ? t.ecmaVersion = 1e8 : t.ecmaVersion == null ? (!ye && typeof console == "object" && console.warn && (ye = !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), pe(t.onToken)) {
+		var r = t.onToken;
+		t.onToken = function(e) {
+			return r.push(e);
+		};
+	}
+	if (pe(t.onComment) && (t.onComment = xe(t, t.onComment)), t.sourceType === "commonjs" && t.allowAwaitOutsideFunction) throw Error("Cannot use allowAwaitOutsideFunction with sourceType: commonjs");
+	return t;
+}
+function xe(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 ge(this, o, s)), e.ranges && (c.range = [i, a]), t.push(c);
+	};
+}
+var N = 1, P = 2, Se = 4, Ce = 8, we = 16, Te = 32, Ee = 64, De = 128, F = 256, Oe = 512, ke = 1024, Ae = N | P | F;
+function je(e, t) {
+	return P | (e ? Se : 0) | (t ? Ce : 0);
+}
+var Me = 0, Ne = 1, I = 2, Pe = 3, Fe = 4, Ie = 5, L = function(e, t, n) {
+	this.options = e = be(e), this.sourceFile = e.sourceFile, this.keywords = A(te[e.ecmaVersion >= 6 ? 6 : e.sourceType === "module" ? "5module" : 5]);
+	var r = "";
+	e.allowReserved !== !0 && (r = _[e.ecmaVersion >= 6 ? 6 : e.ecmaVersion === 5 ? 5 : 3], e.sourceType === "module" && (r += " await")), this.reservedWords = A(r);
+	var i = (r ? r + " " : "") + _.strict;
+	this.reservedWordsStrict = A(i), this.reservedWordsStrictBind = A(i + " " + _.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(E).length) : (this.pos = this.lineStart = 0, this.curLine = 1), this.type = T.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 || e.strict === !0 || 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(this.options.sourceType === "commonjs" ? P : N), this.regexpState = null, this.privateNameStack = [];
+}, R = {
+	inFunction: { configurable: !0 },
+	inGenerator: { configurable: !0 },
+	inAsync: { configurable: !0 },
+	canAwait: { configurable: !0 },
+	allowReturn: { configurable: !0 },
+	allowSuper: { configurable: !0 },
+	allowDirectSuper: { configurable: !0 },
+	treatFunctionsAsVar: { configurable: !0 },
+	allowNewDotTarget: { configurable: !0 },
+	allowUsing: { configurable: !0 },
+	inClassStaticBlock: { configurable: !0 }
+};
+L.prototype.parse = function() {
+	var e = this, t = this.options.program || this.startNode();
+	return this.nextToken(), this.catchStackOverflow(function() {
+		return e.parseTopLevel(t);
+	});
+}, R.inFunction.get = function() {
+	return (this.currentVarScope().flags & P) > 0;
+}, R.inGenerator.get = function() {
+	return (this.currentVarScope().flags & Ce) > 0;
+}, R.inAsync.get = function() {
+	return (this.currentVarScope().flags & Se) > 0;
+}, R.canAwait.get = function() {
+	for (var e = this.scopeStack.length - 1; e >= 0; e--) {
+		var t = this.scopeStack[e].flags;
+		if (t & (F | Oe)) return !1;
+		if (t & P) return (t & Se) > 0;
+	}
+	return this.inModule && this.options.ecmaVersion >= 13 || this.options.allowAwaitOutsideFunction;
+}, R.allowReturn.get = function() {
+	return !!(this.inFunction || this.options.allowReturnOutsideFunction && this.currentVarScope().flags & N);
+}, R.allowSuper.get = function() {
+	return (this.currentThisScope().flags & Ee) > 0 || this.options.allowSuperOutsideMethod;
+}, R.allowDirectSuper.get = function() {
+	return (this.currentThisScope().flags & De) > 0;
+}, R.treatFunctionsAsVar.get = function() {
+	return this.treatFunctionsAsVarInScope(this.currentScope());
+}, R.allowNewDotTarget.get = function() {
+	for (var e = this.scopeStack.length - 1; e >= 0; e--) {
+		var t = this.scopeStack[e].flags;
+		if (t & (F | Oe) || t & P && !(t & we)) return !0;
+	}
+	return !1;
+}, R.allowUsing.get = function() {
+	var e = this.currentScope().flags;
+	return !(e & ke || !this.inModule && e & N);
+}, R.inClassStaticBlock.get = function() {
+	return (this.currentVarScope().flags & F) > 0;
+}, L.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;
+}, L.parse = function(e, t) {
+	return new this(t, e).parse();
+}, L.parseExpressionAt = function(e, t, n) {
+	var r = new this(n, e, t);
+	return r.nextToken(), r.parseExpression();
+}, L.tokenizer = function(e, t) {
+	return new this(t, e);
+}, Object.defineProperties(L.prototype, R);
+var z = L.prototype, Le = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
+z.strictDirective = function(e) {
+	if (this.options.ecmaVersion < 5) return !1;
+	for (;;) {
+		O.lastIndex = e, e += O.exec(this.input)[0].length;
+		var t = Le.exec(this.input.slice(e));
+		if (!t) return !1;
+		if ((t[1] || t[2]) === "use strict") {
+			O.lastIndex = e + t[0].length;
+			var n = O.exec(this.input), r = n.index + n[0].length, i = this.input.charAt(r);
+			return i === ";" || i === "}" || E.test(n[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(i) || i === "!" && this.input.charAt(r + 1) === "=");
+		}
+		e += t[0].length, O.lastIndex = e, e += O.exec(this.input)[0].length, this.input[e] === ";" && e++;
+	}
+}, z.eat = function(e) {
+	return this.type === e ? (this.next(), !0) : !1;
+}, z.isContextual = function(e) {
+	return this.type === T.name && this.value === e && !this.containsEsc;
+}, z.eatContextual = function(e) {
+	return this.isContextual(e) ? (this.next(), !0) : !1;
+}, z.catchStackOverflow = function(e) {
+	try {
+		return e();
+	} catch (e) {
+		if (e instanceof Error && (/\bstack\b.*\b(exceeded|overflow)\b/i.test(e.message) || /\btoo much recursion\b/i.test(e.message))) this.raise(this.start, "Not enough stack space to parse input");
+		else throw e;
+	}
+}, z.expectContextual = function(e) {
+	this.eatContextual(e) || this.unexpected();
+}, z.canInsertSemicolon = function() {
+	return this.type === T.eof || this.type === T.braceR || E.test(this.input.slice(this.lastTokEnd, this.start));
+}, z.insertSemicolon = function() {
+	if (this.canInsertSemicolon()) return this.options.onInsertedSemicolon && this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc), !0;
+}, z.semicolon = function() {
+	!this.eat(T.semi) && !this.insertSemicolon() && this.unexpected();
+}, z.afterTrailingComma = function(e, t) {
+	if (this.type === e) return this.options.onTrailingComma && this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc), t || this.next(), !0;
+}, z.expect = function(e) {
+	this.eat(e) || this.unexpected();
+}, z.unexpected = function(e) {
+	this.raise(e ?? this.start, "Unexpected token");
+};
+var Re = function() {
+	this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = this.doubleProto = -1;
+};
+z.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");
+	}
+}, z.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");
+}, z.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");
+}, z.isSimpleAssignTarget = function(e) {
+	return e.type === "ParenthesizedExpression" ? this.isSimpleAssignTarget(e.expression) : e.type === "Identifier" || e.type === "MemberExpression";
+};
+var B = L.prototype;
+B.parseTopLevel = function(e) {
+	var t = Object.create(null);
+	for (e.body ||= []; this.type !== T.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 === "commonjs" ? "script" : this.options.sourceType, this.finishNode(e, "Program");
+};
+var ze = { kind: "loop" }, Be = { kind: "switch" };
+B.isLet = function(e) {
+	if (this.options.ecmaVersion < 6 || !this.isContextual("let")) return !1;
+	O.lastIndex = this.pos;
+	var t = O.exec(this.input), n = this.pos + t[0].length, r = this.fullCharCodeAt(n);
+	if (r === 91 || r === 92) return !0;
+	if (e) return !1;
+	if (r === 123) return !0;
+	if (v(r)) {
+		var i = n;
+		do
+			n += r <= 65535 ? 1 : 2;
+		while (y(r = this.fullCharCodeAt(n)));
+		if (r === 92) return !0;
+		var a = this.input.slice(i, n);
+		if (!ne.test(a)) return !0;
+	}
+	return !1;
+}, B.isAsyncFunction = function() {
+	if (this.options.ecmaVersion < 8 || !this.isContextual("async")) return !1;
+	O.lastIndex = this.pos;
+	var e = O.exec(this.input), t = this.pos + e[0].length, n;
+	return !E.test(this.input.slice(this.pos, t)) && this.input.slice(t, t + 8) === "function" && (t + 8 === this.input.length || !(y(n = this.fullCharCodeAt(t + 8)) || n === 92));
+}, B.isUsingKeyword = function(e, t) {
+	if (this.options.ecmaVersion < 17 || !this.isContextual(e ? "await" : "using")) return !1;
+	O.lastIndex = this.pos;
+	var n = O.exec(this.input), r = this.pos + n[0].length;
+	if (E.test(this.input.slice(this.pos, r))) return !1;
+	if (e) {
+		var i = r + 5, a;
+		if (this.input.slice(r, i) !== "using" || i === this.input.length || y(a = this.fullCharCodeAt(i)) || a === 92) return !1;
+		O.lastIndex = i;
+		var o = O.exec(this.input);
+		if (r = i + o[0].length, o && E.test(this.input.slice(i, r))) return !1;
+	}
+	var s = this.fullCharCodeAt(r);
+	if (!v(s) && s !== 92) return !1;
+	var c = r;
+	do
+		r += s <= 65535 ? 1 : 2;
+	while (y(s = this.fullCharCodeAt(r)));
+	if (s === 92) return !0;
+	var l = this.input.slice(c, r);
+	if (ne.test(l)) return !1;
+	if (t && !e && l === "of") {
+		O.lastIndex = r;
+		var u = O.exec(this.input);
+		if (r += u[0].length, this.input.charCodeAt(r) !== 61 || (s = this.input.charCodeAt(r + 1)) === 61 || s === 62) return !1;
+	}
+	return !0;
+}, B.isAwaitUsing = function(e) {
+	return this.isUsingKeyword(!0, e);
+}, B.isUsing = function(e) {
+	return this.isUsingKeyword(!1, e);
+}, B.parseStatement = function(e, t, n) {
+	var r = this.type, i = this.startNode(), a;
+	switch (this.isLet(e) && (r = T._var, a = "let"), r) {
+		case T._break:
+		case T._continue: return this.parseBreakContinueStatement(i, r.keyword);
+		case T._debugger: return this.parseDebuggerStatement(i);
+		case T._do: return this.parseDoStatement(i);
+		case T._for: return this.parseForStatement(i);
+		case T._function: return e && (this.strict || e !== "if" && e !== "label") && this.options.ecmaVersion >= 6 && this.unexpected(), this.parseFunctionStatement(i, !1, !e);
+		case T._class: return e && this.unexpected(), this.parseClass(i, !0);
+		case T._if: return this.parseIfStatement(i);
+		case T._return: return this.parseReturnStatement(i);
+		case T._switch: return this.parseSwitchStatement(i);
+		case T._throw: return this.parseThrowStatement(i);
+		case T._try: return this.parseTryStatement(i);
+		case T._const:
+		case T._var: return a ||= this.value, e && a !== "var" && this.unexpected(), this.parseVarStatement(i, a);
+		case T._while: return this.parseWhileStatement(i);
+		case T._with: return this.parseWithStatement(i);
+		case T.braceL: return this.parseBlock(!0, i);
+		case T.semi: return this.parseEmptyStatement(i);
+		case T._export:
+		case T._import:
+			if (this.options.ecmaVersion > 10 && r === T._import) {
+				O.lastIndex = this.pos;
+				var o = O.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 === T._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 this.allowUsing || this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement"), e && this.raise(this.start, "Using declaration is not allowed in single-statement positions"), 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 === T.name && d.type === "Identifier" && this.eat(T.colon) ? this.parseLabeledStatement(i, u, d, e) : this.parseExpressionStatement(i, d);
+	}
+}, B.parseBreakContinueStatement = function(e, t) {
+	var n = t === "break";
+	this.next(), this.eat(T.semi) || this.insertSemicolon() ? e.label = null : this.type === T.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");
+}, B.parseDebuggerStatement = function(e) {
+	return this.next(), this.semicolon(), this.finishNode(e, "DebuggerStatement");
+}, B.parseDoStatement = function(e) {
+	return this.next(), this.labels.push(ze), e.body = this.parseStatement("do"), this.labels.pop(), this.expect(T._while), e.test = this.parseParenExpression(), this.options.ecmaVersion >= 6 ? this.eat(T.semi) : this.semicolon(), this.finishNode(e, "DoWhileStatement");
+}, B.parseForStatement = function(e) {
+	this.next();
+	var t = this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await") ? this.lastTokStart : -1;
+	if (this.labels.push(ze), this.enterScope(0), this.expect(T.parenL), this.type === T.semi) return t > -1 && this.unexpected(t), this.parseFor(e, null);
+	var n = this.isLet();
+	if (this.type === T._var || this.type === T._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.canAwait || this.raise(this.start, "Await using cannot appear outside of async function"), this.next()), this.parseVar(c, !0, s), this.finishNode(c, "VariableDeclaration"), this.parseForAfterInit(e, c, t);
+	}
+	var l = this.containsEsc, u = new Re(), d = this.start, f = t > -1 ? this.parseExprSubscripts(u, "await") : this.parseExpression(!0, u);
+	return this.type === T._in || (o = this.options.ecmaVersion >= 6 && this.isContextual("of")) ? (t > -1 ? (this.type === T._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));
+}, B.parseForAfterInit = function(e, t, n) {
+	return (this.type === T._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && t.declarations.length === 1 ? (this.type === T._in ? ((t.kind === "using" || t.kind === "await using") && !t.declarations[0].init && this.raise(this.start, "Using declaration is not allowed in for-in loops"), this.options.ecmaVersion >= 9 && n > -1 && this.unexpected(n)) : this.options.ecmaVersion >= 9 && (e.await = n > -1), this.parseForIn(e, t)) : (n > -1 && this.unexpected(n), this.parseFor(e, t));
+}, B.parseFunctionStatement = function(e, t, n) {
+	return this.next(), this.parseFunction(e, He | (n ? 0 : Ue), !1, t);
+}, B.parseIfStatement = function(e) {
+	return this.next(), e.test = this.parseParenExpression(), e.consequent = this.parseStatement("if"), e.alternate = this.eat(T._else) ? this.parseStatement("if") : null, this.finishNode(e, "IfStatement");
+}, B.parseReturnStatement = function(e) {
+	return this.allowReturn || this.raise(this.start, "'return' outside of function"), this.next(), this.eat(T.semi) || this.insertSemicolon() ? e.argument = null : (e.argument = this.parseExpression(), this.semicolon()), this.finishNode(e, "ReturnStatement");
+}, B.parseSwitchStatement = function(e) {
+	this.next(), e.discriminant = this.parseParenExpression(), e.cases = [], this.expect(T.braceL), this.labels.push(Be), this.enterScope(ke);
+	for (var t, n = !1; this.type !== T.braceR;) if (this.type === T._case || this.type === T._default) {
+		var r = this.type === T._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(T.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");
+}, B.parseThrowStatement = function(e) {
+	return this.next(), E.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");
+};
+var Ve = [];
+B.parseCatchClauseParam = function() {
+	var e = this.parseBindingAtom(), t = e.type === "Identifier";
+	return this.enterScope(t ? Te : 0), this.checkLValPattern(e, t ? Fe : I), this.expect(T.parenR), e;
+}, B.parseTryStatement = function(e) {
+	if (this.next(), e.block = this.parseBlock(), e.handler = null, this.type === T._catch) {
+		var t = this.startNode();
+		this.next(), this.eat(T.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(T._finally) ? this.parseBlock() : null, !e.handler && !e.finalizer && this.raise(e.start, "Missing catch or finally clause"), this.finishNode(e, "TryStatement");
+}, B.parseVarStatement = function(e, t, n) {
+	return this.next(), this.parseVar(e, !1, t, n), this.semicolon(), this.finishNode(e, "VariableDeclaration");
+}, B.parseWhileStatement = function(e) {
+	return this.next(), e.test = this.parseParenExpression(), this.labels.push(ze), e.body = this.parseStatement("while"), this.labels.pop(), this.finishNode(e, "WhileStatement");
+}, B.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");
+}, B.parseEmptyStatement = function(e) {
+	return this.next(), this.finishNode(e, "EmptyStatement");
+}, B.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 === T._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");
+}, B.parseExpressionStatement = function(e, t) {
+	return e.expression = t, this.semicolon(), this.finishNode(e, "ExpressionStatement");
+}, B.parseBlock = function(e, t, n) {
+	for (e === void 0 && (e = !0), t === void 0 && (t = this.startNode()), t.body = [], this.expect(T.braceL), e && this.enterScope(0); this.type !== T.braceR;) {
+		var r = this.parseStatement(null);
+		t.body.push(r);
+	}
+	return n && (this.strict = !1), this.next(), e && this.exitScope(), this.finishNode(t, "BlockStatement");
+}, B.parseFor = function(e, t) {
+	return e.init = t, this.expect(T.semi), e.test = this.type === T.semi ? null : this.parseExpression(), this.expect(T.semi), e.update = this.type === T.parenR ? null : this.parseExpression(), this.expect(T.parenR), e.body = this.parseStatement("for"), this.exitScope(), this.labels.pop(), this.finishNode(e, "ForStatement");
+}, B.parseForIn = function(e, t) {
+	var n = this.type === T._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(T.parenR), e.body = this.parseStatement("for"), this.exitScope(), this.labels.pop(), this.finishNode(e, n ? "ForInStatement" : "ForOfStatement");
+}, B.parseVar = function(e, t, n, r) {
+	for (e.declarations = [], e.kind = n;;) {
+		var i = this.startNode();
+		if (this.parseVarId(i, n), this.eat(T.eq) ? i.init = this.parseMaybeAssign(t) : !r && n === "const" && !(this.type === T._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) ? this.unexpected() : !r && (n === "using" || n === "await using") && this.options.ecmaVersion >= 17 && this.type !== T._in && !this.isContextual("of") ? this.raise(this.lastTokEnd, "Missing initializer in " + n + " declaration") : !r && i.id.type !== "Identifier" && !(t && (this.type === T._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(T.comma)) break;
+	}
+	return e;
+}, B.parseVarId = function(e, t) {
+	e.id = t === "using" || t === "await using" ? this.parseIdent() : this.parseBindingAtom(), this.checkLValPattern(e.id, t === "var" ? Ne : I, !1);
+};
+var He = 1, Ue = 2, We = 4;
+B.parseFunction = function(e, t, n, r, i) {
+	this.initFunction(e), (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !r) && (this.type === T.star && t & Ue && this.unexpected(), e.generator = this.eat(T.star)), this.options.ecmaVersion >= 8 && (e.async = !!r), t & He && (e.id = t & We && this.type !== T.name ? null : this.parseIdent(), e.id && !(t & Ue) && this.checkLValSimple(e.id, this.strict || e.generator || e.async ? this.treatFunctionsAsVar ? Ne : I : Pe));
+	var a = this.yieldPos, o = this.awaitPos, s = this.awaitIdentPos;
+	return this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0, this.enterScope(je(e.async, e.generator)), t & He || (e.id = this.type === T.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 & He ? "FunctionDeclaration" : "FunctionExpression");
+}, B.parseFunctionParams = function(e) {
+	this.expect(T.parenL), e.params = this.parseBindingList(T.parenR, !1, this.options.ecmaVersion >= 8), this.checkYieldAwaitInDefaultParams();
+}, B.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(T.braceL); this.type !== T.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" && Ge(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");
+}, B.parseClassElement = function(e) {
+	if (this.eat(T.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(T.braceL)) return this.parseClassStaticBlock(n), n;
+		this.isClassElementNameStart() || this.type === T.star ? s = !0 : r = "static";
+	}
+	if (n.static = s, !r && t >= 8 && this.eatContextual("async") && ((this.isClassElementNameStart() || this.type === T.star) && !this.canInsertSemicolon() ? a = !0 : r = "async"), !r && (t >= 9 || !a) && this.eat(T.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 === T.parenL || o !== "method" || i || a) {
+		var l = !n.static && Ke(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;
+}, B.isClassElementNameStart = function() {
+	return this.type === T.name || this.type === T.privateId || this.type === T.num || this.type === T.string || this.type === T.bracketL || this.type.keyword;
+}, B.parseClassElementName = function(e) {
+	this.type === T.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);
+}, B.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 && Ke(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");
+}, B.parseClassField = function(e) {
+	return Ke(e, "constructor") ? this.raise(e.key.start, "Classes can't have a field named 'constructor'") : e.static && Ke(e, "prototype") && this.raise(e.key.start, "Classes can't have a static field named 'prototype'"), this.eat(T.eq) ? (this.enterScope(Oe | Ee), e.value = this.parseMaybeAssign(), this.exitScope()) : e.value = null, this.semicolon(), this.finishNode(e, "PropertyDefinition");
+}, B.parseClassStaticBlock = function(e) {
+	e.body = [];
+	var t = this.labels;
+	for (this.labels = [], this.enterScope(F | Ee); this.type !== T.braceR;) {
+		var n = this.parseStatement(null);
+		e.body.push(n);
+	}
+	return this.next(), this.exitScope(), this.labels = t, this.finishNode(e, "StaticBlock");
+}, B.parseClassId = function(e, t) {
+	this.type === T.name ? (e.id = this.parseIdent(), t && this.checkLValSimple(e.id, I, !1)) : (t === !0 && this.unexpected(), e.id = null);
+}, B.parseClassSuper = function(e) {
+	e.superClass = this.eat(T._extends) ? this.parseExprSubscripts(null, !1) : null;
+}, B.enterClassBody = function() {
+	var e = {
+		declared: Object.create(null),
+		used: []
+	};
+	return this.privateNameStack.push(e), e.declared;
+}, B.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];
+		k(t, o.name) || (i ? i.used.push(o) : this.raiseRecoverable(o.start, "Private field '#" + o.name + "' must be declared in an enclosing class"));
+	}
+};
+function Ge(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 Ke(e, t) {
+	var n = e.computed, r = e.key;
+	return !n && (r.type === "Identifier" && r.name === t || r.type === "Literal" && r.value === t);
+}
+B.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 !== T.string && this.unexpected(), e.source = this.parseExprAtom(), this.options.ecmaVersion >= 16 && (e.attributes = this.parseWithClause()), this.semicolon(), this.finishNode(e, "ExportAllDeclaration");
+}, B.parseExport = function(e, t) {
+	if (this.next(), this.eat(T.star)) return this.parseExportAllDeclaration(e, t);
+	if (this.eat(T._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 !== T.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");
+}, B.parseExportDeclaration = function(e) {
+	return this.parseStatement(null);
+}, B.parseExportDefaultDeclaration = function() {
+	var e;
+	if (this.type === T._function || (e = this.isAsyncFunction())) {
+		var t = this.startNode();
+		return this.next(), e && this.next(), this.parseFunction(t, He | We, !1, e);
+	} else if (this.type === T._class) {
+		var n = this.startNode();
+		return this.parseClass(n, "nullableID");
+	} else {
+		var r = this.parseMaybeAssign();
+		return this.semicolon(), r;
+	}
+}, B.checkExport = function(e, t, n) {
+	e && (typeof t != "string" && (t = t.type === "Identifier" ? t.name : t.value), k(e, t) && this.raiseRecoverable(n, "Duplicate export '" + t + "'"), e[t] = !0);
+}, B.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);
+}, B.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);
+	}
+}, B.shouldParseExportStatement = function() {
+	return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
+}, B.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");
+}, B.parseExportSpecifiers = function(e) {
+	var t = [], n = !0;
+	for (this.expect(T.braceL); !this.eat(T.braceR);) {
+		if (n) n = !1;
+		else if (this.expect(T.comma), this.afterTrailingComma(T.braceR)) break;
+		t.push(this.parseExportSpecifier(e));
+	}
+	return t;
+}, B.parseImport = function(e) {
+	return this.next(), this.type === T.string ? (e.specifiers = Ve, e.source = this.parseExprAtom()) : (e.specifiers = this.parseImportSpecifiers(), this.expectContextual("from"), e.source = this.type === T.string ? this.parseExprAtom() : this.unexpected()), this.options.ecmaVersion >= 16 && (e.attributes = this.parseWithClause()), this.semicolon(), this.finishNode(e, "ImportDeclaration");
+}, B.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, I), this.finishNode(e, "ImportSpecifier");
+}, B.parseImportDefaultSpecifier = function() {
+	var e = this.startNode();
+	return e.local = this.parseIdent(), this.checkLValSimple(e.local, I), this.finishNode(e, "ImportDefaultSpecifier");
+}, B.parseImportNamespaceSpecifier = function() {
+	var e = this.startNode();
+	return this.next(), this.expectContextual("as"), e.local = this.parseIdent(), this.checkLValSimple(e.local, I), this.finishNode(e, "ImportNamespaceSpecifier");
+}, B.parseImportSpecifiers = function() {
+	var e = [], t = !0;
+	if (this.type === T.name && (e.push(this.parseImportDefaultSpecifier()), !this.eat(T.comma))) return e;
+	if (this.type === T.star) return e.push(this.parseImportNamespaceSpecifier()), e;
+	for (this.expect(T.braceL); !this.eat(T.braceR);) {
+		if (t) t = !1;
+		else if (this.expect(T.comma), this.afterTrailingComma(T.braceR)) break;
+		e.push(this.parseImportSpecifier());
+	}
+	return e;
+}, B.parseWithClause = function() {
+	var e = [];
+	if (!this.eat(T._with)) return e;
+	this.expect(T.braceL);
+	for (var t = {}, n = !0; !this.eat(T.braceR);) {
+		if (n) n = !1;
+		else if (this.expect(T.comma), this.afterTrailingComma(T.braceR)) break;
+		var r = this.parseImportAttribute(), i = r.key.type === "Identifier" ? r.key.name : r.key.value;
+		k(t, i) && this.raiseRecoverable(r.key.start, "Duplicate attribute key '" + i + "'"), t[i] = !0, e.push(r);
+	}
+	return e;
+}, B.parseImportAttribute = function() {
+	var e = this.startNode();
+	return e.key = this.type === T.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never"), this.expect(T.colon), this.type !== T.string && this.unexpected(), e.value = this.parseExprAtom(), this.finishNode(e, "ImportAttribute");
+}, B.parseModuleExportName = function() {
+	if (this.options.ecmaVersion >= 13 && this.type === T.string) {
+		var e = this.parseLiteral(this.value);
+		return he.test(e.value) && this.raise(e.start, "An export name cannot include a lone surrogate."), e;
+	}
+	return this.parseIdent(!0);
+}, B.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);
+}, B.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] === "'");
+};
+var V = L.prototype;
+V.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;
+}, V.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;
+}, V.parseSpread = function(e) {
+	var t = this.startNode();
+	return this.next(), t.argument = this.parseMaybeAssign(!1, e), this.finishNode(t, "SpreadElement");
+}, V.parseRestBinding = function() {
+	var e = this.startNode();
+	return this.next(), this.options.ecmaVersion === 6 && this.type !== T.name && this.unexpected(), e.argument = this.parseBindingAtom(), this.finishNode(e, "RestElement");
+}, V.parseBindingAtom = function() {
+	if (this.options.ecmaVersion >= 6) switch (this.type) {
+		case T.bracketL:
+			var e = this.startNode();
+			return this.next(), e.elements = this.parseBindingList(T.bracketR, !0, !0), this.finishNode(e, "ArrayPattern");
+		case T.braceL: return this.parseObj(!0);
+	}
+	return this.parseIdent();
+}, V.parseBindingList = function(e, t, n, r) {
+	for (var i = [], a = !0; !this.eat(e);) if (a ? a = !1 : this.expect(T.comma), t && this.type === T.comma) i.push(null);
+	else if (n && this.afterTrailingComma(e)) break;
+	else if (this.type === T.ellipsis) {
+		var o = this.parseRestBinding();
+		this.parseBindingListItem(o), i.push(o), this.type === T.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;
+}, V.parseAssignableListItem = function(e) {
+	var t = this.parseMaybeDefault(this.start, this.startLoc);
+	return this.parseBindingListItem(t), t;
+}, V.parseBindingListItem = function(e) {
+	return e;
+}, V.parseMaybeDefault = function(e, t, n) {
+	if (n ||= this.parseBindingAtom(), this.options.ecmaVersion < 6 || !this.eat(T.eq)) return n;
+	var r = this.startNodeAt(e, t);
+	return r.left = n, r.right = this.parseMaybeAssign(), this.finishNode(r, "AssignmentPattern");
+}, V.checkLValSimple = function(e, t, n) {
+	t === void 0 && (t = Me);
+	var r = t !== Me;
+	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 === I && e.name === "let" && this.raiseRecoverable(e.start, "let is disallowed as a lexically bound name"), n && (k(n, e.name) && this.raiseRecoverable(e.start, "Argument name clash"), n[e.name] = !0), t !== Ie && 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");
+	}
+}, V.checkLValPattern = function(e, t, n) {
+	switch (t === void 0 && (t = Me), 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);
+	}
+}, V.checkLValInnerPattern = function(e, t, n) {
+	switch (t === void 0 && (t = Me), 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);
+	}
+};
+var H = function(e, t, n, r, i) {
+	this.token = e, this.isExpr = !!t, this.preserveSpace = !!n, this.override = r, this.generator = !!i;
+}, U = {
+	b_stat: new H("{", !1),
+	b_expr: new H("{", !0),
+	b_tmpl: new H("${", !1),
+	p_stat: new H("(", !1),
+	p_expr: new H("(", !0),
+	q_tmpl: new H("`", !0, !0, function(e) {
+		return e.tryReadTemplateToken();
+	}),
+	f_stat: new H("function", !1),
+	f_expr: new H("function", !0),
+	f_expr_gen: new H("function", !0, !1, null, !0),
+	f_gen: new H("function", !1, !1, null, !0)
+}, W = L.prototype;
+W.initialContext = function() {
+	return [U.b_stat];
+}, W.curContext = function() {
+	return this.context[this.context.length - 1];
+}, W.braceIsBlock = function(e) {
+	var t = this.curContext();
+	return t === U.f_expr || t === U.f_stat ? !0 : e === T.colon && (t === U.b_stat || t === U.b_expr) ? !t.isExpr : e === T._return || e === T.name && this.exprAllowed ? E.test(this.input.slice(this.lastTokEnd, this.start)) : e === T._else || e === T.semi || e === T.eof || e === T.parenR || e === T.arrow ? !0 : e === T.braceL ? t === U.b_stat : e === T._var || e === T._const || e === T.name ? !1 : !this.exprAllowed;
+}, W.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;
+}, W.updateContext = function(e) {
+	var t, n = this.type;
+	n.keyword && e === T.dot ? this.exprAllowed = !1 : (t = n.updateContext) ? t.call(this, e) : this.exprAllowed = n.beforeExpr;
+}, W.overrideContext = function(e) {
+	this.curContext() !== e && (this.context[this.context.length - 1] = e);
+}, T.parenR.updateContext = T.braceR.updateContext = function() {
+	if (this.context.length === 1) {
+		this.exprAllowed = !0;
+		return;
+	}
+	var e = this.context.pop();
+	e === U.b_stat && this.curContext().token === "function" && (e = this.context.pop()), this.exprAllowed = !e.isExpr;
+}, T.braceL.updateContext = function(e) {
+	this.context.push(this.braceIsBlock(e) ? U.b_stat : U.b_expr), this.exprAllowed = !0;
+}, T.dollarBraceL.updateContext = function() {
+	this.context.push(U.b_tmpl), this.exprAllowed = !0;
+}, T.parenL.updateContext = function(e) {
+	var t = e === T._if || e === T._for || e === T._with || e === T._while;
+	this.context.push(t ? U.p_stat : U.p_expr), this.exprAllowed = !0;
+}, T.incDec.updateContext = function() {}, T._function.updateContext = T._class.updateContext = function(e) {
+	e.beforeExpr && e !== T._else && !(e === T.semi && this.curContext() !== U.p_stat) && !(e === T._return && E.test(this.input.slice(this.lastTokEnd, this.start))) && !((e === T.colon || e === T.braceL) && this.curContext() === U.b_stat) ? this.context.push(U.f_expr) : this.context.push(U.f_stat), this.exprAllowed = !1;
+}, T.colon.updateContext = function() {
+	this.curContext().token === "function" && this.context.pop(), this.exprAllowed = !0;
+}, T.backQuote.updateContext = function() {
+	this.curContext() === U.q_tmpl ? this.context.pop() : this.context.push(U.q_tmpl), this.exprAllowed = !1;
+}, T.star.updateContext = function(e) {
+	if (e === T._function) {
+		var t = this.context.length - 1;
+		this.context[t] === U.f_expr ? this.context[t] = U.f_expr_gen : this.context[t] = U.f_gen;
+	}
+	this.exprAllowed = !0;
+}, T.name.updateContext = function(e) {
+	var t = !1;
+	this.options.ecmaVersion >= 6 && e !== T.dot && (this.value === "of" && !this.exprAllowed || this.value === "yield" && this.inGeneratorContext()) && (t = !0), this.exprAllowed = t;
+};
+var G = L.prototype;
+G.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;
+	}
+}, G.parseExpression = function(e, t) {
+	var n = this;
+	return this.catchStackOverflow(function() {
+		var r = n.start, i = n.startLoc, a = n.parseMaybeAssign(e, t);
+		if (n.type === T.comma) {
+			var o = n.startNodeAt(r, i);
+			for (o.expressions = [a]; n.eat(T.comma);) o.expressions.push(n.parseMaybeAssign(e, t));
+			return n.finishNode(o, "SequenceExpression");
+		}
+		return a;
+	});
+}, G.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 Re(), r = !0);
+	var s = this.start, c = this.startLoc;
+	(this.type === T.parenL || this.type === T.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 === T.eq && (l = this.toAssignable(l, !1, t)), r || (t.parenthesizedAssign = t.trailingComma = t.doubleProto = -1), t.shorthandAssign >= l.start && (t.shorthandAssign = -1), this.type === T.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;
+}, G.parseMaybeConditional = function(e, t) {
+	var n = this.start, r = this.startLoc, i = this.parseExprOps(e, t);
+	if (this.checkExpressionErrors(t)) return i;
+	if (!(i.type === "ArrowFunctionExpression" && i.start === n) && this.eat(T.question)) {
+		var a = this.startNodeAt(n, r);
+		return a.test = i, a.consequent = this.parseMaybeAssign(), this.expect(T.colon), a.alternate = this.parseMaybeAssign(e), this.finishNode(a, "ConditionalExpression");
+	}
+	return i;
+}, G.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);
+}, G.parseExprOp = function(e, t, n, r, i) {
+	var a = this.type.binop;
+	if (a != null && (!i || this.type !== T._in) && a > r) {
+		var o = this.type === T.logicalOR || this.type === T.logicalAND, s = this.type === T.coalesce;
+		s && (a = T.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 === T.coalesce || s && (this.type === T.logicalOR || this.type === T.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;
+}, G.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");
+}, G.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 === T.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" && qe(s.argument) ? this.raiseRecoverable(s.start, "Deleting local variable in strict mode") : s.operator === "delete" && Je(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 === T.privateId) (r || this.privateNameStack.length === 0) && this.options.checkPrivateFields && this.unexpected(), o = this.parsePrivateIdent(), this.type !== T._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(T.starstar)) if (t) this.unexpected(this.lastTokStart);
+	else return this.buildBinary(i, a, o, this.parseMaybeUnary(null, !1, !1, r), "**", !1);
+	else return o;
+};
+function qe(e) {
+	return e.type === "Identifier" || e.type === "ParenthesizedExpression" && qe(e.expression);
+}
+function Je(e) {
+	return e.type === "MemberExpression" && e.property.type === "PrivateIdentifier" || e.type === "ChainExpression" && Je(e.expression) || e.type === "ParenthesizedExpression" && Je(e.expression);
+}
+G.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;
+}, G.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;
+	}
+}, G.shouldParseAsyncArrow = function() {
+	return !this.canInsertSemicolon() && this.eat(T.arrow);
+}, G.parseSubscriptAsyncArrow = function(e, t, n, r) {
+	return this.parseArrowExpression(this.startNodeAt(e, t), n, !0, r);
+}, G.parseSubscript = function(e, t, n, r, i, a, o) {
+	var s = this.options.ecmaVersion >= 11, c = s && this.eat(T.questionDot);
+	r && c && this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions");
+	var l = this.eat(T.bracketL);
+	if (l || c && this.type !== T.parenL && this.type !== T.backQuote || this.eat(T.dot)) {
+		var u = this.startNodeAt(t, n);
+		u.object = e, l ? (u.property = this.parseExpression(), this.expect(T.bracketR)) : this.type === T.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(T.parenL)) {
+		var d = new Re(), f = this.yieldPos, p = this.awaitPos, m = this.awaitIdentPos;
+		this.yieldPos = 0, this.awaitPos = 0, this.awaitIdentPos = 0;
+		var h = this.parseExprList(T.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 === T.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;
+}, G.parseExprAtom = function(e, t, n) {
+	this.type === T.slash && this.readRegexp();
+	var r, i = this.potentialArrowAt === this.start;
+	switch (this.type) {
+		case T._super: return this.allowSuper || this.raise(this.start, "'super' keyword outside a method"), r = this.startNode(), this.next(), this.type === T.parenL && !this.allowDirectSuper && this.raise(r.start, "super() call outside constructor of a subclass"), this.type !== T.dot && this.type !== T.bracketL && this.type !== T.parenL && this.unexpected(), this.finishNode(r, "Super");
+		case T._this: return r = this.startNode(), this.next(), this.finishNode(r, "ThisExpression");
+		case T.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(T._function)) return this.overrideContext(U.f_expr), this.parseFunction(this.startNodeAt(a, o), 0, !1, !0, t);
+			if (i && !this.canInsertSemicolon()) {
+				if (this.eat(T.arrow)) return this.parseArrowExpression(this.startNodeAt(a, o), [c], !1, t);
+				if (this.options.ecmaVersion >= 8 && c.name === "async" && this.type === T.name && !s && (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) return c = this.parseIdent(!1), (this.canInsertSemicolon() || !this.eat(T.arrow)) && this.unexpected(), this.parseArrowExpression(this.startNodeAt(a, o), [c], !0, t);
+			}
+			return c;
+		case T.regexp:
+			var l = this.value;
+			return r = this.parseLiteral(l.value), r.regex = {
+				pattern: l.pattern,
+				flags: l.flags
+			}, r;
+		case T.num:
+		case T.string: return this.parseLiteral(this.value);
+		case T._null:
+		case T._true:
+		case T._false: return r = this.startNode(), r.value = this.type === T._null ? null : this.type === T._true, r.raw = this.type.keyword, this.next(), this.finishNode(r, "Literal");
+		case T.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 T.bracketL: return r = this.startNode(), this.next(), r.elements = this.parseExprList(T.bracketR, !0, !0, e), this.finishNode(r, "ArrayExpression");
+		case T.braceL: return this.overrideContext(U.b_expr), this.parseObj(!1, e);
+		case T._function: return r = this.startNode(), this.next(), this.parseFunction(r, 0);
+		case T._class: return this.parseClass(this.startNode(), !1);
+		case T._new: return this.parseNew();
+		case T.backQuote: return this.parseTemplate();
+		case T._import: return this.options.ecmaVersion >= 11 ? this.parseExprImport(n) : this.unexpected();
+		default: return this.parseExprAtomDefault();
+	}
+}, G.parseExprAtomDefault = function() {
+	this.unexpected();
+}, G.parseExprImport = function(e) {
+	var t = this.startNode();
+	if (this.containsEsc && this.raiseRecoverable(this.start, "Escape sequence in keyword import"), this.next(), this.type === T.parenL && !e) return this.parseDynamicImport(t);
+	if (this.type === T.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();
+}, G.parseDynamicImport = function(e) {
+	if (this.next(), e.source = this.parseMaybeAssign(), this.options.ecmaVersion >= 16) this.eat(T.parenR) ? e.options = null : (this.expect(T.comma), this.afterTrailingComma(T.parenR) ? e.options = null : (e.options = this.parseMaybeAssign(), this.eat(T.parenR) || (this.expect(T.comma), this.afterTrailingComma(T.parenR) || this.unexpected())));
+	else if (!this.eat(T.parenR)) {
+		var t = this.start;
+		this.eat(T.comma) && this.eat(T.parenR) ? this.raiseRecoverable(t, "Trailing comma is not allowed in import()") : this.unexpected(t);
+	}
+	return this.finishNode(e, "ImportExpression");
+}, G.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");
+}, G.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");
+}, G.parseParenExpression = function() {
+	this.expect(T.parenL);
+	var e = this.parseExpression();
+	return this.expect(T.parenR), e;
+}, G.shouldParseArrow = function(e) {
+	return !this.canInsertSemicolon();
+}, G.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 Re(), f = this.yieldPos, p = this.awaitPos, m;
+		for (this.yieldPos = 0, this.awaitPos = 0; this.type !== T.parenR;) if (l ? l = !1 : this.expect(T.comma), a && this.afterTrailingComma(T.parenR, !0)) {
+			u = !0;
+			break;
+		} else if (this.type === T.ellipsis) {
+			m = this.start, c.push(this.parseParenItem(this.parseRestBinding())), this.type === T.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(T.parenR), e && this.shouldParseArrow(c) && this.eat(T.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;
+}, G.parseParenItem = function(e) {
+	return e;
+}, G.parseParenArrowList = function(e, t, n, r) {
+	return this.parseArrowExpression(this.startNodeAt(e, t), n, !1, r);
+};
+var Ye = [];
+G.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 === T.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), e.callee.type === "Super" && this.raiseRecoverable(r, "Invalid use of 'super'"), this.eat(T.parenL) ? e.arguments = this.parseExprList(T.parenR, this.options.ecmaVersion >= 8, !1) : e.arguments = Ye, this.finishNode(e, "NewExpression");
+}, G.parseTemplateElement = function(e) {
+	var t = e.isTagged, n = this.startNode();
+	return this.type === T.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 === T.backQuote, this.finishNode(n, "TemplateElement");
+}, G.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 === T.eof && this.raise(this.pos, "Unterminated template literal"), this.expect(T.dollarBraceL), n.expressions.push(this.parseExpression()), this.expect(T.braceR), n.quasis.push(r = this.parseTemplateElement({ isTagged: t }));
+	return this.next(), this.finishNode(n, "TemplateLiteral");
+}, G.isAsyncProp = function(e) {
+	return !e.computed && e.key.type === "Identifier" && e.key.name === "async" && (this.type === T.name || this.type === T.num || this.type === T.string || this.type === T.bracketL || this.type.keyword || this.options.ecmaVersion >= 9 && this.type === T.star) && !E.test(this.input.slice(this.lastTokEnd, this.start));
+}, G.parseObj = function(e, t) {
+	var n = this.startNode(), r = !0, i = {};
+	for (n.properties = [], this.next(); !this.eat(T.braceR);) {
+		if (r) r = !1;
+		else if (this.expect(T.comma), this.options.ecmaVersion >= 5 && this.afterTrailingComma(T.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");
+}, G.parseProperty = function(e, t) {
+	var n = this.startNode(), r, i, a, o;
+	if (this.options.ecmaVersion >= 9 && this.eat(T.ellipsis)) return e ? (n.argument = this.parseIdent(!1), this.type === T.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 === T.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(T.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(T.star), this.parsePropertyName(n)) : i = !1, this.parsePropertyValue(n, e, r, i, a, o, t, s), this.finishNode(n, "Property");
+}, G.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");
+}, G.parsePropertyValue = function(e, t, n, r, i, a, o, s) {
+	(n || r) && this.type === T.colon && this.unexpected(), this.eat(T.colon) ? (e.value = t ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(!1, o), e.kind = "init") : this.options.ecmaVersion >= 6 && this.type === T.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 !== T.comma && this.type !== T.braceR && this.type !== T.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 === T.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();
+}, G.parsePropertyName = function(e) {
+	if (this.options.ecmaVersion >= 6) {
+		if (this.eat(T.bracketL)) return e.computed = !0, e.key = this.parseMaybeAssign(), this.expect(T.bracketR), e.key;
+		e.computed = !1;
+	}
+	return e.key = this.type === T.num || this.type === T.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never");
+}, G.initFunction = function(e) {
+	e.id = null, this.options.ecmaVersion >= 6 && (e.generator = e.expression = !1), this.options.ecmaVersion >= 8 && (e.async = !1);
+}, G.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(je(t, r.generator) | Ee | (n ? De : 0)), this.expect(T.parenL), r.params = this.parseBindingList(T.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");
+}, G.parseArrowExpression = function(e, t, n, r) {
+	var i = this.yieldPos, a = this.awaitPos, o = this.awaitIdentPos;
+	return this.enterScope(je(n, !1) | we), 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");
+}, G.parseFunctionBody = function(e, t, n, r) {
+	var i = t && this.type !== T.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, Ie), e.body = this.parseBlock(!1, void 0, o && !a), e.expression = !1, this.adaptDirectivePrologue(e.body.body), this.labels = c;
+	}
+	this.exitScope();
+}, G.isSimpleParamList = function(e) {
+	for (var t = 0, n = e; t < n.length; t += 1) if (n[t].type !== "Identifier") return !1;
+	return !0;
+}, G.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, Ne, t ? null : n);
+	}
+}, G.parseExprList = function(e, t, n, r) {
+	for (var i = [], a = !0; !this.eat(e);) {
+		if (a) a = !1;
+		else if (this.expect(T.comma), t && this.afterTrailingComma(e)) break;
+		var o = void 0;
+		n && this.type === T.comma ? o = null : this.type === T.ellipsis ? (o = this.parseSpread(r), r && this.type === T.comma && r.trailingComma < 0 && (r.trailingComma = this.start)) : o = this.parseMaybeAssign(!1, r), i.push(o);
+	}
+	return i;
+}, G.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 & Ae) && 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"));
+}, G.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;
+}, G.parseIdentNode = function() {
+	var e = this.startNode();
+	return this.type === T.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 = T.name) : this.unexpected(), e;
+}, G.parsePrivateIdent = function() {
+	var e = this.startNode();
+	return this.type === T.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;
+}, G.parseYield = function(e) {
+	this.yieldPos ||= this.start;
+	var t = this.startNode();
+	return this.next(), this.type === T.semi || this.canInsertSemicolon() || this.type !== T.star && !this.type.startsExpr ? (t.delegate = !1, t.argument = null) : (t.delegate = this.eat(T.star), t.argument = this.parseMaybeAssign(e)), this.finishNode(t, "YieldExpression");
+}, G.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");
+};
+var Xe = L.prototype;
+Xe.raise = function(e, t) {
+	var n = _e(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;
+}, Xe.raiseRecoverable = Xe.raise, Xe.curPosition = function() {
+	if (this.options.locations) return new M(this.curLine, this.pos - this.lineStart);
+};
+var K = L.prototype, Ze = function(e) {
+	this.flags = e, this.var = [], this.lexical = [], this.functions = [];
+};
+K.enterScope = function(e) {
+	this.scopeStack.push(new Ze(e));
+}, K.exitScope = function() {
+	this.scopeStack.pop();
+}, K.treatFunctionsAsVarInScope = function(e) {
+	return e.flags & P || !this.inModule && e.flags & N;
+}, K.declareName = function(e, t, n) {
+	var r = !1;
+	if (t === I) {
+		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 & N && delete this.undefinedExports[e];
+	} else if (t === Fe) this.currentScope().lexical.push(e);
+	else if (t === Pe) {
+		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 & Te && s.lexical[0] === e) || !this.treatFunctionsAsVarInScope(s) && s.functions.indexOf(e) > -1) {
+			r = !0;
+			break;
+		}
+		if (s.var.push(e), this.inModule && s.flags & N && delete this.undefinedExports[e], s.flags & Ae) break;
+	}
+	r && this.raiseRecoverable(n, "Identifier '" + e + "' has already been declared");
+}, K.checkLocalExport = function(e) {
+	this.scopeStack[0].lexical.indexOf(e.name) === -1 && this.scopeStack[0].var.indexOf(e.name) === -1 && (this.undefinedExports[e.name] = e);
+}, K.currentScope = function() {
+	return this.scopeStack[this.scopeStack.length - 1];
+}, K.currentVarScope = function() {
+	for (var e = this.scopeStack.length - 1;; e--) {
+		var t = this.scopeStack[e];
+		if (t.flags & (Ae | Oe | F)) return t;
+	}
+}, K.currentThisScope = function() {
+	for (var e = this.scopeStack.length - 1;; e--) {
+		var t = this.scopeStack[e];
+		if (t.flags & (Ae | Oe | F) && !(t.flags & we)) return t;
+	}
+};
+var Qe = function(e, t, n) {
+	this.type = "", this.start = t, this.end = 0, e.options.locations && (this.loc = new ge(e, n)), e.options.directSourceFile && (this.sourceFile = e.options.directSourceFile), e.options.ranges && (this.range = [t, 0]);
+}, $e = L.prototype;
+$e.startNode = function() {
+	return new Qe(this, this.start, this.startLoc);
+}, $e.startNodeAt = function(e, t) {
+	return new Qe(this, e, t);
+};
+function et(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;
+}
+$e.finishNode = function(e, t) {
+	return et.call(this, e, t, this.lastTokEnd, this.lastTokEndLoc);
+}, $e.finishNodeAt = function(e, t, n, r) {
+	return et.call(this, e, t, n, r);
+}, $e.copyNode = function(e) {
+	var t = new Qe(this, e.start, this.startLoc);
+	for (var n in e) t[n] = e[n];
+	return t;
+};
+var tt = "Berf Beria_Erfe Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sidetic Sidt Sunu Sunuwar Tai_Yo Tayo Todhri Todr Tolong_Siki Tols Tulu_Tigalari Tutg Unknown Zzzz", nt = "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", rt = nt + " Extended_Pictographic", it = rt, at = it + " EBase EComp EMod EPres ExtPict", ot = at, st = {
+	9: nt,
+	10: rt,
+	11: it,
+	12: at,
+	13: ot,
+	14: ot
+}, ct = {
+	9: "",
+	10: "",
+	11: "",
+	12: "",
+	13: "",
+	14: "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Flag_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence RGI_Emoji"
+}, lt = "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", ut = "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", dt = ut + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd", ft = dt + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho", pt = ft + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", mt = pt + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith", ht = {
+	9: ut,
+	10: dt,
+	11: ft,
+	12: pt,
+	13: mt,
+	14: mt + " " + tt
+}, gt = {};
+function _t(e) {
+	var t = gt[e] = {
+		binary: A(st[e] + " " + lt),
+		binaryOfStrings: A(ct[e]),
+		nonBinary: {
+			General_Category: A(lt),
+			Script: A(ht[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;
+}
+for (var vt = 0, yt = [
+	9,
+	10,
+	11,
+	12,
+	13,
+	14
+]; vt < yt.length; vt += 1) {
+	var bt = yt[vt];
+	_t(bt);
+}
+var q = L.prototype, xt = function(e, t) {
+	this.parent = e, this.base = t || this;
+};
+xt.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;
+}, xt.prototype.sibling = function() {
+	return new xt(this.parent, this.base);
+};
+var J = 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 = gt[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;
+};
+J.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);
+}, J.prototype.raise = function(e) {
+	this.parser.raiseRecoverable(this.start, "Invalid regular expression: /" + this.source + "/: " + e);
+}, J.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;
+}, J.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;
+}, J.prototype.current = function(e) {
+	return e === void 0 && (e = !1), this.at(this.pos, e);
+}, J.prototype.lookahead = function(e) {
+	return e === void 0 && (e = !1), this.at(this.nextIndex(this.pos, e), e);
+}, J.prototype.advance = function(e) {
+	e === void 0 && (e = !1), this.pos = this.nextIndex(this.pos, e);
+}, J.prototype.eat = function(e, t) {
+	return t === void 0 && (t = !1), this.current(t) === e ? (this.advance(t), !0) : !1;
+}, J.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;
+}, q.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");
+};
+function St(e) {
+	for (var t in e) return !0;
+	return !1;
+}
+q.validateRegExpPattern = function(e) {
+	this.regexp_pattern(e), !e.switchN && this.options.ecmaVersion >= 9 && St(e.groupNames) && (e.switchN = !0, this.regexp_pattern(e));
+}, q.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");
+	}
+}, q.regexp_disjunction = function(e) {
+	var t = this.options.ecmaVersion >= 16;
+	for (t && (e.branchID = new xt(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");
+}, q.regexp_alternative = function(e) {
+	for (; e.pos < e.source.length && this.regexp_eatTerm(e););
+}, q.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;
+}, q.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;
+}, q.regexp_eatQuantifier = function(e, t) {
+	return t === void 0 && (t = !1), this.regexp_eatQuantifierPrefix(e, t) ? (e.eat(63), !0) : !1;
+}, q.regexp_eatQuantifierPrefix = function(e, t) {
+	return e.eat(42) || e.eat(43) || e.eat(63) || this.regexp_eatBracedQuantifier(e, t);
+}, q.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;
+}, q.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);
+}, q.regexp_eatReverseSolidusAtomEscape = function(e) {
+	var t = e.pos;
+	if (e.eat(92)) {
+		if (this.regexp_eatAtomEscape(e)) return !0;
+		e.pos = t;
+	}
+	return !1;
+}, q.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;
+}, q.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;
+}, q.regexp_eatModifiers = function(e) {
+	for (var t = "", n = 0; (n = e.current()) !== -1 && Ct(n);) t += j(n), e.advance();
+	return t;
+};
+function Ct(e) {
+	return e === 105 || e === 109 || e === 115;
+}
+q.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);
+}, q.regexp_eatInvalidBracedQuantifier = function(e) {
+	return this.regexp_eatBracedQuantifier(e, !0) && e.raise("Nothing to repeat"), !1;
+}, q.regexp_eatSyntaxCharacter = function(e) {
+	var t = e.current();
+	return wt(t) ? (e.lastIntValue = t, e.advance(), !0) : !1;
+};
+function wt(e) {
+	return e === 36 || e >= 40 && e <= 43 || e === 46 || e === 63 || e >= 91 && e <= 94 || e >= 123 && e <= 125;
+}
+q.regexp_eatPatternCharacters = function(e) {
+	for (var t = e.pos, n = 0; (n = e.current()) !== -1 && !wt(n);) e.advance();
+	return e.pos !== t;
+}, q.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;
+}, q.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;
+	}
+}, q.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;
+}, q.regexp_eatRegExpIdentifierName = function(e) {
+	if (e.lastStringValue = "", this.regexp_eatRegExpIdentifierStart(e)) {
+		for (e.lastStringValue += j(e.lastIntValue); this.regexp_eatRegExpIdentifierPart(e);) e.lastStringValue += j(e.lastIntValue);
+		return !0;
+	}
+	return !1;
+}, q.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), Tt(r) ? (e.lastIntValue = r, !0) : (e.pos = t, !1);
+};
+function Tt(e) {
+	return v(e, !0) || e === 36 || e === 95;
+}
+q.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), Et(r) ? (e.lastIntValue = r, !0) : (e.pos = t, !1);
+};
+function Et(e) {
+	return y(e, !0) || e === 36 || e === 95 || e === 8204 || e === 8205;
+}
+q.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);
+}, q.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;
+}, q.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;
+}, q.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);
+}, q.regexp_eatCControlLetter = function(e) {
+	var t = e.pos;
+	if (e.eat(99)) {
+		if (this.regexp_eatControlLetter(e)) return !0;
+		e.pos = t;
+	}
+	return !1;
+}, q.regexp_eatZero = function(e) {
+	return e.current() === 48 && !It(e.lookahead()) ? (e.lastIntValue = 0, e.advance(), !0) : !1;
+}, q.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;
+}, q.regexp_eatControlLetter = function(e) {
+	var t = e.current();
+	return Dt(t) ? (e.lastIntValue = t % 32, e.advance(), !0) : !1;
+};
+function Dt(e) {
+	return e >= 65 && e <= 90 || e >= 97 && e <= 122;
+}
+q.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) && Ot(e.lastIntValue)) return !0;
+		r && e.raise("Invalid unicode escape"), e.pos = n;
+	}
+	return !1;
+};
+function Ot(e) {
+	return e >= 0 && e <= 1114111;
+}
+q.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;
+}, q.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;
+};
+var kt = 0, Y = 1, X = 2;
+q.regexp_eatCharacterClassEscape = function(e) {
+	var t = e.current();
+	if (At(t)) return e.lastIntValue = -1, e.advance(), Y;
+	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 === X && e.raise("Invalid property name"), r;
+		e.raise("Invalid property name");
+	}
+	return kt;
+};
+function At(e) {
+	return e === 100 || e === 68 || e === 115 || e === 83 || e === 119 || e === 87;
+}
+q.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), Y;
+		}
+	}
+	if (e.pos = t, this.regexp_eatLoneUnicodePropertyNameOrValue(e)) {
+		var i = e.lastStringValue;
+		return this.regexp_validateUnicodePropertyNameOrValue(e, i);
+	}
+	return kt;
+}, q.regexp_validateUnicodePropertyNameAndValue = function(e, t, n) {
+	k(e.unicodeProperties.nonBinary, t) || e.raise("Invalid property name"), e.unicodeProperties.nonBinary[t].test(n) || e.raise("Invalid property value");
+}, q.regexp_validateUnicodePropertyNameOrValue = function(e, t) {
+	if (e.unicodeProperties.binary.test(t)) return Y;
+	if (e.switchV && e.unicodeProperties.binaryOfStrings.test(t)) return X;
+	e.raise("Invalid property name");
+}, q.regexp_eatUnicodePropertyName = function(e) {
+	var t = 0;
+	for (e.lastStringValue = ""; jt(t = e.current());) e.lastStringValue += j(t), e.advance();
+	return e.lastStringValue !== "";
+};
+function jt(e) {
+	return Dt(e) || e === 95;
+}
+q.regexp_eatUnicodePropertyValue = function(e) {
+	var t = 0;
+	for (e.lastStringValue = ""; Mt(t = e.current());) e.lastStringValue += j(t), e.advance();
+	return e.lastStringValue !== "";
+};
+function Mt(e) {
+	return jt(e) || It(e);
+}
+q.regexp_eatLoneUnicodePropertyNameOrValue = function(e) {
+	return this.regexp_eatUnicodePropertyValue(e);
+}, q.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 === X && e.raise("Negated character class may contain strings"), !0;
+	}
+	return !1;
+}, q.regexp_classContents = function(e) {
+	return e.current() === 93 ? Y : e.switchV ? this.regexp_classSetExpression(e) : (this.regexp_nonEmptyClassRanges(e), Y);
+}, q.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");
+		}
+	}
+}, q.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 || zt(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);
+}, q.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);
+}, q.regexp_classSetExpression = function(e) {
+	var t = Y, n;
+	if (!this.regexp_eatClassSetRange(e)) if (n = this.regexp_eatClassSetOperand(e)) {
+		n === X && (t = X);
+		for (var r = e.pos; e.eatChars([38, 38]);) {
+			if (e.current() !== 38 && (n = this.regexp_eatClassSetOperand(e))) {
+				n !== X && (t = Y);
+				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 === X && (t = X);
+	}
+}, q.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;
+}, q.regexp_eatClassSetOperand = function(e) {
+	return this.regexp_eatClassSetCharacter(e) ? Y : this.regexp_eatClassStringDisjunction(e) || this.regexp_eatNestedClass(e);
+}, q.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 === X && 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;
+}, q.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;
+}, q.regexp_classStringDisjunctionContents = function(e) {
+	for (var t = this.regexp_classString(e); e.eat(124);) this.regexp_classString(e) === X && (t = X);
+	return t;
+}, q.regexp_classString = function(e) {
+	for (var t = 0; this.regexp_eatClassSetCharacter(e);) t++;
+	return t === 1 ? Y : X;
+}, q.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() && Nt(n) || Pt(n) ? !1 : (e.advance(), e.lastIntValue = n, !0);
+};
+function Nt(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 Pt(e) {
+	return e === 40 || e === 41 || e === 45 || e === 47 || e >= 91 && e <= 93 || e >= 123 && e <= 125;
+}
+q.regexp_eatClassSetReservedPunctuator = function(e) {
+	var t = e.current();
+	return Ft(t) ? (e.lastIntValue = t, e.advance(), !0) : !1;
+};
+function Ft(e) {
+	return e === 33 || e === 35 || e === 37 || e === 38 || e === 44 || e === 45 || e >= 58 && e <= 62 || e === 64 || e === 96 || e === 126;
+}
+q.regexp_eatClassControlLetter = function(e) {
+	var t = e.current();
+	return It(t) || t === 95 ? (e.lastIntValue = t % 32, e.advance(), !0) : !1;
+}, q.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;
+}, q.regexp_eatDecimalDigits = function(e) {
+	var t = e.pos, n = 0;
+	for (e.lastIntValue = 0; It(n = e.current());) e.lastIntValue = 10 * e.lastIntValue + (n - 48), e.advance();
+	return e.pos !== t;
+};
+function It(e) {
+	return e >= 48 && e <= 57;
+}
+q.regexp_eatHexDigits = function(e) {
+	var t = e.pos, n = 0;
+	for (e.lastIntValue = 0; Lt(n = e.current());) e.lastIntValue = 16 * e.lastIntValue + Rt(n), e.advance();
+	return e.pos !== t;
+};
+function Lt(e) {
+	return e >= 48 && e <= 57 || e >= 65 && e <= 70 || e >= 97 && e <= 102;
+}
+function Rt(e) {
+	return e >= 65 && e <= 70 ? 10 + (e - 65) : e >= 97 && e <= 102 ? 10 + (e - 97) : e - 48;
+}
+q.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;
+}, q.regexp_eatOctalDigit = function(e) {
+	var t = e.current();
+	return zt(t) ? (e.lastIntValue = t - 48, e.advance(), !0) : (e.lastIntValue = 0, !1);
+};
+function zt(e) {
+	return e >= 48 && e <= 55;
+}
+q.regexp_eatFixedHexDigits = function(e, t) {
+	var n = e.pos;
+	e.lastIntValue = 0;
+	for (var r = 0; r < t; ++r) {
+		var i = e.current();
+		if (!Lt(i)) return e.pos = n, !1;
+		e.lastIntValue = 16 * e.lastIntValue + Rt(i), e.advance();
+	}
+	return !0;
+};
+var Bt = function(e) {
+	this.type = e.type, this.value = e.value, this.start = e.start, this.end = e.end, e.options.locations && (this.loc = new ge(e, e.startLoc, e.endLoc)), e.options.ranges && (this.range = [e.start, e.end]);
+}, Z = L.prototype;
+Z.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 Bt(this)), this.lastTokEnd = this.end, this.lastTokStart = this.start, this.lastTokEndLoc = this.endLoc, this.lastTokStartLoc = this.startLoc, this.nextToken();
+}, Z.getToken = function() {
+	return this.next(), new Bt(this);
+}, typeof Symbol < "u" && (Z[Symbol.iterator] = function() {
+	var e = this;
+	return { next: function() {
+		var t = e.getToken();
+		return {
+			done: t.type === T.eof,
+			value: t
+		};
+	} };
+}), Z.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(T.eof);
+	if (e.override) return e.override(this);
+	this.readToken(this.fullCharCodeAtPos());
+}, Z.readToken = function(e) {
+	return v(e, this.options.ecmaVersion >= 6) || e === 92 ? this.readWord() : this.getTokenFromCode(e);
+}, Z.fullCharCodeAt = function(e) {
+	var t = this.input.charCodeAt(e);
+	if (t <= 55295 || t >= 56320) return t;
+	var n = this.input.charCodeAt(e + 1);
+	return n <= 56319 || n >= 57344 ? t : (t << 10) + n - 56613888;
+}, Z.fullCharCodeAtPos = function() {
+	return this.fullCharCodeAt(this.pos);
+}, Z.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 = ce(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());
+}, Z.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 && !D(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());
+}, Z.skipSpace = function() {
+	loop: 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 loop;
+				}
+				break;
+			default: if (e > 8 && e < 14 || e >= 5760 && le.test(String.fromCharCode(e))) ++this.pos;
+			else break loop;
+		}
+	}
+}, Z.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);
+}, Z.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(T.ellipsis)) : (++this.pos, this.finishToken(T.dot));
+}, Z.readToken_slash = function() {
+	var e = this.input.charCodeAt(this.pos + 1);
+	return this.exprAllowed ? (++this.pos, this.readRegexp()) : e === 61 ? this.finishOp(T.assign, 2) : this.finishOp(T.slash, 1);
+}, Z.readToken_mult_modulo_exp = function(e) {
+	var t = this.input.charCodeAt(this.pos + 1), n = 1, r = e === 42 ? T.star : T.modulo;
+	return this.options.ecmaVersion >= 7 && e === 42 && t === 42 && (++n, r = T.starstar, t = this.input.charCodeAt(this.pos + 2)), t === 61 ? this.finishOp(T.assign, n + 1) : this.finishOp(r, n);
+}, Z.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(T.assign, 3) : this.finishOp(e === 124 ? T.logicalOR : T.logicalAND, 2) : t === 61 ? this.finishOp(T.assign, 2) : this.finishOp(e === 124 ? T.bitwiseOR : T.bitwiseAND, 1);
+}, Z.readToken_caret = function() {
+	return this.input.charCodeAt(this.pos + 1) === 61 ? this.finishOp(T.assign, 2) : this.finishOp(T.bitwiseXOR, 1);
+}, Z.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 || E.test(this.input.slice(this.lastTokEnd, this.pos))) ? (this.skipLineComment(3), this.skipSpace(), this.nextToken()) : this.finishOp(T.incDec, 2) : t === 61 ? this.finishOp(T.assign, 2) : this.finishOp(T.plusMin, 1);
+}, Z.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(T.assign, n + 1) : this.finishOp(T.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(T.relational, n));
+}, Z.readToken_eq_excl = function(e) {
+	var t = this.input.charCodeAt(this.pos + 1);
+	return t === 61 ? this.finishOp(T.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) : e === 61 && t === 62 && this.options.ecmaVersion >= 6 ? (this.pos += 2, this.finishToken(T.arrow)) : this.finishOp(e === 61 ? T.eq : T.prefix, 1);
+}, Z.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(T.questionDot, 2);
+		}
+		if (t === 63) return e >= 12 && this.input.charCodeAt(this.pos + 2) === 61 ? this.finishOp(T.assign, 3) : this.finishOp(T.coalesce, 2);
+	}
+	return this.finishOp(T.question, 1);
+}, Z.readToken_numberSign = function() {
+	var e = this.options.ecmaVersion, t = 35;
+	if (e >= 13 && (++this.pos, t = this.fullCharCodeAtPos(), v(t, !0) || t === 92)) return this.finishToken(T.privateId, this.readWord1());
+	this.raise(this.pos, "Unexpected character '" + j(t) + "'");
+}, Z.getTokenFromCode = function(e) {
+	switch (e) {
+		case 46: return this.readToken_dot();
+		case 40: return ++this.pos, this.finishToken(T.parenL);
+		case 41: return ++this.pos, this.finishToken(T.parenR);
+		case 59: return ++this.pos, this.finishToken(T.semi);
+		case 44: return ++this.pos, this.finishToken(T.comma);
+		case 91: return ++this.pos, this.finishToken(T.bracketL);
+		case 93: return ++this.pos, this.finishToken(T.bracketR);
+		case 123: return ++this.pos, this.finishToken(T.braceL);
+		case 125: return ++this.pos, this.finishToken(T.braceR);
+		case 58: return ++this.pos, this.finishToken(T.colon);
+		case 96:
+			if (this.options.ecmaVersion < 6) break;
+			return ++this.pos, this.finishToken(T.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(T.prefix, 1);
+		case 35: return this.readToken_numberSign();
+	}
+	this.raise(this.pos, "Unexpected character '" + j(e) + "'");
+}, Z.finishOp = function(e, t) {
+	var n = this.input.slice(this.pos, this.pos + t);
+	return this.pos += t, this.finishToken(e, n);
+}, Z.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 (E.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 J(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(T.regexp, {
+		pattern: i,
+		flags: o,
+		value: c
+	});
+}, Z.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;
+};
+function Vt(e, t) {
+	return t ? parseInt(e, 8) : parseFloat(e.replace(/_/g, ""));
+}
+function Ht(e) {
+	return typeof BigInt == "function" ? BigInt(e.replace(/_/g, "")) : null;
+}
+Z.readRadixNumber = function(e) {
+	var t = this.pos;
+	this.pos += 2;
+	var n = this.readInt(e);
+	return n ?? this.raise(this.start + 2, "Expected number in radix " + e), this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110 ? (n = Ht(this.input.slice(t, this.pos)), ++this.pos) : v(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number"), this.finishToken(T.num, n);
+}, Z.readNumber = function(e) {
+	var t = this.pos;
+	!e && this.readInt(10, void 0, !0) === null && this.raise(t, "Invalid number");
+	var n = this.pos - t >= 2 && this.input.charCodeAt(t) === 48;
+	n && this.strict && this.raise(t, "Invalid number");
+	var r = this.input.charCodeAt(this.pos);
+	if (!n && !e && this.options.ecmaVersion >= 11 && r === 110) {
+		var i = Ht(this.input.slice(t, this.pos));
+		return ++this.pos, v(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number"), this.finishToken(T.num, i);
+	}
+	n && /[89]/.test(this.input.slice(t, this.pos)) && (n = !1), r === 46 && !n && (++this.pos, this.readInt(10), r = this.input.charCodeAt(this.pos)), (r === 69 || r === 101) && !n && (r = this.input.charCodeAt(++this.pos), (r === 43 || r === 45) && ++this.pos, this.readInt(10) === null && this.raise(t, "Invalid number")), v(this.fullCharCodeAtPos()) && this.raise(this.pos, "Identifier directly after number");
+	var a = Vt(this.input.slice(t, this.pos), n);
+	return this.finishToken(T.num, a);
+}, Z.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;
+}, Z.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)) : (D(r) && this.raise(this.start, "Unterminated string constant"), ++this.pos);
+	}
+	return t += this.input.slice(n, this.pos++), this.finishToken(T.string, t);
+};
+var Ut = {};
+Z.tryReadTemplateToken = function() {
+	this.inTemplateElement = !0;
+	try {
+		this.readTmplToken();
+	} catch (e) {
+		if (e === Ut) this.readInvalidTemplateToken();
+		else throw e;
+	}
+	this.inTemplateElement = !1;
+}, Z.invalidStringToken = function(e, t) {
+	if (this.inTemplateElement && this.options.ecmaVersion >= 9) throw Ut;
+	this.raise(e, t);
+}, Z.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 === T.template || this.type === T.invalidTemplate) ? n === 36 ? (this.pos += 2, this.finishToken(T.dollarBraceL)) : (++this.pos, this.finishToken(T.backQuote)) : (e += this.input.slice(t, this.pos), this.finishToken(T.template, e));
+		if (n === 92) e += this.input.slice(t, this.pos), e += this.readEscapedChar(!0), t = this.pos;
+		else if (D(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;
+	}
+}, Z.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(T.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");
+}, Z.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 j(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 D(t) ? (this.options.locations && (this.lineStart = this.pos, ++this.curLine), "") : String.fromCharCode(t);
+	}
+}, Z.readHexChar = function(e) {
+	var t = this.pos, n = this.readInt(16, e);
+	return n === null && this.invalidStringToken(t, "Bad character escape sequence"), n;
+}, Z.readWord1 = function() {
+	this.containsEsc = !1;
+	for (var e = "", t = !0, n = this.pos, r = this.options.ecmaVersion >= 6; this.pos < this.input.length;) {
+		var i = this.fullCharCodeAtPos();
+		if (y(i, r)) this.pos += i <= 65535 ? 1 : 2;
+		else if (i === 92) {
+			this.containsEsc = !0, e += this.input.slice(n, this.pos);
+			var a = this.pos;
+			this.input.charCodeAt(++this.pos) !== 117 && this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX"), ++this.pos;
+			var o = this.readCodePoint();
+			(t ? v : y)(o, r) || this.invalidStringToken(a, "Invalid Unicode escape"), e += j(o), n = this.pos;
+		} else break;
+		t = !1;
+	}
+	return e + this.input.slice(n, this.pos);
+}, Z.readWord = function() {
+	var e = this.readWord1(), t = T.name;
+	return this.keywords.test(e) && (t = oe[e]), this.finishToken(t, e);
+}, L.acorn = {
+	Parser: L,
+	version: "8.17.0",
+	defaultOptions: ve,
+	Position: M,
+	SourceLocation: ge,
+	getLineInfo: _e,
+	Node: Qe,
+	TokenType: b,
+	tokTypes: T,
+	keywordTypes: oe,
+	TokContext: H,
+	tokContexts: U,
+	isIdentifierChar: y,
+	isIdentifierStart: v,
+	Token: Bt,
+	isNewLine: D,
+	lineBreak: E,
+	lineBreakG: se,
+	nonASCIIwhitespace: le
+};
+function Wt(e, t) {
+	return L.parse(e, t);
+}
+function Q(e, t, n) {
+	return L.parseExpressionAt(e, t, n);
+}
+//#endregion
+//#region src/transformer.ts
+function Gt(e) {
+	if (typeof e != "object" || !e) return e;
+	if (Array.isArray(e)) return e.map(Gt);
+	let t = {};
+	for (let n of Object.keys(e)) t[n] = Gt(e[n]);
+	return t;
+}
+var Kt = class {
+	rawAst;
+	constructor(e) {
+		this.rawAst = e;
+	}
+	transform() {
+		return {
+			...this.rawAst,
+			body: this.transformChildren(this.rawAst.body)
+		};
+	}
+	transformChildren(e) {
+		let t = [];
+		for (let r of e) r.type === n.Text && typeof r.content == "string" && this.isWhitespaceOnly(r.content) || t.push(this.transformNode(r));
+		return t;
+	}
+	transformNode(e) {
+		if (e.type === n.Element) return e.tagName === "script" ? this.transformScriptElement(e) : {
+			...e,
+			attributes: e.attributes.map((e) => e.type === n.Attribute && e.value !== null && typeof e.value != "string" && e.value.type === n.Interpolation ? {
+				...e,
+				value: this.transformInterpolation(e.value)
+			} : e),
+			children: this.transformChildren(e.children)
+		};
+		if (e.type === n.Interpolation) return this.transformInterpolation(e);
+		if (e.type === n.If) {
+			let t = typeof e.test == "string" && e.test.trim().length > 0 ? Q(e.test, 0, { ecmaVersion: "latest" }) : e.test, n = null;
+			return Array.isArray(e.alternate) ? n = this.transformChildren(e.alternate) : e.alternate !== null && (n = this.transformNode(e.alternate)), {
+				...e,
+				test: t,
+				consequent: this.transformChildren(e.consequent),
+				alternate: n
+			};
+		}
+		return e.type === n.For ? {
+			...e,
+			iterable: typeof e.iterable == "string" ? Q(e.iterable, 0, { ecmaVersion: "latest" }) : e.iterable,
+			key: typeof e.key == "string" && e.key.trim().length > 0 ? Q(e.key, 0, { ecmaVersion: "latest" }) : e.key ?? null,
+			body: this.transformChildren(e.body)
+		} : e.type === n.Switch ? this.transformSwitchToIfChain(e) : e;
+	}
+	transformSwitchToIfChain(e) {
+		let t = typeof e.discriminant == "string" ? Q(e.discriminant, 0, { ecmaVersion: "latest" }) : e.discriminant, r = (i) => {
+			let a = e.cases[i];
+			if (!a) return null;
+			if (a.expression === null) return this.transformChildren(a.body);
+			let o = typeof a.expression == "string" && a.expression.trim().length > 0 ? Q(a.expression, 0, { ecmaVersion: "latest" }) : a.expression, s = {
+				type: "BinaryExpression",
+				operator: "===",
+				left: Gt(t),
+				right: o,
+				start: 0,
+				end: 0
+			}, c = this.transformChildren(a.body), l = r(i + 1), u = null;
+			return (Array.isArray(l) || l !== null && l.type === n.If) && (u = l), {
+				type: n.If,
+				test: s,
+				consequent: c,
+				alternate: u,
+				loc: a.loc
+			};
+		}, i = r(0);
+		return i ? Array.isArray(i) ? i[0] || {
+			type: n.Comment,
+			content: "empty switch",
+			loc: e.loc
+		} : i : {
+			type: n.Comment,
+			content: "empty switch",
+			loc: e.loc
+		};
+	}
+	transformInterpolation(e) {
+		if (typeof e.expression != "string") return e;
+		let t;
+		try {
+			t = Q(e.expression, 0, {
+				ecmaVersion: "latest",
+				allowAwaitOutsideFunction: !0
+			});
+		} catch (t) {
+			throw new i(`Failed to parse JS expression in interpolation: ${t instanceof Error ? t.message : String(t)}`, e.loc.start.line, e.loc.start.column, e.loc.start.offset);
+		}
+		return {
+			...e,
+			expression: t
+		};
+	}
+	transformScriptElement(e) {
+		let t = e.children.map((e) => {
+			if (e.type === n.Text && typeof e.content == "string") {
+				let t;
+				try {
+					let n = Wt(e.content, {
+						ecmaVersion: "latest",
+						sourceType: "module",
+						allowAwaitOutsideFunction: !0,
+						allowReturnOutsideFunction: !0
+					});
+					t = n.body.length === 1 && n.body[0] !== void 0 ? n.body[0] : n.body;
+				} catch (t) {
+					throw new i(`Failed to parse script tag JS content: ${t instanceof Error ? t.message : String(t)}`, e.loc.start.line, e.loc.start.column, e.loc.start.offset);
+				}
+				return {
+					...e,
+					content: t
+				};
+			}
+			return e;
+		});
+		return {
+			...e,
+			children: t
+		};
+	}
+	isWhitespaceOnly(e) {
+		if (e.length === 0) return !1;
+		for (let t = 0; t < e.length; t++) {
+			let n = e.charCodeAt(t);
+			if (n !== 32 && n !== 9 && n !== 10 && n !== 13) return !1;
+		}
+		return !0;
+	}
+}, qt = class {
+	ast;
+	bytecode = [];
+	constants = [];
+	nextRegisterId = 0;
+	declaredVars = /* @__PURE__ */ new Set();
+	imports = [];
+	bindingPositions = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.ast = e;
+	}
+	generate() {
+		if (this.bytecode = [], this.constants = [], this.nextRegisterId = 0, this.declaredVars = /* @__PURE__ */ new Set(), this.imports = [], this.bindingPositions = /* @__PURE__ */ new Map(), this.collectDeclaredVars(this.ast.body), this.ast.body.length === 0) {
+			let e = this.allocRegister();
+			return this.emit(a.CREATE_FRAGMENT, e), this.emit(a.RETURN, e), {
+				bytecode: this.bytecode,
+				constants: this.constants,
+				reactiveBindings: this.buildReactiveBindings(),
+				declaredVars: [...this.declaredVars],
+				imports: this.imports
+			};
+		}
+		if (this.ast.body.length === 1 && this.ast.body[0]?.type === n.Element) {
+			let e = this.allocRegister();
+			this.compileElement(this.ast.body[0], e), this.emit(a.RETURN, e);
+		} else {
+			let e = this.allocRegister();
+			this.emit(a.CREATE_FRAGMENT, e);
+			for (let t of this.ast.body) this.compileNode(t, e);
+			this.emit(a.RETURN, e);
+		}
+		return {
+			bytecode: this.bytecode,
+			constants: this.constants,
+			reactiveBindings: this.buildReactiveBindings(),
+			declaredVars: [...this.declaredVars],
+			imports: this.imports
+		};
+	}
+	compileNode(e, t) {
+		switch (e.type) {
+			case n.Element:
+				e.tagName === "script" ? this.compileScriptElement(e) : this.compileElementNode(e, t);
+				break;
+			case n.Text:
+				this.compileTextNode(e, t);
+				break;
+			case n.Interpolation:
+				this.compileInterpolationNode(e, t);
+				break;
+			case n.Comment:
+				this.compileCommentNode(e, t);
+				break;
+			case n.If:
+				this.compileIfNode(e, t);
+				break;
+			case n.For:
+				this.compileForNode(e, t);
+				break;
+		}
+	}
+	filterRuntimeScriptAst(e) {
+		if (Array.isArray(e)) {
+			let t = e.filter((e) => e && e.type !== "ImportDeclaration");
+			return t.length === 1 ? t[0] : t;
+		}
+		return e && typeof e == "object" && e.type === "ImportDeclaration" ? null : e;
+	}
+	compileScriptElement(e) {
+		for (let t of e.children) if (t.type === n.Text && typeof t.content == "object" && t.content !== null) {
+			let e = this.filterRuntimeScriptAst(t.content);
+			if (e !== null && (!Array.isArray(e) || e.length > 0)) {
+				let t = this.addConstant(e);
+				this.emit(a.EXEC_SCRIPT, t);
+			}
+		}
+	}
+	isComponentTag(e) {
+		if (this.imports.some((t) => t.localName === e)) return !0;
+		let t = e.charAt(0);
+		return t !== "" && t === t.toUpperCase() && t !== t.toLowerCase();
+	}
+	compileElement(e, t) {
+		let r = this.isComponentTag(e.tagName), i = this.addConstant(e.tagName);
+		if (r) {
+			let r = { __drift_props__: !0 };
+			for (let t of e.attributes) t.type === n.Attribute && (t.value === null ? r[t.name] = !0 : typeof t.value == "string" ? r[t.name] = t.value : t.value.type === n.Interpolation && (r[t.name] = t.value.expression));
+			let o = this.addConstant(r), s = this.bytecode.length;
+			this.emit(a.CREATE_ELEMENT, t, i, o);
+			for (let t of e.attributes) t.type === n.Attribute && t.value !== null && typeof t.value != "string" && t.value.type === n.Interpolation && this.recordBindingPositions(t.value.expression, s, a.CREATE_ELEMENT);
+		} else {
+			this.emit(a.CREATE_ELEMENT, t, i);
+			for (let n of e.attributes) this.compileAttributeNode(n, t);
+			for (let n of e.children) this.compileNode(n, t);
+		}
+	}
+	compileElementNode(e, t) {
+		let n = this.allocRegister();
+		this.compileElement(e, n), this.emit(a.APPEND_CHILD, t, n);
+	}
+	compileAttributeNode(e, t) {
+		let r = this.addConstant(e.name);
+		if (e.value === null) {
+			let e = this.addConstant(!0);
+			this.emit(a.SET_ATTR, t, r, e, 0);
+		} else if (typeof e.value == "string") {
+			let n = this.addConstant(e.value);
+			this.emit(a.SET_ATTR, t, r, n, 0);
+		} else if (e.value.type === n.Interpolation) {
+			let n = this.addConstant(e.value.expression), i = this.bytecode.length;
+			this.emit(a.SET_ATTR, t, r, n, 1), this.recordBindingPositions(e.value.expression, i, a.SET_ATTR);
+		}
+	}
+	compileTextNode(e, t) {
+		let n = this.allocRegister(), r = this.addConstant(e.content);
+		this.emit(a.CREATE_TEXT, n, r), this.emit(a.APPEND_CHILD, t, n);
+	}
+	compileInterpolationNode(e, t) {
+		let n = this.allocRegister(), r = this.addConstant(e.expression), i = this.bytecode.length;
+		this.emit(a.INTERPOLATE_TEXT, n, r), this.emit(a.APPEND_CHILD, t, n), this.recordBindingPositions(e.expression, i, a.INTERPOLATE_TEXT);
+	}
+	compileCommentNode(e, t) {
+		let n = this.allocRegister(), r = this.addConstant(e.content);
+		this.emit(a.CREATE_COMMENT, n, r), this.emit(a.APPEND_CHILD, t, n);
+	}
+	compileNodesToSubModule(e) {
+		let t = this.bytecode, n = this.constants, r = this.nextRegisterId, i = this.bindingPositions;
+		this.bytecode = [], this.constants = [], this.nextRegisterId = 0, this.bindingPositions = /* @__PURE__ */ new Map();
+		let o = this.allocRegister();
+		this.emit(a.CREATE_FRAGMENT, o);
+		for (let t of e) this.compileNode(t, o);
+		this.emit(a.RETURN, o);
+		let s = {
+			bytecode: this.bytecode,
+			constants: this.constants,
+			reactiveBindings: this.buildReactiveBindings()
+		};
+		return this.bytecode = t, this.constants = n, this.nextRegisterId = r, this.bindingPositions = i, s;
+	}
+	collectDepsFromSubModule(e, t) {
+		let n = new Set(e.reactiveBindings.map((e) => e.variable));
+		if (t) for (let e of this.extractIdentifiers(t)) this.declaredVars.has(e) && n.add(e);
+		return [...n];
+	}
+	compileIfNode(e, t) {
+		let n = this.compileNodesToSubModule(e.consequent), r = this.addConstant(n), i = 255, o = null;
+		if (e.alternate !== null) {
+			let t;
+			t = Array.isArray(e.alternate) ? e.alternate : [e.alternate], o = this.compileNodesToSubModule(t), i = this.addConstant(o);
+		}
+		let s = new Set(this.collectDepsFromSubModule(n, e.test));
+		if (o) for (let e of this.collectDepsFromSubModule(o)) s.add(e);
+		let c = this.addConstant(Array.from(s)), l = this.addConstant(e.test);
+		this.emit(a.REACTIVE_IF, t, l, r, i, c);
+	}
+	compileForNode(e, t) {
+		let n = this.compileNodesToSubModule(e.body), r = this.addConstant(n), i = this.addConstant(e.iterable), o = this.addConstant(e.item), s = e.index === null ? 255 : this.addConstant(e.index), c = e.key ? this.addConstant(e.key) : 255, l = this.collectDepsFromSubModule(n, e.iterable), u = this.addConstant(l);
+		this.emit(a.REACTIVE_FOR, t, i, o, s, c, r, u);
+	}
+	collectDeclaredVars(e) {
+		for (let t of e) if (t.type === n.Element && t.tagName === "script") {
+			for (let e of t.children) if (e.type === n.Text && typeof e.content == "object" && e.content !== null) {
+				let t = e.content;
+				if (Array.isArray(t)) for (let e of t) this.extractVarNames(e);
+				else this.extractVarNames(t);
+			}
+		}
+	}
+	extractVarNames(e) {
+		if (!(!e || typeof e != "object")) {
+			if (e.type === "VariableDeclaration") for (let t of e.declarations) this.extractBindingIdentifiers(t.id);
+			else if (e.type === "FunctionDeclaration" && e.id?.type === "Identifier") this.declaredVars.add(e.id.name);
+			else if (e.type === "ImportDeclaration" && Array.isArray(e.specifiers)) {
+				let t = typeof e.source?.value == "string" ? e.source.value : "";
+				for (let n of e.specifiers) if (n.local?.type === "Identifier") {
+					let e = n.local.name;
+					this.declaredVars.add(e);
+					let r = n.type === "ImportDefaultSpecifier", i = n.type === "ImportSpecifier" && n.imported?.type === "Identifier" ? n.imported.name : void 0;
+					this.imports.push({
+						localName: e,
+						source: t,
+						isDefault: r,
+						importedName: i
+					});
+				}
+			}
+		}
+	}
+	extractBindingIdentifiers(e) {
+		if (!(!e || typeof e != "object")) if (e.type === "Identifier") this.declaredVars.add(e.name);
+		else if (e.type === "ObjectPattern" && Array.isArray(e.properties)) for (let t of e.properties) t.type === "Property" ? this.extractBindingIdentifiers(t.value) : t.type === "RestElement" && this.extractBindingIdentifiers(t.argument);
+		else if (e.type === "ArrayPattern" && Array.isArray(e.elements)) for (let t of e.elements) t && this.extractBindingIdentifiers(t);
+		else e.type === "AssignmentPattern" && this.extractBindingIdentifiers(e.left);
+	}
+	extractIdentifiers(e) {
+		let t = /* @__PURE__ */ new Set();
+		if (!e || typeof e != "object" || !e.type) return t;
+		switch (e.type) {
+			case "Identifier":
+				t.add(e.name);
+				break;
+			case "BinaryExpression":
+			case "LogicalExpression":
+				for (let n of this.extractIdentifiers(e.left)) t.add(n);
+				for (let n of this.extractIdentifiers(e.right)) t.add(n);
+				break;
+			case "UnaryExpression":
+			case "UpdateExpression":
+				for (let n of this.extractIdentifiers(e.argument)) t.add(n);
+				break;
+			case "MemberExpression":
+				for (let n of this.extractIdentifiers(e.object)) t.add(n);
+				break;
+			case "CallExpression":
+				for (let n of this.extractIdentifiers(e.callee)) t.add(n);
+				for (let n of e.arguments) for (let e of this.extractIdentifiers(n)) t.add(e);
+				break;
+			case "ConditionalExpression":
+				for (let n of this.extractIdentifiers(e.test)) t.add(n);
+				for (let n of this.extractIdentifiers(e.consequent)) t.add(n);
+				for (let n of this.extractIdentifiers(e.alternate)) t.add(n);
+				break;
+			case "AssignmentExpression":
+				for (let n of this.extractIdentifiers(e.left)) t.add(n);
+				for (let n of this.extractIdentifiers(e.right)) t.add(n);
+				break;
+			case "ArrowFunctionExpression":
+			case "FunctionExpression":
+				for (let n of this.extractIdentifiers(e.body)) t.add(n);
+				break;
+			case "BlockStatement":
+				for (let n of e.body) for (let e of this.extractIdentifiers(n)) t.add(e);
+				break;
+			case "ExpressionStatement":
+				for (let n of this.extractIdentifiers(e.expression)) t.add(n);
+				break;
+			case "ReturnStatement":
+				if (e.argument) for (let n of this.extractIdentifiers(e.argument)) t.add(n);
+				break;
+			case "NewExpression":
+				for (let n of this.extractIdentifiers(e.callee)) t.add(n);
+				if (e.arguments) for (let n of e.arguments) for (let e of this.extractIdentifiers(n)) t.add(e);
+				break;
+			case "ForStatement":
+				if (e.init) for (let n of this.extractIdentifiers(e.init)) t.add(n);
+				if (e.test) for (let n of this.extractIdentifiers(e.test)) t.add(n);
+				if (e.update) for (let n of this.extractIdentifiers(e.update)) t.add(n);
+				if (e.body) for (let n of this.extractIdentifiers(e.body)) t.add(n);
+				break;
+			case "ForOfStatement":
+			case "ForInStatement":
+				if (e.left) for (let n of this.extractIdentifiers(e.left)) t.add(n);
+				if (e.right) for (let n of this.extractIdentifiers(e.right)) t.add(n);
+				if (e.body) for (let n of this.extractIdentifiers(e.body)) t.add(n);
+				break;
+			case "WhileStatement":
+			case "DoWhileStatement":
+				if (e.test) for (let n of this.extractIdentifiers(e.test)) t.add(n);
+				if (e.body) for (let n of this.extractIdentifiers(e.body)) t.add(n);
+				break;
+		}
+		return t;
+	}
+	recordBindingPositions(e, t, n) {
+		if (this.declaredVars.size === 0) return;
+		let r = this.extractIdentifiers(e);
+		for (let e of r) this.declaredVars.has(e) && (this.bindingPositions.has(e) || this.bindingPositions.set(e, []), this.bindingPositions.get(e).push({
+			pc: t,
+			opcode: n
+		}));
+	}
+	buildReactiveBindings() {
+		let e = [];
+		for (let [t, n] of this.bindingPositions) e.push({
+			variable: t,
+			positions: n
+		});
+		return e;
+	}
+	allocRegister() {
+		return this.nextRegisterId++;
+	}
+	addConstant(e) {
+		e && typeof e == "object" && e.type && typeof e.type == "string" && (e = { __drift_fn__: `(scope, declaredVars, setScopeValue, inScopeChain, resolveIterable) => (${$(e)})` });
+		let t = this.constants.findIndex((t) => this.isConstantEqual(t, e));
+		return t === -1 ? (this.constants.push(e), this.constants.length - 1) : t;
+	}
+	isConstantEqual(e, t) {
+		return e === t || typeof e == "object" && typeof t == "object" && e !== null && t !== null && JSON.stringify(e) === JSON.stringify(t);
+	}
+	emit(e, ...t) {
+		this.bytecode.push(e, ...t);
+	}
+	emitJumpIfFalsePlaceholder(e) {
+		let t = this.bytecode.length;
+		return this.bytecode.push(a.JUMP_IF_FALSE, e, 0, 0), t;
+	}
+	emitJumpPlaceholder() {
+		let e = this.bytecode.length;
+		return this.bytecode.push(a.JUMP, 0, 0), e;
+	}
+	emitJump(e) {
+		let t = e >> 8 & 255, n = e & 255;
+		this.bytecode.push(a.JUMP, t, n);
+	}
+	emitLoopIterPlaceholder(e, t, n, r, i) {
+		let o = this.bytecode.length, s = r >> 8 & 255, c = r & 255, l = i >> 8 & 255, u = i & 255;
+		return this.bytecode.push(a.LOOP_ITER, e, t, n, s, c, l, u, 0, 0), o;
+	}
+	patchJump(e, t) {
+		let n = t >> 8 & 255, r = t & 255, i = this.bytecode[e];
+		i === a.JUMP_IF_FALSE ? (this.bytecode[e + 2] = n, this.bytecode[e + 3] = r) : i === a.JUMP ? (this.bytecode[e + 1] = n, this.bytecode[e + 2] = r) : i === a.LOOP_ITER && (this.bytecode[e + 8] = n, this.bytecode[e + 9] = r);
+	}
+};
+function Jt(e) {
+	return !e || typeof e != "object" ? null : e.type === "Identifier" ? e.name : e.type === "MemberExpression" ? Jt(e.object) : null;
+}
+function $(e, t) {
+	if (e == null) return "undefined";
+	if (typeof e != "object") return typeof e == "string" ? JSON.stringify(e) : String(e);
+	if (Array.isArray(e)) return e.map((e) => $(e, t)).join("; ");
+	switch (e.type) {
+		case "Identifier": return t && t.has(e.name) ? e.name : `((typeof inScopeChain === 'function' ? inScopeChain(scope, ${JSON.stringify(e.name)}) : Object.prototype.hasOwnProperty.call(scope || {}, ${JSON.stringify(e.name)})) ? scope[${JSON.stringify(e.name)}] : (typeof globalThis !== 'undefined' && Object.prototype.hasOwnProperty.call(globalThis, ${JSON.stringify(e.name)}) ? globalThis[${JSON.stringify(e.name)}] : undefined))`;
+		case "Literal": return typeof e.raw == "string" ? e.raw : typeof e.value == "string" ? JSON.stringify(e.value) : String(e.value);
+		case "BinaryExpression":
+		case "LogicalExpression": return `(${$(e.left, t)} ${e.operator} ${$(e.right, t)})`;
+		case "UnaryExpression": return `(${e.operator} ${$(e.argument, t)})`;
+		case "ConditionalExpression": return `(${$(e.test, t)} ? ${$(e.consequent, t)} : ${$(e.alternate, t)})`;
+		case "MemberExpression": return e.computed ? `(${$(e.object, t)}[${$(e.property, t)}])` : `(${$(e.object, t)}.${e.property.name})`;
+		case "CallExpression": {
+			let n = `(${$(e.callee, t)}(${e.arguments ? e.arguments.map((e) => $(e, t)).join(", ") : ""}))`;
+			if (e.callee?.type === "MemberExpression" && e.callee.property?.type === "Identifier") {
+				let r = Jt(e.callee.object), i = e.callee.property.name;
+				if (r && [
+					"push",
+					"pop",
+					"shift",
+					"unshift",
+					"splice",
+					"sort",
+					"reverse"
+				].includes(i) && (!t || !t.has(r))) return `(() => { const _res = ${n}; if (typeof setScopeValue === 'function' && scope) setScopeValue(scope, ${JSON.stringify(r)}, scope[${JSON.stringify(r)}]); return _res; })()`;
+			}
+			return n;
+		}
+		case "AssignmentExpression": {
+			let n = $(e.right, t);
+			if (e.left?.type === "Identifier") {
+				let r = e.left.name;
+				if (t && t.has(r)) return `(${r} ${e.operator} ${n})`;
+				if (e.operator === "=") return `(typeof setScopeValue === 'function' ? setScopeValue(scope, ${JSON.stringify(r)}, ${n}) : ((scope || {})[${JSON.stringify(r)}] = ${n}))`;
+				{
+					let t = e.operator.slice(0, -1);
+					return `(typeof setScopeValue === 'function' ? setScopeValue(scope, ${JSON.stringify(r)}, (scope[${JSON.stringify(r)}] ${t} ${n})) : ((scope || {})[${JSON.stringify(r)}] ${e.operator} ${n}))`;
+				}
+			}
+			if (e.left?.type === "MemberExpression") {
+				let r = Jt(e.left), i = `(${$(e.left, t)} ${e.operator} ${n})`;
+				if (r && (!t || !t.has(r))) return `(() => { const _res = ${i}; if (typeof setScopeValue === 'function' && scope) setScopeValue(scope, ${JSON.stringify(r)}, scope[${JSON.stringify(r)}]); return _res; })()`;
+			}
+			if (e.left?.type === "ArrayPattern") {
+				let r = [], i = e.left.elements || [];
+				for (let e = 0; e < i.length; e++) {
+					let n = i[e];
+					if (n?.type === "Identifier") {
+						let i = n.name;
+						(!t || !t.has(i)) && r.push(`if (typeof setScopeValue === 'function' && scope) setScopeValue(scope, ${JSON.stringify(i)}, _val[${e}]);`);
+					}
+				}
+				return `(() => { const _val = ${n} || []; ${r.join(" ")} return _val; })()`;
+			}
+			if (e.left?.type === "ObjectPattern") {
+				let r = [], i = e.left.properties || [];
+				for (let e of i) if (e.type === "Property" && e.value?.type === "Identifier") {
+					let n = e.key?.name || (typeof e.key?.value == "string" ? e.key.value : String(e.key?.value)), i = e.value.name;
+					(!t || !t.has(i)) && r.push(`if (typeof setScopeValue === 'function' && scope) setScopeValue(scope, ${JSON.stringify(i)}, _val[${JSON.stringify(n)}]);`);
+				}
+				return `(() => { const _val = ${n} || {}; ${r.join(" ")} return _val; })()`;
+			}
+			return `(${$(e.left, t)} ${e.operator} ${n})`;
+		}
+		case "UpdateExpression":
+			if (e.argument?.type === "Identifier") {
+				let n = e.argument.name;
+				if (t && t.has(n)) return e.prefix ? `(${e.operator}${n})` : `(${n}${e.operator})`;
+				let r = e.operator === "++" ? "+" : "-";
+				return e.prefix ? `(typeof setScopeValue === 'function' ? (setScopeValue(scope, ${JSON.stringify(n)}, (Number(scope[${JSON.stringify(n)}]) || 0) ${r} 1), scope[${JSON.stringify(n)}]) : ((scope || {})[${JSON.stringify(n)}] = (Number((scope || {})[${JSON.stringify(n)}]) || 0) ${r} 1))` : `(() => { const _v = Number(scope[${JSON.stringify(n)}]) || 0; if (typeof setScopeValue === 'function') setScopeValue(scope, ${JSON.stringify(n)}, _v ${r} 1); else (scope || {})[${JSON.stringify(n)}] = _v ${r} 1; return _v; })()`;
+			}
+			if (e.argument?.type === "MemberExpression") {
+				let n = Jt(e.argument), r = e.prefix ? `(${e.operator}${$(e.argument, t)})` : `(${$(e.argument, t)}${e.operator})`;
+				if (n && (!t || !t.has(n))) return `(() => { const _res = ${r}; if (typeof setScopeValue === 'function' && scope) setScopeValue(scope, ${JSON.stringify(n)}, scope[${JSON.stringify(n)}]); return _res; })()`;
+			}
+			return e.prefix ? `(${e.operator}${$(e.argument, t)})` : `(${$(e.argument, t)}${e.operator})`;
+		case "SequenceExpression": return `(${e.expressions ? e.expressions.map((e) => $(e, t)).join(", ") : ""})`;
+		case "ArrayExpression": return `[${e.elements ? e.elements.map((e) => e?.type === "SpreadElement" ? "..." + $(e.argument, t) : $(e, t)).join(", ") : ""}]`;
+		case "ObjectExpression": return `{${e.properties ? e.properties.map((e) => e.type === "SpreadElement" ? "..." + $(e.argument, t) : `${e.computed ? "[" + $(e.key, t) + "]" : e.key.name}: ${$(e.value, t)}`).join(", ") : ""}}`;
+		case "SpreadElement": return `...${$(e.argument, t)}`;
+		case "TemplateLiteral": return `\`${e.quasis ? e.quasis.map((n, r) => (n.value?.raw ?? "") + (e.expressions && e.expressions[r] ? "${" + $(e.expressions[r], t) + "}" : "")).join("") : ""}\``;
+		case "TaggedTemplateExpression": return `${$(e.tag, t)}${$(e.quasi, t)}`;
+		case "ThisExpression": return "scope";
+		case "BlockStatement": {
+			let n = new Set(t);
+			return `{ ${(e.body ? e.body.map((e) => $(e, n)).filter(Boolean) : []).join("; ")}; }`;
+		}
+		case "ExpressionStatement": return $(e.expression, t);
+		case "ReturnStatement": return `return ${e.argument ? $(e.argument, t) : ""}`;
+		case "BreakStatement": return e.label ? `break ${e.label.name}` : "break";
+		case "ContinueStatement": return e.label ? `continue ${e.label.name}` : "continue";
+		case "IfStatement": return `if (${$(e.test, t)}) ${e.consequent.type === "BlockStatement" ? $(e.consequent, t) : `{ ${$(e.consequent, t)}; }`}${e.alternate ? ` else ${e.alternate.type === "BlockStatement" || e.alternate.type === "IfStatement" ? $(e.alternate, t) : `{ ${$(e.alternate, t)}; }`}` : ""}`;
+		case "ForStatement": {
+			let n = new Set(t);
+			if (e.init?.type === "VariableDeclaration" && e.init.declarations) for (let t of e.init.declarations) {
+				let e = t.id?.name;
+				e && n.add(e);
+			}
+			let r = "";
+			e.init?.type === "VariableDeclaration" && e.init.declarations ? r = "let " + e.init.declarations.map((e) => `${e.id.name} = ${e.init ? $(e.init, n) : "undefined"}`).join(", ") : e.init && (r = $(e.init, n));
+			let i = e.test ? $(e.test, n) : "", a = e.update ? $(e.update, n) : "", o = e.body ? $(e.body, n) : "";
+			return `(() => { for (${r}; ${i}; ${a}) ${o}; })()`;
+		}
+		case "ForOfStatement": {
+			let n = new Set(t), r = e.left?.type === "VariableDeclaration" ? e.left.declarations[0]?.id?.name : e.left?.name;
+			return r && n.add(r), `(() => { const _iter = (typeof resolveIterable === 'function' ? resolveIterable(${$(e.right, t)}) : (${$(e.right, t)} || [])); for (let ${r} of _iter) { if (scope) scope[${JSON.stringify(r)}] = ${r}; ${$(e.body, n)}; } })()`;
+		}
+		case "ForInStatement": {
+			let n = new Set(t), r = e.left?.type === "VariableDeclaration" ? e.left.declarations[0]?.id?.name : e.left?.name;
+			return r && n.add(r), `(() => { const _obj = ${$(e.right, t)}; if (_obj) { for (let ${r} in _obj) { if (scope) scope[${JSON.stringify(r)}] = ${r}; ${$(e.body, n)}; } } })()`;
+		}
+		case "WhileStatement": return `(() => { while (${$(e.test, t)}) ${$(e.body, t)}; })()`;
+		case "DoWhileStatement": return `(() => { do ${$(e.body, t)} while (${$(e.test, t)}); })()`;
+		case "ArrayPattern": return `[ ${e.elements ? e.elements.map((e) => e ? e.type === "RestElement" ? "..." + $(e.argument, t) : e.type === "AssignmentPattern" ? `${$(e.left, t)} = ${$(e.right, t)}` : e.name || $(e, t) : "").join(", ") : ""} ]`;
+		case "ObjectPattern": return `{ ${e.properties ? e.properties.map((e) => {
+			if (e.type === "Property") {
+				let n = e.key?.name || $(e.key, t), r = e.value?.name || $(e.value, t);
+				return n === r ? n : `${n}: ${r}`;
+			}
+			return e.type === "RestElement" ? `...${$(e.argument, t)}` : "";
+		}).filter(Boolean).join(", ") : ""} }`;
+		case "VariableDeclaration": {
+			let n = new Set(t), r = [];
+			if (e.declarations) for (let i of e.declarations) if (i.id?.type === "ObjectPattern") {
+				let e = i.init ? $(i.init, t) : "undefined";
+				for (let a of i.id.properties || []) if (a.type === "Property") {
+					let i = a.key?.name || (typeof a.key?.value == "string" ? a.key.value : $(a.key, t)), o = a.value?.name, s = null;
+					if (a.value?.type === "AssignmentPattern" ? (o = a.value.left?.name || $(a.value.left, t), s = $(a.value.right, t)) : o ||= $(a.value, t), o) {
+						n.add(o);
+						let t = `((${e} && (${JSON.stringify(i)} in ${e})) ? ${e}[${JSON.stringify(i)}] : ${s ?? "undefined"})`;
+						r.push(`(typeof setScopeValue === 'function' ? setScopeValue(scope, ${JSON.stringify(o)}, ${t}) : ((scope || {})[${JSON.stringify(o)}] = ${t}))`);
+					}
+				}
+			} else {
+				let e = i.id?.name || $(i.id, t);
+				i.id?.name && n.add(i.id.name);
+				let a = i.init ? $(i.init, t) : "undefined";
+				t && i.id?.name && t.has(i.id.name) ? r.push(`${i.id.name} = ${a}`) : r.push(`(typeof setScopeValue === 'function' ? setScopeValue(scope, ${JSON.stringify(e)}, ${a}) : ((scope || {})[${JSON.stringify(e)}] = ${a}))`);
+			}
+			return `(${r.filter(Boolean).join(", ") || "undefined"})`;
+		}
+		case "FunctionDeclaration": {
+			let n = e.id?.name, r = new Set(t);
+			n && r.add(n);
+			let i = [];
+			if (e.params) for (let n of e.params) if (n.type === "AssignmentPattern") {
+				let e = n.left?.name || $(n.left, t), a = $(n.right, t);
+				n.left?.name && r.add(n.left.name), i.push(`${e} = ${a}`);
+			} else {
+				let e = n.name || n.id?.name || n.left && n.left.name || $(n, t);
+				e && (i.push(e), r.add(e));
+			}
+			if (e.body?.type === "BlockStatement" && Array.isArray(e.body.body)) for (let t of e.body.body) if (t.type === "VariableDeclaration" && t.declarations) for (let e of t.declarations) e.id?.name && r.add(e.id.name);
+			else t.type === "FunctionDeclaration" && t.id?.name && r.add(t.id.name);
+			let a = i.join(", "), o = e.body?.type === "BlockStatement" ? `{ ${e.body.body.map((e) => $(e, r)).filter(Boolean).join("; ")}; }` : `{ ${$(e.body, r)}; }`, s = `function ${n || ""}(${a}) ${o}`;
+			return n ? `(typeof setScopeValue === 'function' ? setScopeValue(scope, ${JSON.stringify(n)}, ${s}) : ((scope || {})[${JSON.stringify(n)}] = ${s}))` : s;
+		}
+		case "ArrowFunctionExpression":
+		case "FunctionExpression": {
+			let n = new Set(t), r = [];
+			if (e.params) for (let i of e.params) if (i.type === "AssignmentPattern") {
+				let e = i.left?.name || $(i.left, t), a = $(i.right, t);
+				i.left?.name && n.add(i.left.name), r.push(`${e} = ${a}`);
+			} else {
+				let e = i.name || i.id?.name || i.left && i.left.name || $(i, t);
+				e && (r.push(e), n.add(e));
+			}
+			if (e.body?.type === "BlockStatement" && Array.isArray(e.body.body)) for (let t of e.body.body) if (t.type === "VariableDeclaration" && t.declarations) for (let e of t.declarations) e.id?.name && n.add(e.id.name);
+			else t.type === "FunctionDeclaration" && t.id?.name && n.add(t.id.name);
+			let i = r.join(", ");
+			return e.body?.type === "BlockStatement" ? `((${i}) => ${`{ ${e.body.body.map((e) => $(e, n)).filter(Boolean).join("; ")}; }`})` : `((${i}) => ${$(e.body, n)})`;
+		}
+		case "NewExpression": return `new (${$(e.callee, t)})(${e.arguments ? e.arguments.map((e) => $(e, t)).join(", ") : ""})`;
+		case "EmptyStatement":
+		case "ImportDeclaration":
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier": return "";
+		case "ParenthesizedExpression":
+		case "ChainExpression": return $(e.expression, t);
+		default: return "";
+	}
+}
+//#endregion
+//#region src/index.ts
+function Yt(e, t = !1) {
+	let n = new Kt(new f(new l(e)).parse()).transform(), r = new qt(n).generate();
+	return t && (console.log("--- Transformed AST ---"), console.log(JSON.stringify(n, null, 2)), console.log("--- Compiled Module ---"), console.log(JSON.stringify(r, null, 2))), r;
+}
+//#endregion
+export { n as ASTNodeType, qt as DriftGenerator, l as DriftLexer, r as DriftLexerError, f as DriftParser, i as DriftParserError, Kt as DriftTransformer, t as LexerStateKind, a as Opcode, e as TokenType, $ as astToJS, Yt as compile };