@jackuait/blok 0.9.0 → 0.10.0-beta.10

package/dist/chunks/engine-javascript-CJpnSvzf.mjs

@@ -0,0 +1,2373 @@
+import { n as e, t } from "./objectSpread2-CWwMYL_U.mjs";
+import { t as n } from "./objectWithoutProperties-D0XxKB4n.mjs";
+//#region node_modules/@shikijs/engine-javascript/dist/scanner-BFcBmQR1.mjs
+var r = 4294967295, i = class {
+	constructor(t, n = {}) {
+		e(this, "regexps", void 0), this.patterns = t, this.options = n;
+		let { forgiving: r = !1, cache: i, regexConstructor: a } = n;
+		if (!a) throw Error("Option `regexConstructor` is not provided");
+		this.regexps = t.map((e) => {
+			if (typeof e != "string") return e;
+			let t = i == null ? void 0 : i.get(e);
+			if (t) {
+				if (t instanceof RegExp) return t;
+				if (r) return null;
+				throw t;
+			}
+			try {
+				let t = a(e);
+				return i == null || i.set(e, t), t;
+			} catch (t) {
+				if (i == null || i.set(e, t), r) return null;
+				throw t;
+			}
+		});
+	}
+	findNextMatchSync(e, t, n) {
+		let i = typeof e == "string" ? e : e.content, a = [];
+		function o(e, t, n = 0) {
+			return {
+				index: e,
+				captureIndices: t.indices.map((e) => e == null ? {
+					start: r,
+					end: r,
+					length: 0
+				} : {
+					start: e[0] + n,
+					end: e[1] + n,
+					length: e[1] - e[0]
+				})
+			};
+		}
+		for (let e = 0; e < this.regexps.length; e++) {
+			let n = this.regexps[e];
+			if (n) try {
+				n.lastIndex = t;
+				let r = n.exec(i);
+				if (!r) continue;
+				if (r.index === t) return o(e, r, 0);
+				a.push([
+					e,
+					r,
+					0
+				]);
+			} catch (e) {
+				if (this.options.forgiving) continue;
+				throw e;
+			}
+		}
+		if (a.length) {
+			let e = Math.min(...a.map((e) => e[1].index));
+			for (let [t, n, r] of a) if (n.index === e) return o(t, n, r);
+		}
+		return null;
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/checkPrivateRedeclaration.js
+function a(e, t) {
+	if (t.has(e)) throw TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateMethodInitSpec.js
+function o(e, t) {
+	a(e, t), t.add(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldInitSpec.js
+function s(e, t, n) {
+	a(e, t), t.set(e, n);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/assertClassBrand.js
+function c(e, t, n) {
+	if (typeof e == "function" ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldGet2.js
+function l(e, t) {
+	return e.get(c(e, t));
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldSet2.js
+function u(e, t, n) {
+	return e.set(c(e, t), n), n;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/getPrototypeOf.js
+function d(e) {
+	return d = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(e) {
+		return e.__proto__ || Object.getPrototypeOf(e);
+	}, d(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/superPropBase.js
+function f(e, t) {
+	for (; !{}.hasOwnProperty.call(e, t) && (e = d(e)) !== null;);
+	return e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/get.js
+function p() {
+	return p = typeof Reflect < "u" && Reflect.get ? Reflect.get.bind() : function(e, t, n) {
+		var r = f(e, t);
+		if (r) {
+			var i = Object.getOwnPropertyDescriptor(r, t);
+			return i.get ? i.get.call(arguments.length < 3 ? e : n) : i.value;
+		}
+	}, p.apply(null, arguments);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/superPropGet.js
+function m(e, t, n, r) {
+	var i = p(d(1 & r ? e.prototype : e), t, n);
+	return 2 & r && typeof i == "function" ? function(e) {
+		return i.apply(n, e);
+	} : i;
+}
+//#endregion
+//#region node_modules/oniguruma-parser/dist/utils.js
+function h(e) {
+	if ([...e].length !== 1) throw Error(`Expected "${e}" to be a single code point`);
+	return e.codePointAt(0);
+}
+function g(e, t, n) {
+	return e.has(t) || e.set(t, n), e.get(t);
+}
+var _ = new Set([
+	"alnum",
+	"alpha",
+	"ascii",
+	"blank",
+	"cntrl",
+	"digit",
+	"graph",
+	"lower",
+	"print",
+	"punct",
+	"space",
+	"upper",
+	"word",
+	"xdigit"
+]), v = String.raw;
+function y(e, t) {
+	if (e == null) throw Error(t == null ? "Value expected" : t);
+	return e;
+}
+//#endregion
+//#region node_modules/oniguruma-parser/dist/tokenizer/tokenize.js
+var ee = v`\[\^?`, te = `c.? | C(?:-.?)?|${v`[pP]\{(?:\^?[-\x20_]*[A-Za-z][-\x20\w]*\})?`}|${v`x[89A-Fa-f]\p{AHex}(?:\\x[89A-Fa-f]\p{AHex})*`}|${v`u(?:\p{AHex}{4})? | x\{[^\}]*\}? | x\p{AHex}{0,2}`}|${v`o\{[^\}]*\}?`}|${v`\d{1,3}`}`, ne = /[?*+][?+]?|\{(?:\d+(?:,\d*)?|,\d+)\}\??/, re = new RegExp(v`
+  \\ (?:
+    ${te}
+    | [gk]<[^>]*>?
+    | [gk]'[^']*'?
+    | .
+  )
+  | \( (?:
+    \? (?:
+      [:=!>({]
+      | <[=!]
+      | <[^>]*>
+      | '[^']*'
+      | ~\|?
+      | #(?:[^)\\]|\\.?)*
+      | [^:)]*[:)]
+    )?
+    | \*[^\)]*\)?
+  )?
+  | (?:${ne.source})+
+  | ${ee}
+  | .
+`.replace(/\s+/g, ""), "gsu"), ie = new RegExp(v`
+  \\ (?:
+    ${te}
+    | .
+  )
+  | \[:(?:\^?\p{Alpha}+|\^):\]
+  | ${ee}
+  | &&
+  | .
+`.replace(/\s+/g, ""), "gsu");
+function ae(e, n = {}) {
+	let r = t(t({ flags: "" }, n), {}, { rules: t({
+		captureGroup: !1,
+		singleline: !1
+	}, n.rules) });
+	if (typeof e != "string") throw Error("String expected as pattern");
+	let i = Me(r.flags), a = [i.extended], o = {
+		captureGroup: r.rules.captureGroup,
+		getCurrentModX() {
+			return a.at(-1);
+		},
+		numOpenGroups: 0,
+		popModX() {
+			a.pop();
+		},
+		pushModX(e) {
+			a.push(e);
+		},
+		replaceCurrentModX(e) {
+			a[a.length - 1] = e;
+		},
+		singleline: r.rules.singleline
+	}, s = [], c;
+	for (re.lastIndex = 0; c = re.exec(e);) {
+		let t = oe(o, e, c[0], re.lastIndex);
+		t.tokens ? s.push(...t.tokens) : t.token && s.push(t.token), t.lastIndex !== void 0 && (re.lastIndex = t.lastIndex);
+	}
+	let l = [], u = 0;
+	s.filter((e) => e.type === "GroupOpen").forEach((e) => {
+		e.kind === "capturing" ? e.number = ++u : e.raw === "(" && l.push(e);
+	}), u || l.forEach((e, t) => {
+		e.kind = "capturing", e.number = t + 1;
+	});
+	let d = u || l.length;
+	return {
+		tokens: s.map((e) => e.type === "EscapedNumber" ? Pe(e, d) : e).flat(),
+		flags: i
+	};
+}
+function oe(e, n, r, i) {
+	let [a, o] = r;
+	if (r === "[" || r === "[^") {
+		let e = se(n, r, i);
+		return {
+			tokens: e.tokens,
+			lastIndex: e.lastIndex
+		};
+	}
+	if (a === "\\") {
+		if ("AbBGyYzZ".includes(o)) return { token: de(r, r) };
+		if (/^\\g[<']/.test(r)) {
+			if (!/^\\g(?:<[^>]+>|'[^']+')$/.test(r)) throw Error(`Invalid group name "${r}"`);
+			return { token: Se(r) };
+		}
+		if (/^\\k[<']/.test(r)) {
+			if (!/^\\k(?:<[^>]+>|'[^']+')$/.test(r)) throw Error(`Invalid group name "${r}"`);
+			return { token: fe(r) };
+		}
+		if (o === "K") return { token: _e("keep", r) };
+		if (o === "N" || o === "R") return { token: x("newline", r, { negate: o === "N" }) };
+		if (o === "O") return { token: x("any", r) };
+		if (o === "X") return { token: x("text_segment", r) };
+		let e = le(r, { inCharClass: !1 });
+		return Array.isArray(e) ? { tokens: e } : { token: e };
+	}
+	if (a === "(") {
+		if (o === "*") return { token: De(r) };
+		if (r === "(?{") throw Error(`Unsupported callout "${r}"`);
+		if (r.startsWith("(?#")) {
+			if (n[i] !== ")") throw Error("Unclosed comment group \"(?#\"");
+			return { lastIndex: i + 1 };
+		}
+		if (/^\(\?[-imx]+[:)]$/.test(r)) return { token: Ee(r, e) };
+		if (e.pushModX(e.getCurrentModX()), e.numOpenGroups++, r === "(" && !e.captureGroup || r === "(?:") return { token: S("group", r) };
+		if (r === "(?>") return { token: S("atomic", r) };
+		if (r === "(?=" || r === "(?!" || r === "(?<=" || r === "(?<!") return { token: S(r[2] === "<" ? "lookbehind" : "lookahead", r, { negate: r.endsWith("!") }) };
+		if (r === "(" && e.captureGroup || r.startsWith("(?<") && r.endsWith(">") || r.startsWith("(?'") && r.endsWith("'")) return { token: S("capturing", r, t({}, r !== "(" && { name: r.slice(3, -1) })) };
+		if (r.startsWith("(?~")) {
+			if (r === "(?~|") throw Error(`Unsupported absence function kind "${r}"`);
+			return { token: S("absence_repeater", r) };
+		}
+		throw r === "(?(" ? /* @__PURE__ */ Error(`Unsupported conditional "${r}"`) : /* @__PURE__ */ Error(`Invalid or unsupported group option "${r}"`);
+	}
+	if (r === ")") {
+		if (e.popModX(), e.numOpenGroups--, e.numOpenGroups < 0) throw Error("Unmatched \")\"");
+		return { token: ye(r) };
+	}
+	if (e.getCurrentModX()) {
+		if (r === "#") {
+			let e = n.indexOf("\n", i);
+			return { lastIndex: e === -1 ? n.length : e };
+		}
+		if (/^\s$/.test(r)) {
+			let e = /\s+/y;
+			return e.lastIndex = i, { lastIndex: e.exec(n) ? e.lastIndex : i };
+		}
+	}
+	return r === "." ? { token: x("dot", r) } : r === "^" || r === "$" ? { token: de(e.singleline ? {
+		"^": v`\A`,
+		$: v`\Z`
+	}[r] : r, r) } : r === "|" ? { token: ue(r) } : ne.test(r) ? { tokens: Fe(r) } : { token: b(h(r), r) };
+}
+function se(e, t, n) {
+	let r = [ge(t[1] === "^", t)], i = 1, a;
+	for (ie.lastIndex = n; a = ie.exec(e);) {
+		let e = a[0];
+		if (e[0] === "[" && e[1] !== ":") i++, r.push(ge(e[1] === "^", e));
+		else if (e === "]") {
+			if (r.at(-1).type === "CharacterClassOpen") r.push(b(93, e));
+			else if (i--, r.push(pe(e)), !i) break;
+		} else {
+			let t = ce(e);
+			Array.isArray(t) ? r.push(...t) : r.push(t);
+		}
+	}
+	return {
+		tokens: r,
+		lastIndex: ie.lastIndex || e.length
+	};
+}
+function ce(e) {
+	if (e[0] === "\\") return le(e, { inCharClass: !0 });
+	if (e[0] === "[") {
+		let t = (/* @__PURE__ */ RegExp("\\[:(?<negate>\\^?)(?<name>[a-z]+):\\]", "")).exec(e);
+		if (!t || !_.has(t.groups.name)) throw Error(`Invalid POSIX class "${e}"`);
+		return x("posix", e, {
+			value: t.groups.name,
+			negate: !!t.groups.negate
+		});
+	}
+	return e === "-" ? me(e) : e === "&&" ? he(e) : b(h(e), e);
+}
+function le(e, { inCharClass: t }) {
+	let n = e[1];
+	if (n === "c" || n === "C") return Te(e);
+	if ("dDhHsSwW".includes(n)) return ke(e);
+	if (e.startsWith(v`\o{`)) throw Error(`Incomplete, invalid, or unsupported octal code point "${e}"`);
+	if (/^\\[pP]\{/.test(e)) {
+		if (e.length === 3) throw Error(`Incomplete or invalid Unicode property "${e}"`);
+		return Ae(e);
+	}
+	if ((/* @__PURE__ */ RegExp("^\\\\x[89A-Fa-f]\\p{AHex}", "u")).test(e)) try {
+		let t = e.split(/\\x/).slice(1).map((e) => parseInt(e, 16)), n = new TextDecoder("utf-8", {
+			ignoreBOM: !0,
+			fatal: !0
+		}).decode(new Uint8Array(t)), r = new TextEncoder();
+		return [...n].map((e) => {
+			let t = [...r.encode(e)].map((e) => `\\x${e.toString(16)}`).join("");
+			return b(h(e), t);
+		});
+	} catch (t) {
+		throw Error(`Multibyte code "${e}" incomplete or invalid in Oniguruma`);
+	}
+	if (n === "u" || n === "x") return b(Ne(e), e);
+	if (we.has(n)) return b(we.get(n), e);
+	if (/\d/.test(n)) return ve(t, e);
+	if (e === "\\") throw Error(v`Incomplete escape "\"`);
+	if (n === "M") throw Error(`Unsupported meta "${e}"`);
+	if ([...e].length === 2) return b(e.codePointAt(1), e);
+	throw Error(`Unexpected escape "${e}"`);
+}
+function ue(e) {
+	return {
+		type: "Alternator",
+		raw: e
+	};
+}
+function de(e, t) {
+	return {
+		type: "Assertion",
+		kind: e,
+		raw: t
+	};
+}
+function fe(e) {
+	return {
+		type: "Backreference",
+		raw: e
+	};
+}
+function b(e, t) {
+	return {
+		type: "Character",
+		value: e,
+		raw: t
+	};
+}
+function pe(e) {
+	return {
+		type: "CharacterClassClose",
+		raw: e
+	};
+}
+function me(e) {
+	return {
+		type: "CharacterClassHyphen",
+		raw: e
+	};
+}
+function he(e) {
+	return {
+		type: "CharacterClassIntersector",
+		raw: e
+	};
+}
+function ge(e, t) {
+	return {
+		type: "CharacterClassOpen",
+		negate: e,
+		raw: t
+	};
+}
+function x(e, n, r = {}) {
+	return t(t({
+		type: "CharacterSet",
+		kind: e
+	}, r), {}, { raw: n });
+}
+function _e(e, t, n = {}) {
+	return e === "keep" ? {
+		type: "Directive",
+		kind: e,
+		raw: t
+	} : {
+		type: "Directive",
+		kind: e,
+		flags: y(n.flags),
+		raw: t
+	};
+}
+function ve(e, t) {
+	return {
+		type: "EscapedNumber",
+		inCharClass: e,
+		raw: t
+	};
+}
+function ye(e) {
+	return {
+		type: "GroupClose",
+		raw: e
+	};
+}
+function S(e, n, r = {}) {
+	return t(t({
+		type: "GroupOpen",
+		kind: e
+	}, r), {}, { raw: n });
+}
+function be(e, t, n, r) {
+	return {
+		type: "NamedCallout",
+		kind: e,
+		tag: t,
+		arguments: n,
+		raw: r
+	};
+}
+function xe(e, t, n, r) {
+	return {
+		type: "Quantifier",
+		kind: e,
+		min: t,
+		max: n,
+		raw: r
+	};
+}
+function Se(e) {
+	return {
+		type: "Subroutine",
+		raw: e
+	};
+}
+var Ce = new Set([
+	"COUNT",
+	"CMP",
+	"ERROR",
+	"FAIL",
+	"MAX",
+	"MISMATCH",
+	"SKIP",
+	"TOTAL_COUNT"
+]), we = new Map([
+	["a", 7],
+	["b", 8],
+	["e", 27],
+	["f", 12],
+	["n", 10],
+	["r", 13],
+	["t", 9],
+	["v", 11]
+]);
+function Te(e) {
+	let t = e[1] === "c" ? e[2] : e[3];
+	if (!t || !/[A-Za-z]/.test(t)) throw Error(`Unsupported control character "${e}"`);
+	return b(h(t.toUpperCase()) - 64, e);
+}
+function Ee(e, n) {
+	let { on: r, off: i } = (/* @__PURE__ */ RegExp("^\\(\\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?", "")).exec(e).groups;
+	i != null || (i = "");
+	let a = (n.getCurrentModX() || r.includes("x")) && !i.includes("x"), o = je(r), s = je(i), c = {};
+	if (o && (c.enable = o), s && (c.disable = s), e.endsWith(")")) return n.replaceCurrentModX(a), _e("flags", e, { flags: c });
+	if (e.endsWith(":")) return n.pushModX(a), n.numOpenGroups++, S("group", e, t({}, (o || s) && { flags: c }));
+	throw Error(`Unexpected flag modifier "${e}"`);
+}
+function De(e) {
+	var t;
+	let n = (/* @__PURE__ */ RegExp("\\(\\*(?<name>[A-Za-z_]\\w*)?(?:\\[(?<tag>(?:[A-Za-z_]\\w*)?)\\])?(?:\\{(?<args>[^}]*)\\})?\\)", "")).exec(e);
+	if (!n) throw Error(`Incomplete or invalid named callout "${e}"`);
+	let { name: r, tag: i, args: a } = n.groups;
+	if (!r) throw Error(`Invalid named callout "${e}"`);
+	if (i === "") throw Error(`Named callout tag with empty value not allowed "${e}"`);
+	let o = a ? a.split(",").filter((e) => e !== "").map((e) => /^[+-]?\d+$/.test(e) ? +e : e) : [], [s, c, l] = o, u = Ce.has(r) ? r.toLowerCase() : "custom";
+	switch (u) {
+		case "fail":
+		case "mismatch":
+		case "skip":
+			if (o.length > 0) throw Error(`Named callout arguments not allowed "${o}"`);
+			break;
+		case "error":
+			if (o.length > 1) throw Error(`Named callout allows only one argument "${o}"`);
+			if (typeof s == "string") throw Error(`Named callout argument must be a number "${s}"`);
+			break;
+		case "max":
+			if (!o.length || o.length > 2) throw Error(`Named callout must have one or two arguments "${o}"`);
+			if (typeof s == "string" && !/^[A-Za-z_]\w*$/.test(s)) throw Error(`Named callout argument one must be a tag or number "${s}"`);
+			if (o.length === 2 && (typeof c == "number" || !/^[<>X]$/.test(c))) throw Error(`Named callout optional argument two must be '<', '>', or 'X' "${c}"`);
+			break;
+		case "count":
+		case "total_count":
+			if (o.length > 1) throw Error(`Named callout allows only one argument "${o}"`);
+			if (o.length === 1 && (typeof s == "number" || !/^[<>X]$/.test(s))) throw Error(`Named callout optional argument must be '<', '>', or 'X' "${s}"`);
+			break;
+		case "cmp":
+			if (o.length !== 3) throw Error(`Named callout must have three arguments "${o}"`);
+			if (typeof s == "string" && !/^[A-Za-z_]\w*$/.test(s)) throw Error(`Named callout argument one must be a tag or number "${s}"`);
+			if (typeof c == "number" || !/^(?:[<>!=]=|[<>])$/.test(c)) throw Error(`Named callout argument two must be '==', '!=', '>', '<', '>=', or '<=' "${c}"`);
+			if (typeof l == "string" && !/^[A-Za-z_]\w*$/.test(l)) throw Error(`Named callout argument three must be a tag or number "${l}"`);
+			break;
+		case "custom": throw Error(`Undefined callout name "${r}"`);
+		default: throw Error(`Unexpected named callout kind "${u}"`);
+	}
+	return be(u, i == null ? null : i, (t = a == null ? void 0 : a.split(",")) == null ? null : t, e);
+}
+function Oe(e) {
+	let t = null, n, r;
+	if (e[0] === "{") {
+		let { minStr: i, maxStr: a } = (/* @__PURE__ */ RegExp("^\\{(?<minStr>\\d*)(?:,(?<maxStr>\\d*))?", "")).exec(e).groups, o = 1e5;
+		if (+i > o || a && +a > o) throw Error("Quantifier value unsupported in Oniguruma");
+		if (n = +i, r = a === void 0 ? +i : a === "" ? Infinity : +a, n > r && (t = "possessive", [n, r] = [r, n]), e.endsWith("?")) {
+			if (t === "possessive") throw Error("Unsupported possessive interval quantifier chain with \"?\"");
+			t = "lazy";
+		} else t || (t = "greedy");
+	} else n = e[0] === "+" ? 1 : 0, r = e[0] === "?" ? 1 : Infinity, t = e[1] === "+" ? "possessive" : e[1] === "?" ? "lazy" : "greedy";
+	return xe(t, n, r, e);
+}
+function ke(e) {
+	let t = e[1].toLowerCase();
+	return x({
+		d: "digit",
+		h: "hex",
+		s: "space",
+		w: "word"
+	}[t], e, { negate: e[1] !== t });
+}
+function Ae(e) {
+	let { p: t, neg: n, value: r } = (/* @__PURE__ */ RegExp("^\\\\(?<p>[pP])\\{(?<neg>\\^?)(?<value>[^}]+)", "")).exec(e).groups;
+	return x("property", e, {
+		value: r,
+		negate: t === "P" && !n || t === "p" && !!n
+	});
+}
+function je(e) {
+	let t = {};
+	return e.includes("i") && (t.ignoreCase = !0), e.includes("m") && (t.dotAll = !0), e.includes("x") && (t.extended = !0), Object.keys(t).length ? t : null;
+}
+function Me(e) {
+	let t = {
+		ignoreCase: !1,
+		dotAll: !1,
+		extended: !1,
+		digitIsAscii: !1,
+		posixIsAscii: !1,
+		spaceIsAscii: !1,
+		wordIsAscii: !1,
+		textSegmentMode: null
+	};
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (!"imxDPSWy".includes(r)) throw Error(`Invalid flag "${r}"`);
+		if (r === "y") {
+			if (!/^y{[gw]}/.test(e.slice(n))) throw Error("Invalid or unspecified flag \"y\" mode");
+			t.textSegmentMode = e[n + 2] === "g" ? "grapheme" : "word", n += 3;
+			continue;
+		}
+		t[{
+			i: "ignoreCase",
+			m: "dotAll",
+			x: "extended",
+			D: "digitIsAscii",
+			P: "posixIsAscii",
+			S: "spaceIsAscii",
+			W: "wordIsAscii"
+		}[r]] = !0;
+	}
+	return t;
+}
+function Ne(e) {
+	if ((/* @__PURE__ */ RegExp("^(?:\\\\u(?!\\p{AHex}{4})|\\\\x(?!\\p{AHex}{1,2}|\\{\\p{AHex}{1,8}\\}))", "u")).test(e)) throw Error(`Incomplete or invalid escape "${e}"`);
+	let t = e[2] === "{" ? (/* @__PURE__ */ RegExp("^\\\\x\\{\\s*(?<hex>\\p{AHex}+)", "u")).exec(e).groups.hex : e.slice(2);
+	return parseInt(t, 16);
+}
+function Pe(e, t) {
+	let { raw: n, inCharClass: r } = e, i = n.slice(1);
+	if (!r && (i !== "0" && i.length === 1 || i[0] !== "0" && +i <= t)) return [fe(n)];
+	let a = [], o = i.match(/^[0-7]+|\d/g);
+	for (let e = 0; e < o.length; e++) {
+		let t = o[e], r;
+		if (e === 0 && t !== "8" && t !== "9") {
+			if (r = parseInt(t, 8), r > 127) throw Error(v`Octal encoded byte above 177 unsupported "${n}"`);
+		} else r = h(t);
+		a.push(b(r, (e === 0 ? "\\" : "") + t));
+	}
+	return a;
+}
+function Fe(e) {
+	let t = [], n = new RegExp(ne, "gy"), r;
+	for (; r = n.exec(e);) {
+		let e = r[0];
+		if (e[0] === "{") {
+			let r = (/* @__PURE__ */ RegExp("^\\{(?<min>\\d+),(?<max>\\d+)\\}\\??$", "")).exec(e);
+			if (r) {
+				let { min: i, max: a } = r.groups;
+				if (+i > +a && e.endsWith("?")) {
+					n.lastIndex--, t.push(Oe(e.slice(0, -1)));
+					continue;
+				}
+			}
+		}
+		t.push(Oe(e));
+	}
+	return t;
+}
+//#endregion
+//#region node_modules/oniguruma-parser/dist/parser/node-utils.js
+function Ie(e, t) {
+	if (!Array.isArray(e.body)) throw Error("Expected node with body array");
+	if (e.body.length !== 1) return !1;
+	let n = e.body[0];
+	return !t || Object.keys(t).every((e) => t[e] === n[e]);
+}
+function Le(e) {
+	return Re.has(e.type);
+}
+var Re = new Set([
+	"AbsenceFunction",
+	"Backreference",
+	"CapturingGroup",
+	"Character",
+	"CharacterClass",
+	"CharacterSet",
+	"Group",
+	"Quantifier",
+	"Subroutine"
+]);
+//#endregion
+//#region node_modules/oniguruma-parser/dist/parser/parse.js
+function ze(e, n = {}) {
+	let r = t(t({
+		flags: "",
+		normalizeUnknownPropertyNames: !1,
+		skipBackrefValidation: !1,
+		skipLookbehindValidation: !1,
+		skipPropertyNameValidation: !1,
+		unicodePropertyMap: null
+	}, n), {}, { rules: t({
+		captureGroup: !1,
+		singleline: !1
+	}, n.rules) }), i = ae(e, {
+		flags: r.flags,
+		rules: {
+			captureGroup: r.rules.captureGroup,
+			singleline: r.rules.singleline
+		}
+	}), a = (e, t) => {
+		let n = i.tokens[o.nextIndex];
+		switch (o.parent = e, o.nextIndex++, n.type) {
+			case "Alternator": return C();
+			case "Assertion": return Be(n);
+			case "Backreference": return Ve(n, o);
+			case "Character": return w(n.value, { useLastValid: !!t.isCheckingRangeEnd });
+			case "CharacterClassHyphen": return He(n, o, t);
+			case "CharacterClassOpen": return Ue(n, o, t);
+			case "CharacterSet": return We(n, o);
+			case "Directive": return et(n.kind, { flags: n.flags });
+			case "GroupOpen": return Ge(n, o, t);
+			case "NamedCallout": return nt(n.kind, n.tag, n.arguments);
+			case "Quantifier": return Ke(n, o);
+			case "Subroutine": return qe(n, o);
+			default: throw Error(`Unexpected token type "${n.type}"`);
+		}
+	}, o = {
+		capturingGroups: [],
+		hasNumberedRef: !1,
+		namedGroupsByName: /* @__PURE__ */ new Map(),
+		nextIndex: 0,
+		normalizeUnknownPropertyNames: r.normalizeUnknownPropertyNames,
+		parent: null,
+		skipBackrefValidation: r.skipBackrefValidation,
+		skipLookbehindValidation: r.skipLookbehindValidation,
+		skipPropertyNameValidation: r.skipPropertyNameValidation,
+		subroutines: [],
+		tokens: i.tokens,
+		unicodePropertyMap: r.unicodePropertyMap,
+		walk: a
+	}, s = at(tt(i.flags)), c = s.body[0];
+	for (; o.nextIndex < i.tokens.length;) {
+		let e = a(c, {});
+		e.type === "Alternative" ? (s.body.push(e), c = e) : c.body.push(e);
+	}
+	let { capturingGroups: l, hasNumberedRef: u, namedGroupsByName: d, subroutines: f } = o;
+	if (u && d.size && !r.rules.captureGroup) throw Error("Numbered backref/subroutine not allowed when using named capture");
+	for (let { ref: e } of f) if (typeof e == "number") {
+		if (e > l.length) throw Error("Subroutine uses a group number that's not defined");
+		e && (l[e - 1].isSubroutined = !0);
+	} else if (d.has(e)) {
+		if (d.get(e).length > 1) throw Error(v`Subroutine uses a duplicate group name "\g<${e}>"`);
+		d.get(e)[0].isSubroutined = !0;
+	} else throw Error(v`Subroutine uses a group name that's not defined "\g<${e}>"`);
+	return s;
+}
+function Be({ kind: e }) {
+	return Ye(y({
+		"^": "line_start",
+		$: "line_end",
+		"\\A": "string_start",
+		"\\b": "word_boundary",
+		"\\B": "word_boundary",
+		"\\G": "search_start",
+		"\\y": "text_segment_boundary",
+		"\\Y": "text_segment_boundary",
+		"\\z": "string_end",
+		"\\Z": "string_end_newline"
+	}[e], `Unexpected assertion kind "${e}"`), { negate: e === v`\B` || e === v`\Y` });
+}
+function Ve({ raw: e }, t) {
+	let n = /^\\k[<']/.test(e), r = n ? e.slice(3, -1) : e.slice(1), i = (n, r = !1) => {
+		let i = t.capturingGroups.length, a = !1;
+		if (n > i) if (t.skipBackrefValidation) a = !0;
+		else throw Error(`Not enough capturing groups defined to the left "${e}"`);
+		return t.hasNumberedRef = !0, Xe(r ? i + 1 - n : n, { orphan: a });
+	};
+	if (n) {
+		let n = (/* @__PURE__ */ RegExp("^(?<sign>-?)0*(?<num>[1-9]\\d*)$", "")).exec(r);
+		if (n) return i(+n.groups.num, !!n.groups.sign);
+		if (/[-+]/.test(r)) throw Error(`Invalid backref name "${e}"`);
+		if (!t.namedGroupsByName.has(r)) throw Error(`Group name not defined to the left "${e}"`);
+		return Xe(r);
+	}
+	return i(+r);
+}
+function He(e, n, r) {
+	let { tokens: i, walk: a } = n, o = n.parent, s = o.body.at(-1), c = i[n.nextIndex];
+	if (!r.isCheckingRangeEnd && s && s.type !== "CharacterClass" && s.type !== "CharacterClassRange" && c && c.type !== "CharacterClassOpen" && c.type !== "CharacterClassClose" && c.type !== "CharacterClassIntersector") {
+		let e = a(o, t(t({}, r), {}, { isCheckingRangeEnd: !0 }));
+		if (s.type === "Character" && e.type === "Character") return o.body.pop(), Qe(s, e);
+		throw Error("Invalid character class range");
+	}
+	return w(h("-"));
+}
+function Ue({ negate: e }, t, n) {
+	let { tokens: r, walk: i } = t, a = r[t.nextIndex], o = [T()], s = pt(a);
+	for (; s.type !== "CharacterClassClose";) {
+		if (s.type === "CharacterClassIntersector") o.push(T()), t.nextIndex++;
+		else {
+			let e = o.at(-1);
+			e.body.push(i(e, n));
+		}
+		s = pt(r[t.nextIndex], a);
+	}
+	let c = T({ negate: e });
+	return o.length === 1 ? c.body = o[0].body : (c.kind = "intersection", c.body = o.map((e) => e.body.length === 1 ? e.body[0] : e)), t.nextIndex++, c;
+}
+function We({ kind: e, negate: t, value: n }, r) {
+	let { normalizeUnknownPropertyNames: i, skipPropertyNameValidation: a, unicodePropertyMap: o } = r;
+	if (e === "property") {
+		let r = A(n);
+		if (_.has(r) && !(o != null && o.has(r))) e = "posix", n = r;
+		else return O(n, {
+			negate: t,
+			normalizeUnknownPropertyNames: i,
+			skipPropertyNameValidation: a,
+			unicodePropertyMap: o
+		});
+	}
+	return e === "posix" ? rt(n, { negate: t }) : $e(e, { negate: t });
+}
+function Ge(e, n, r) {
+	let { tokens: i, capturingGroups: a, namedGroupsByName: o, skipLookbehindValidation: s, walk: c } = n, l = st(e), u = l.type === "AbsenceFunction", d = ut(l), f = d && l.negate;
+	if (l.type === "CapturingGroup" && (a.push(l), l.name && g(o, l.name, []).push(l)), u && r.isInAbsenceFunction) throw Error("Nested absence function not supported by Oniguruma");
+	let p = mt(i[n.nextIndex]);
+	for (; p.type !== "GroupClose";) {
+		if (p.type === "Alternator") l.body.push(C()), n.nextIndex++;
+		else {
+			let e = l.body.at(-1), n = c(e, t(t({}, r), {}, {
+				isInAbsenceFunction: r.isInAbsenceFunction || u,
+				isInLookbehind: r.isInLookbehind || d,
+				isInNegLookbehind: r.isInNegLookbehind || f
+			}));
+			if (e.body.push(n), (d || r.isInLookbehind) && !s) {
+				let e = "Lookbehind includes a pattern not allowed by Oniguruma";
+				if (f || r.isInNegLookbehind) {
+					if (lt(n) || n.type === "CapturingGroup") throw Error(e);
+				} else if (lt(n) || ut(n) && n.negate) throw Error(e);
+			}
+		}
+		p = mt(i[n.nextIndex]);
+	}
+	return n.nextIndex++, l;
+}
+function Ke({ kind: e, min: t, max: n }, r) {
+	let i = r.parent, a = i.body.at(-1);
+	if (!a || !Le(a)) throw Error("Quantifier requires a repeatable token");
+	let o = it(e, t, n, a);
+	return i.body.pop(), o;
+}
+function qe({ raw: e }, t) {
+	let { capturingGroups: n, subroutines: r } = t, i = e.slice(3, -1), a = (/* @__PURE__ */ RegExp("^(?<sign>[-+]?)0*(?<num>[1-9]\\d*)$", "")).exec(i);
+	if (a) {
+		let e = +a.groups.num, r = n.length;
+		if (t.hasNumberedRef = !0, i = {
+			"": e,
+			"+": r + e,
+			"-": r + 1 - e
+		}[a.groups.sign], i < 1) throw Error("Invalid subroutine number");
+	} else i === "0" && (i = 0);
+	let o = ot(i);
+	return r.push(o), o;
+}
+function Je(e, t) {
+	if (e !== "repeater") throw Error(`Unexpected absence function kind "${e}"`);
+	return {
+		type: "AbsenceFunction",
+		kind: e,
+		body: k(t == null ? void 0 : t.body)
+	};
+}
+function C(e) {
+	return {
+		type: "Alternative",
+		body: ct(e == null ? void 0 : e.body)
+	};
+}
+function Ye(e, t) {
+	let n = {
+		type: "Assertion",
+		kind: e
+	};
+	return (e === "word_boundary" || e === "text_segment_boundary") && (n.negate = !!(t != null && t.negate)), n;
+}
+function Xe(e, n) {
+	let r = !!(n != null && n.orphan);
+	return t({
+		type: "Backreference",
+		ref: e
+	}, r && { orphan: r });
+}
+function Ze(e, n) {
+	let r = t({
+		name: void 0,
+		isSubroutined: !1
+	}, n);
+	if (r.name !== void 0 && !dt(r.name)) throw Error(`Group name "${r.name}" invalid in Oniguruma`);
+	return t(t(t({
+		type: "CapturingGroup",
+		number: e
+	}, r.name && { name: r.name }), r.isSubroutined && { isSubroutined: r.isSubroutined }), {}, { body: k(n == null ? void 0 : n.body) });
+}
+function w(e, n) {
+	let r = t({ useLastValid: !1 }, n);
+	if (e > 1114111) {
+		let t = e.toString(16);
+		if (r.useLastValid) e = 1114111;
+		else throw e > 1310719 ? /* @__PURE__ */ Error(`Invalid code point out of range "\\x{${t}}"`) : /* @__PURE__ */ Error(`Invalid code point out of range in JS "\\x{${t}}"`);
+	}
+	return {
+		type: "Character",
+		value: e
+	};
+}
+function T(e) {
+	let n = t({
+		kind: "union",
+		negate: !1
+	}, e);
+	return {
+		type: "CharacterClass",
+		kind: n.kind,
+		negate: n.negate,
+		body: ct(e == null ? void 0 : e.body)
+	};
+}
+function Qe(e, t) {
+	if (t.value < e.value) throw Error("Character class range out of order");
+	return {
+		type: "CharacterClassRange",
+		min: e,
+		max: t
+	};
+}
+function $e(e, t) {
+	let n = !!(t != null && t.negate), r = {
+		type: "CharacterSet",
+		kind: e
+	};
+	return (e === "digit" || e === "hex" || e === "newline" || e === "space" || e === "word") && (r.negate = n), (e === "text_segment" || e === "newline" && !n) && (r.variableLength = !0), r;
+}
+function et(e, t = {}) {
+	if (e === "keep") return {
+		type: "Directive",
+		kind: e
+	};
+	if (e === "flags") return {
+		type: "Directive",
+		kind: e,
+		flags: y(t.flags)
+	};
+	throw Error(`Unexpected directive kind "${e}"`);
+}
+function tt(e) {
+	return t({ type: "Flags" }, e);
+}
+function E(e) {
+	let n = e == null ? void 0 : e.atomic, r = e == null ? void 0 : e.flags;
+	if (n && r) throw Error("Atomic group cannot have flags");
+	return t(t(t({ type: "Group" }, n && { atomic: n }), r && { flags: r }), {}, { body: k(e == null ? void 0 : e.body) });
+}
+function D(e) {
+	let n = t({
+		behind: !1,
+		negate: !1
+	}, e);
+	return {
+		type: "LookaroundAssertion",
+		kind: n.behind ? "lookbehind" : "lookahead",
+		negate: n.negate,
+		body: k(e == null ? void 0 : e.body)
+	};
+}
+function nt(e, t, n) {
+	return {
+		type: "NamedCallout",
+		kind: e,
+		tag: t,
+		arguments: n
+	};
+}
+function rt(e, t) {
+	let n = !!(t != null && t.negate);
+	if (!_.has(e)) throw Error(`Invalid POSIX class "${e}"`);
+	return {
+		type: "CharacterSet",
+		kind: "posix",
+		value: e,
+		negate: n
+	};
+}
+function it(e, t, n, r) {
+	if (t > n) throw Error("Invalid reversed quantifier range");
+	return {
+		type: "Quantifier",
+		kind: e,
+		min: t,
+		max: n,
+		body: r
+	};
+}
+function at(e, t) {
+	return {
+		type: "Regex",
+		body: k(t == null ? void 0 : t.body),
+		flags: e
+	};
+}
+function ot(e) {
+	return {
+		type: "Subroutine",
+		ref: e
+	};
+}
+function O(e, n) {
+	var r, i;
+	let a = t({
+		negate: !1,
+		normalizeUnknownPropertyNames: !1,
+		skipPropertyNameValidation: !1,
+		unicodePropertyMap: null
+	}, n), o = (r = a.unicodePropertyMap) == null ? void 0 : r.get(A(e));
+	if (!o) {
+		if (a.normalizeUnknownPropertyNames) o = ft(e);
+		else if (a.unicodePropertyMap && !a.skipPropertyNameValidation) throw Error(v`Invalid Unicode property "\p{${e}}"`);
+	}
+	return {
+		type: "CharacterSet",
+		kind: "property",
+		value: (i = o) == null ? e : i,
+		negate: a.negate
+	};
+}
+function st({ flags: e, kind: t, name: n, negate: r, number: i }) {
+	switch (t) {
+		case "absence_repeater": return Je("repeater");
+		case "atomic": return E({ atomic: !0 });
+		case "capturing": return Ze(i, { name: n });
+		case "group": return E({ flags: e });
+		case "lookahead":
+		case "lookbehind": return D({
+			behind: t === "lookbehind",
+			negate: r
+		});
+		default: throw Error(`Unexpected group kind "${t}"`);
+	}
+}
+function k(e) {
+	if (e === void 0) e = [C()];
+	else if (!Array.isArray(e) || !e.length || !e.every((e) => e.type === "Alternative")) throw Error("Invalid body; expected array of one or more Alternative nodes");
+	return e;
+}
+function ct(e) {
+	if (e === void 0) e = [];
+	else if (!Array.isArray(e) || !e.every((e) => !!e.type)) throw Error("Invalid body; expected array of nodes");
+	return e;
+}
+function lt(e) {
+	return e.type === "LookaroundAssertion" && e.kind === "lookahead";
+}
+function ut(e) {
+	return e.type === "LookaroundAssertion" && e.kind === "lookbehind";
+}
+function dt(e) {
+	return (/* @__PURE__ */ RegExp("^[\\p{Alpha}\\p{Pc}][^)]*$", "u")).test(e);
+}
+function ft(e) {
+	return e.trim().replace(/[- _]+/g, "_").replace(/[A-Z][a-z]+(?=[A-Z])/g, "$&_").replace(/[A-Za-z]+/g, (e) => e[0].toUpperCase() + e.slice(1).toLowerCase());
+}
+function A(e) {
+	return e.replace(/[- _]+/g, "").toLowerCase();
+}
+function pt(e, t) {
+	return y(e, `${(t == null ? void 0 : t.type) === "Character" && t.value === 93 ? "Empty" : "Unclosed"} character class`);
+}
+function mt(e) {
+	return y(e, "Unclosed group");
+}
+//#endregion
+//#region node_modules/oniguruma-parser/dist/traverser/traverse.js
+function j(e, t, n = null) {
+	function r(e, t) {
+		for (let n = 0; n < e.length; n++) {
+			let r = i(e[n], t, n, e);
+			n = Math.max(-1, n + r);
+		}
+	}
+	function i(a, o = null, s = null, c = null) {
+		var l, u;
+		let d = 0, f = !1, p = {
+			node: a,
+			parent: o,
+			key: s,
+			container: c,
+			root: e,
+			remove() {
+				M(c).splice(Math.max(0, N(s) + d), 1), d--, f = !0;
+			},
+			removeAllNextSiblings() {
+				return M(c).splice(N(s) + 1);
+			},
+			removeAllPrevSiblings() {
+				let e = N(s) + d;
+				return d -= e, M(c).splice(0, Math.max(0, e));
+			},
+			replaceWith(e, t = {}) {
+				let n = !!t.traverse;
+				c ? c[Math.max(0, N(s) + d)] = e : y(o, "Can't replace root node")[s] = e, n && i(e, o, s, c), f = !0;
+			},
+			replaceWithMultiple(e, t = {}) {
+				let n = !!t.traverse;
+				if (M(c).splice(Math.max(0, N(s) + d), 1, ...e), d += e.length - 1, n) {
+					let t = 0;
+					for (let n = 0; n < e.length; n++) t += i(e[n], o, N(s) + n + t, c);
+				}
+				f = !0;
+			},
+			skip() {
+				f = !0;
+			}
+		}, { type: m } = a, h = t["*"], g = t[m], _ = typeof h == "function" ? h : h == null ? void 0 : h.enter, v = typeof g == "function" ? g : g == null ? void 0 : g.enter;
+		if (_ == null || _(p, n), v == null || v(p, n), !f) switch (m) {
+			case "AbsenceFunction":
+			case "CapturingGroup":
+			case "Group":
+				r(a.body, a);
+				break;
+			case "Alternative":
+			case "CharacterClass":
+				r(a.body, a);
+				break;
+			case "Assertion":
+			case "Backreference":
+			case "Character":
+			case "CharacterSet":
+			case "Directive":
+			case "Flags":
+			case "NamedCallout":
+			case "Subroutine": break;
+			case "CharacterClassRange":
+				i(a.min, a, "min"), i(a.max, a, "max");
+				break;
+			case "LookaroundAssertion":
+				r(a.body, a);
+				break;
+			case "Quantifier":
+				i(a.body, a, "body");
+				break;
+			case "Regex":
+				r(a.body, a), i(a.flags, a, "flags");
+				break;
+			default: throw Error(`Unexpected node type "${m}"`);
+		}
+		return g == null || (l = g.exit) == null || l.call(g, p, n), h == null || (u = h.exit) == null || u.call(h, p, n), d;
+	}
+	return i(e), e;
+}
+function M(e) {
+	if (!Array.isArray(e)) throw Error("Container expected");
+	return e;
+}
+function N(e) {
+	if (typeof e != "number") throw Error("Numeric key expected");
+	return e;
+}
+//#endregion
+//#region node_modules/regex/src/utils-internals.js
+var ht = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
+function gt(e, t) {
+	for (let n = 0; n < e.length; n++) e[n] >= t && e[n]++;
+}
+function _t(e, t, n, r) {
+	return e.slice(0, t) + r + e.slice(t + n.length);
+}
+//#endregion
+//#region node_modules/regex-utilities/src/index.js
+var P = Object.freeze({
+	DEFAULT: "DEFAULT",
+	CHAR_CLASS: "CHAR_CLASS"
+});
+function vt(e, t, n, r) {
+	let i = new RegExp(String.raw`${t}|(?<$skip>\[\^?|\\?.)`, "gsu"), a = [!1], o = 0, s = "";
+	for (let t of e.matchAll(i)) {
+		let { 0: e, groups: { $skip: i } } = t;
+		if (!i && (!r || r === P.DEFAULT == !o)) {
+			n instanceof Function ? s += n(t, {
+				context: o ? P.CHAR_CLASS : P.DEFAULT,
+				negated: a[a.length - 1]
+			}) : s += n;
+			continue;
+		}
+		e[0] === "[" ? (o++, a.push(e[1] === "^")) : e === "]" && o && (o--, a.pop()), s += e;
+	}
+	return s;
+}
+function yt(e, t, n, r) {
+	vt(e, t, n, r);
+}
+function bt(e, t, n = 0, r) {
+	if (!new RegExp(t, "su").test(e)) return null;
+	let i = RegExp(`${t}|(?<$skip>\\\\?.)`, "gsu");
+	i.lastIndex = n;
+	let a = 0, o;
+	for (; o = i.exec(e);) {
+		let { 0: e, groups: { $skip: t } } = o;
+		if (!t && (!r || r === P.DEFAULT == !a)) return o;
+		e === "[" ? a++ : e === "]" && a && a--, i.lastIndex == o.index && i.lastIndex++;
+	}
+	return null;
+}
+function F(e, t, n) {
+	return !!bt(e, t, 0, n);
+}
+function xt(e, t) {
+	let n = /* @__PURE__ */ RegExp("\\\\?.", "gsu");
+	n.lastIndex = t;
+	let r = e.length, i = 0, a = 1, o;
+	for (; o = n.exec(e);) {
+		let [e] = o;
+		if (e === "[") i++;
+		else if (i) e === "]" && i--;
+		else if (e === "(") a++;
+		else if (e === ")" && (a--, !a)) {
+			r = o.index;
+			break;
+		}
+	}
+	return e.slice(t, r);
+}
+//#endregion
+//#region node_modules/regex/src/atomic.js
+var St = new RegExp(String.raw`(?<noncapturingStart>${ht})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, "gsu");
+function Ct(e, t) {
+	var n, r;
+	let i = (n = t == null ? void 0 : t.hiddenCaptures) == null ? [] : n, a = (r = t == null ? void 0 : t.captureTransfers) == null ? /* @__PURE__ */ new Map() : r;
+	if (!/\(\?>/.test(e)) return {
+		pattern: e,
+		captureTransfers: a,
+		hiddenCaptures: i
+	};
+	let o = [0], s = [], c = 0, l = 0, u = NaN, d;
+	do {
+		d = !1;
+		let t = 0, n = 0, r = !1, f;
+		for (St.lastIndex = Number.isNaN(u) ? 0 : u + 7; f = St.exec(e);) {
+			let { 0: p, index: m, groups: { capturingStart: h, noncapturingStart: g } } = f;
+			if (p === "[") t++;
+			else if (t) p === "]" && t--;
+			else if (p === "(?>" && !r) u = m, r = !0;
+			else if (r && g) n++;
+			else if (h) r ? n++ : (c++, o.push(c + l));
+			else if (p === ")" && r) {
+				if (!n) {
+					l++;
+					let t = c + l;
+					if (e = `${e.slice(0, u)}(?:(?=(${e.slice(u + 3, m)}))<$$${t}>)${e.slice(m + 1)}`, d = !0, s.push(t), gt(i, t), a.size) {
+						let e = /* @__PURE__ */ new Map();
+						a.forEach((n, r) => {
+							e.set(r >= t ? r + 1 : r, n.map((e) => e >= t ? e + 1 : e));
+						}), a = e;
+					}
+					break;
+				}
+				n--;
+			}
+		}
+	} while (d);
+	return i.push(...s), e = vt(e, String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`, ({ 0: e, groups: { backrefNum: t, wrappedBackrefNum: n } }) => {
+		if (t) {
+			let n = +t;
+			if (n > o.length - 1) throw Error(`Backref "${e}" greater than number of captures`);
+			return `\\${o[n]}`;
+		}
+		return `\\${n}`;
+	}, P.DEFAULT), {
+		pattern: e,
+		captureTransfers: a,
+		hiddenCaptures: i
+	};
+}
+var wt = String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`, Tt = new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${wt})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g, ""), "gsu");
+function Et(e) {
+	if (!RegExp(`${wt}\\+`).test(e)) return { pattern: e };
+	let t = [], n = null, r = null, i = "", a = 0, o;
+	for (Tt.lastIndex = 0; o = Tt.exec(e);) {
+		let { 0: s, index: c, groups: { qBase: l, qMod: u, invalidQ: d } } = o;
+		if (s === "[") a || (r = c), a++;
+		else if (s === "]") a ? a-- : r = null;
+		else if (!a) if (u === "+" && i && !i.startsWith("(")) {
+			if (d) throw Error(`Invalid quantifier "${s}"`);
+			let t = -1;
+			if (/^\{\d+\}$/.test(l)) e = _t(e, c + l.length, u, "");
+			else {
+				if (i === ")" || i === "]") {
+					let t = i === ")" ? n : r;
+					if (t === null) throw Error(`Invalid unmatched "${i}"`);
+					e = `${e.slice(0, t)}(?>${e.slice(t, c)}${l})${e.slice(c + s.length)}`;
+				} else e = `${e.slice(0, c - i.length)}(?>${i}${l})${e.slice(c + s.length)}`;
+				t += 4;
+			}
+			Tt.lastIndex += t;
+		} else s[0] === "(" ? t.push(c) : s === ")" && (n = t.length ? t.pop() : null);
+		i = s;
+	}
+	return { pattern: e };
+}
+//#endregion
+//#region node_modules/regex-recursion/src/index.js
+var I = String.raw, Dt = I`\(\?R=(?<rDepth>[^\)]+)\)|${I`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`}`, L = I`\(\?<(?![=!])(?<captureName>[^>]+)>`, Ot = I`${L}|(?<unnamed>\()(?!\?)`, R = new RegExp(I`${L}|${Dt}|\(\?|\\?.`, "gsu"), kt = "Cannot use multiple overlapping recursions";
+function At(e, n) {
+	var r;
+	let { hiddenCaptures: i, mode: a } = t({
+		hiddenCaptures: [],
+		mode: "plugin"
+	}, n), o = (r = n == null ? void 0 : n.captureTransfers) == null ? /* @__PURE__ */ new Map() : r;
+	if (!new RegExp(Dt, "su").test(e)) return {
+		pattern: e,
+		captureTransfers: o,
+		hiddenCaptures: i
+	};
+	if (a === "plugin" && F(e, I`\(\?\(DEFINE\)`, P.DEFAULT)) throw Error("DEFINE groups cannot be used with recursion");
+	let s = [], c = F(e, I`\\[1-9]`, P.DEFAULT), l = /* @__PURE__ */ new Map(), u = [], d = !1, f = 0, p = 0, m;
+	for (R.lastIndex = 0; m = R.exec(e);) {
+		let { 0: t, groups: { captureName: n, rDepth: r, gRNameOrNum: h, gRDepth: g } } = m;
+		if (t === "[") f++;
+		else if (f) t === "]" && f--;
+		else if (r) {
+			if (jt(r), d) throw Error(kt);
+			if (c) throw Error(`${a === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with global recursion`);
+			let t = e.slice(0, m.index), n = e.slice(R.lastIndex);
+			if (F(n, Dt, P.DEFAULT)) throw Error(kt);
+			let l = r - 1;
+			e = Mt(t, n, l, !1, i, s, p), o = Ft(o, t, l, s.length, 0, p);
+			break;
+		} else if (h) {
+			jt(g);
+			let n = !1;
+			for (let e of u) if (e.name === h || e.num === +h) {
+				if (n = !0, e.hasRecursedWithin) throw Error(kt);
+				break;
+			}
+			if (!n) throw Error(I`Recursive \g cannot be used outside the referenced group "${a === "external" ? h : I`\g<${h}&R=${g}>`}"`);
+			let r = l.get(h), f = xt(e, r);
+			if (c && F(f, I`${L}|\((?!\?)`, P.DEFAULT)) throw Error(`${a === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with recursion of capturing groups`);
+			let _ = e.slice(r, m.index), v = f.slice(_.length + t.length), y = s.length, ee = g - 1, te = Mt(_, v, ee, !0, i, s, p);
+			o = Ft(o, _, ee, s.length - y, y, p), e = `${e.slice(0, r)}${te}${e.slice(r + f.length)}`, R.lastIndex += te.length - t.length - _.length - v.length, u.forEach((e) => e.hasRecursedWithin = !0), d = !0;
+		} else if (n) p++, l.set(String(p), R.lastIndex), l.set(n, R.lastIndex), u.push({
+			num: p,
+			name: n
+		});
+		else if (t[0] === "(") {
+			let e = t === "(";
+			e && (p++, l.set(String(p), R.lastIndex)), u.push(e ? { num: p } : {});
+		} else t === ")" && u.pop();
+	}
+	return i.push(...s), {
+		pattern: e,
+		captureTransfers: o,
+		hiddenCaptures: i
+	};
+}
+function jt(e) {
+	let t = `Max depth must be integer between 2 and 100; used ${e}`;
+	if (!/^[1-9]\d*$/.test(e) || (e = +e, e < 2 || e > 100)) throw Error(t);
+}
+function Mt(e, t, n, r, i, a, o) {
+	let s = /* @__PURE__ */ new Set();
+	r && yt(e + t, L, ({ groups: { captureName: e } }) => {
+		s.add(e);
+	}, P.DEFAULT);
+	let c = [
+		n,
+		r ? s : null,
+		i,
+		a,
+		o
+	];
+	return `${e}${Nt(`(?:${e}`, "forward", ...c)}(?:)${Nt(`${t})`, "backward", ...c)}${t}`;
+}
+function Nt(e, t, n, r, i, a, o) {
+	let s = (e) => t === "forward" ? e + 2 : n - e + 2 - 1, c = "";
+	for (let t = 0; t < n; t++) {
+		let n = s(t);
+		c += vt(e, I`${Ot}|\\k<(?<backref>[^>]+)>`, ({ 0: e, groups: { captureName: t, unnamed: s, backref: c } }) => {
+			if (c && r && !r.has(c)) return e;
+			let l = `_$${n}`;
+			if (s || t) {
+				let n = o + a.length + 1;
+				return a.push(n), Pt(i, n), s ? e : `(?<${t}${l}>`;
+			}
+			return I`\k<${c}${l}>`;
+		}, P.DEFAULT);
+	}
+	return c;
+}
+function Pt(e, t) {
+	for (let n = 0; n < e.length; n++) e[n] >= t && e[n]++;
+}
+function Ft(e, t, n, r, i, a) {
+	if (e.size && r) {
+		let o = 0;
+		yt(t, Ot, () => o++, P.DEFAULT);
+		let s = a - o + i, c = /* @__PURE__ */ new Map();
+		return e.forEach((e, t) => {
+			let i = (r - o * n) / n, a = o * n, l = t > s + o ? t + r : t, u = [];
+			for (let t of e) if (t <= s) u.push(t);
+			else if (t > s + o + i) u.push(t + r);
+			else if (t <= s + o) for (let e = 0; e <= n; e++) u.push(t + o * e);
+			else for (let e = 0; e <= n; e++) u.push(t + a + i * e);
+			c.set(l, u);
+		}), c;
+	}
+	return e;
+}
+//#endregion
+//#region node_modules/oniguruma-to-es/dist/esm/index.js
+var It = ["lazyCompile"], z, B, V, H, U, Lt, Rt, W = String.fromCodePoint, G = String.raw, K = {
+	flagGroups: !0,
+	unicodeSets: !0
+};
+K.bugFlagVLiteralHyphenIsRange = K.unicodeSets ? (() => {
+	try {
+		new RegExp(G`[\d\-a]`, "v");
+	} catch (e) {
+		return !0;
+	}
+	return !1;
+})() : !1, K.bugNestedClassIgnoresNegation = K.unicodeSets && (/* @__PURE__ */ RegExp("[[^a]]", "v")).test("a");
+function zt(e, { enable: t, disable: n }) {
+	return {
+		dotAll: !(n != null && n.dotAll) && !!(t != null && t.dotAll || e.dotAll),
+		ignoreCase: !(n != null && n.ignoreCase) && !!(t != null && t.ignoreCase || e.ignoreCase)
+	};
+}
+function q(e, t, n) {
+	return e.has(t) || e.set(t, n), e.get(t);
+}
+function Bt(e, t) {
+	return Ht[e] >= Ht[t];
+}
+function Vt(e, t) {
+	if (e == null) throw Error(t == null ? "Value expected" : t);
+	return e;
+}
+var Ht = {
+	ES2025: 2025,
+	ES2024: 2024,
+	ES2018: 2018
+}, Ut = {
+	auto: "auto",
+	ES2025: "ES2025",
+	ES2024: "ES2024",
+	ES2018: "ES2018"
+};
+function Wt(e = {}) {
+	if ({}.toString.call(e) !== "[object Object]") throw Error("Unexpected options");
+	if (e.target !== void 0 && !Ut[e.target]) throw Error(`Unexpected target "${e.target}"`);
+	let n = t(t({
+		accuracy: "default",
+		avoidSubclass: !1,
+		flags: "",
+		global: !1,
+		hasIndices: !1,
+		lazyCompileLength: Infinity,
+		target: "auto",
+		verbose: !1
+	}, e), {}, { rules: t({
+		allowOrphanBackrefs: !1,
+		asciiWordBoundaries: !1,
+		captureGroup: !1,
+		recursionLimit: 20,
+		singleline: !1
+	}, e.rules) });
+	return n.target === "auto" && (n.target = K.flagGroups ? "ES2025" : K.unicodeSets ? "ES2024" : "ES2018"), n;
+}
+var Gt = "[	-\r ]", Kt = /* @__PURE__ */ new Set([W(304), W(305)]), J = G`[\p{L}\p{M}\p{N}\p{Pc}]`;
+function qt(e) {
+	if (Kt.has(e)) return [e];
+	let t = /* @__PURE__ */ new Set(), n = e.toLowerCase(), r = n.toUpperCase(), i = Zt.get(n), a = Yt.get(n), o = Xt.get(n);
+	return [...r].length === 1 && t.add(r), o && t.add(o), i && t.add(i), t.add(n), a && t.add(a), [...t];
+}
+var Jt = /* @__PURE__ */ new Map("C Other\nCc Control cntrl\nCf Format\nCn Unassigned\nCo Private_Use\nCs Surrogate\nL Letter\nLC Cased_Letter\nLl Lowercase_Letter\nLm Modifier_Letter\nLo Other_Letter\nLt Titlecase_Letter\nLu Uppercase_Letter\nM Mark Combining_Mark\nMc Spacing_Mark\nMe Enclosing_Mark\nMn Nonspacing_Mark\nN Number\nNd Decimal_Number digit\nNl Letter_Number\nNo Other_Number\nP Punctuation punct\nPc Connector_Punctuation\nPd Dash_Punctuation\nPe Close_Punctuation\nPf Final_Punctuation\nPi Initial_Punctuation\nPo Other_Punctuation\nPs Open_Punctuation\nS Symbol\nSc Currency_Symbol\nSk Modifier_Symbol\nSm Math_Symbol\nSo Other_Symbol\nZ Separator\nZl Line_Separator\nZp Paragraph_Separator\nZs Space_Separator\nASCII\nASCII_Hex_Digit AHex\nAlphabetic Alpha\nAny\nAssigned\nBidi_Control Bidi_C\nBidi_Mirrored Bidi_M\nCase_Ignorable CI\nCased\nChanges_When_Casefolded CWCF\nChanges_When_Casemapped CWCM\nChanges_When_Lowercased CWL\nChanges_When_NFKC_Casefolded CWKCF\nChanges_When_Titlecased CWT\nChanges_When_Uppercased CWU\nDash\nDefault_Ignorable_Code_Point DI\nDeprecated Dep\nDiacritic Dia\nEmoji\nEmoji_Component EComp\nEmoji_Modifier EMod\nEmoji_Modifier_Base EBase\nEmoji_Presentation EPres\nExtended_Pictographic ExtPict\nExtender Ext\nGrapheme_Base Gr_Base\nGrapheme_Extend Gr_Ext\nHex_Digit Hex\nIDS_Binary_Operator IDSB\nIDS_Trinary_Operator IDST\nID_Continue IDC\nID_Start IDS\nIdeographic Ideo\nJoin_Control Join_C\nLogical_Order_Exception LOE\nLowercase Lower\nMath\nNoncharacter_Code_Point NChar\nPattern_Syntax Pat_Syn\nPattern_White_Space Pat_WS\nQuotation_Mark QMark\nRadical\nRegional_Indicator RI\nSentence_Terminal STerm\nSoft_Dotted SD\nTerminal_Punctuation Term\nUnified_Ideograph UIdeo\nUppercase Upper\nVariation_Selector VS\nWhite_Space space\nXID_Continue XIDC\nXID_Start XIDS".split(/\s/).map((e) => [A(e), e])), Yt = /* @__PURE__ */ new Map([["s", W(383)], [W(383), "s"]]), Xt = /* @__PURE__ */ new Map([
+	[W(223), W(7838)],
+	[W(107), W(8490)],
+	[W(229), W(8491)],
+	[W(969), W(8486)]
+]), Zt = new Map([
+	Y(453),
+	Y(456),
+	Y(459),
+	Y(498),
+	...en(8072, 8079),
+	...en(8088, 8095),
+	...en(8104, 8111),
+	Y(8124),
+	Y(8140),
+	Y(8188)
+]), Qt = /* @__PURE__ */ new Map([
+	["alnum", G`[\p{Alpha}\p{Nd}]`],
+	["alpha", G`\p{Alpha}`],
+	["ascii", G`\p{ASCII}`],
+	["blank", G`[\p{Zs}\t]`],
+	["cntrl", G`\p{Cc}`],
+	["digit", G`\p{Nd}`],
+	["graph", G`[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]`],
+	["lower", G`\p{Lower}`],
+	["print", G`[[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]\p{Zs}]`],
+	["punct", G`[\p{P}\p{S}]`],
+	["space", G`\p{space}`],
+	["upper", G`\p{Upper}`],
+	["word", G`[\p{Alpha}\p{M}\p{Nd}\p{Pc}]`],
+	["xdigit", G`\p{AHex}`]
+]);
+function $t(e, t) {
+	let n = [];
+	for (let r = e; r <= t; r++) n.push(r);
+	return n;
+}
+function Y(e) {
+	let t = W(e);
+	return [t.toLowerCase(), t];
+}
+function en(e, t) {
+	return $t(e, t).map((e) => Y(e));
+}
+var tn = /* @__PURE__ */ new Set([
+	"Lower",
+	"Lowercase",
+	"Upper",
+	"Uppercase",
+	"Ll",
+	"Lowercase_Letter",
+	"Lt",
+	"Titlecase_Letter",
+	"Lu",
+	"Uppercase_Letter"
+]);
+function nn(e, n) {
+	let r = t({
+		accuracy: "default",
+		asciiWordBoundaries: !1,
+		avoidSubclass: !1,
+		bestEffortTarget: "ES2025"
+	}, n);
+	sn(e);
+	let i = {
+		accuracy: r.accuracy,
+		asciiWordBoundaries: r.asciiWordBoundaries,
+		avoidSubclass: r.avoidSubclass,
+		flagDirectivesByAlt: /* @__PURE__ */ new Map(),
+		jsGroupNameMap: /* @__PURE__ */ new Map(),
+		minTargetEs2024: Bt(r.bestEffortTarget, "ES2024"),
+		passedLookbehind: !1,
+		strategy: null,
+		subroutineRefMap: /* @__PURE__ */ new Map(),
+		supportedGNodes: /* @__PURE__ */ new Set(),
+		digitIsAscii: e.flags.digitIsAscii,
+		spaceIsAscii: e.flags.spaceIsAscii,
+		wordIsAscii: e.flags.wordIsAscii
+	};
+	j(e, rn, i);
+	let a = {
+		dotAll: e.flags.dotAll,
+		ignoreCase: e.flags.ignoreCase
+	}, o = {
+		currentFlags: a,
+		prevFlags: null,
+		globalFlags: a,
+		groupOriginByCopy: /* @__PURE__ */ new Map(),
+		groupsByName: /* @__PURE__ */ new Map(),
+		multiplexCapturesToLeftByRef: /* @__PURE__ */ new Map(),
+		openRefs: /* @__PURE__ */ new Map(),
+		reffedNodesByReferencer: /* @__PURE__ */ new Map(),
+		subroutineRefMap: i.subroutineRefMap
+	};
+	return j(e, an, o), j(e, on, {
+		groupsByName: o.groupsByName,
+		highestOrphanBackref: 0,
+		numCapturesToLeft: 0,
+		reffedNodesByReferencer: o.reffedNodesByReferencer
+	}), e._originMap = o.groupOriginByCopy, e._strategy = i.strategy, e;
+}
+var rn = {
+	AbsenceFunction({ node: e, parent: t, replaceWith: n }) {
+		let { body: r, kind: i } = e;
+		if (i === "repeater") {
+			let e = E();
+			e.body[0].body.push(D({
+				negate: !0,
+				body: r
+			}), O("Any"));
+			let i = E();
+			i.body[0].body.push(it("greedy", 0, Infinity, e)), n(Q(i, t), { traverse: !0 });
+		} else throw Error("Unsupported absence function \"(?~|\"");
+	},
+	Alternative: {
+		enter({ node: e, parent: t, key: n }, { flagDirectivesByAlt: r }) {
+			let i = e.body.filter((e) => e.kind === "flags");
+			for (let e = n + 1; e < t.body.length; e++) {
+				let n = t.body[e];
+				q(r, n, []).push(...i);
+			}
+		},
+		exit({ node: e }, { flagDirectivesByAlt: t }) {
+			var n;
+			if ((n = t.get(e)) != null && n.length) {
+				let n = mn(t.get(e));
+				if (n) {
+					let t = E({ flags: n });
+					t.body[0].body = e.body, e.body = [Q(t, e)];
+				}
+			}
+		}
+	},
+	Assertion({ node: e, parent: t, key: n, container: r, root: i, remove: a, replaceWith: o }, s) {
+		let { kind: c, negate: l } = e, { asciiWordBoundaries: u, avoidSubclass: d, supportedGNodes: f, wordIsAscii: p } = s;
+		if (c === "text_segment_boundary") throw Error(`Unsupported text segment boundary "\\${l ? "Y" : "y"}"`);
+		if (c === "line_end") o(Q(D({ body: [C({ body: [Ye("string_end")] }), C({ body: [w(10)] })] }), t));
+		else if (c === "line_start") o(Q(X(G`(?<=\A|\n(?!\z))`, { skipLookbehindValidation: !0 }), t));
+		else if (c === "search_start") if (f.has(e)) i.flags.sticky = !0, a();
+		else {
+			let e = r[n - 1];
+			if (e && bn(e)) o(Q(D({ negate: !0 }), t));
+			else if (d) throw Error(G`Uses "\G" in a way that requires a subclass`);
+			else o(Z(Ye("string_start"), t)), s.strategy = "clip_search";
+		}
+		else if (!(c === "string_end" || c === "string_start")) if (c === "string_end_newline") o(Q(X(G`(?=\n?\z)`), t));
+		else if (c === "word_boundary") {
+			if (!p && !u) {
+				let e = `(?:(?<=${J})(?!${J})|(?<!${J})(?=${J}))`, n = `(?:(?<=${J})(?=${J})|(?<!${J})(?!${J}))`;
+				o(Q(X(l ? n : e), t));
+			}
+		} else throw Error(`Unexpected assertion kind "${c}"`);
+	},
+	Backreference({ node: e }, { jsGroupNameMap: t }) {
+		let { ref: n } = e;
+		typeof n == "string" && !Sn(n) && (n = pn(n, t), e.ref = n);
+	},
+	CapturingGroup({ node: e }, { jsGroupNameMap: t, subroutineRefMap: n }) {
+		let { name: r } = e;
+		r && !Sn(r) && (r = pn(r, t), e.name = r), n.set(e.number, e), r && n.set(r, e);
+	},
+	CharacterClassRange({ node: e, parent: t, replaceWith: n }) {
+		t.kind === "intersection" && n(Q(T({ body: [e] }), t), { traverse: !0 });
+	},
+	CharacterSet({ node: e, parent: t, replaceWith: n }, { accuracy: r, minTargetEs2024: i, digitIsAscii: a, spaceIsAscii: o, wordIsAscii: s }) {
+		let { kind: c, negate: l, value: u } = e;
+		if (a && (c === "digit" || u === "digit")) {
+			n(Z($e("digit", { negate: l }), t));
+			return;
+		}
+		if (o && (c === "space" || u === "space")) {
+			n(Q(Cn(X(Gt), l), t));
+			return;
+		}
+		if (s && (c === "word" || u === "word")) {
+			n(Z($e("word", { negate: l }), t));
+			return;
+		}
+		if (c === "any") n(Z(O("Any"), t));
+		else if (c === "digit") n(Z(O("Nd", { negate: l }), t));
+		else if (c !== "dot") if (c === "text_segment") {
+			if (r === "strict") throw Error(G`Use of "\X" requires non-strict accuracy`);
+			let e = "\\p{Emoji}(?:\\p{EMod}|\\uFE0F\\u20E3?|[\\x{E0020}-\\x{E007E}]+\\x{E007F})?", a = G`\p{RI}{2}|${e}(?:\u200D${e})*`;
+			n(Q(X(G`(?>\r\n|${i ? G`\p{RGI_Emoji}` : a}|\P{M}\p{M}*)`, { skipPropertyNameValidation: !0 }), t));
+		} else if (c === "hex") n(Z(O("AHex", { negate: l }), t));
+		else if (c === "newline") n(Q(X(l ? "[^\n]" : "(?>\r\n?|[\n\v\f…\u2028\u2029])"), t));
+		else if (c === "posix") if (!i && (u === "graph" || u === "print")) {
+			if (r === "strict") throw Error(`POSIX class "${u}" requires min target ES2024 or non-strict accuracy`);
+			let e = {
+				graph: "!-~",
+				print: " -~"
+			}[u];
+			l && (e = `\0-${W(e.codePointAt(0) - 1)}${W(e.codePointAt(2) + 1)}-\u{10FFFF}`), n(Q(X(`[${e}]`), t));
+		} else n(Q(Cn(X(Qt.get(u)), l), t));
+		else if (c === "property") Jt.has(A(u)) || (e.key = "sc");
+		else if (c === "space") n(Z(O("space", { negate: l }), t));
+		else if (c === "word") n(Q(Cn(X(J), l), t));
+		else throw Error(`Unexpected character set kind "${c}"`);
+	},
+	Directive({ node: e, parent: t, root: n, remove: r, replaceWith: i, removeAllPrevSiblings: a, removeAllNextSiblings: o }) {
+		let { kind: s, flags: c } = e;
+		if (s === "flags") if (!c.enable && !c.disable) r();
+		else {
+			let e = E({ flags: c });
+			e.body[0].body = o(), i(Q(e, t), { traverse: !0 });
+		}
+		else if (s === "keep") {
+			let e = n.body[0], r = n.body.length === 1 && Ie(e, { type: "Group" }) && e.body[0].body.length === 1 ? e.body[0] : n;
+			if (t.parent !== r || r.body.length > 1) throw Error(G`Uses "\K" in a way that's unsupported`);
+			let o = D({ behind: !0 });
+			o.body[0].body = a(), i(Q(o, t));
+		} else throw Error(`Unexpected directive kind "${s}"`);
+	},
+	Flags({ node: e, parent: t }) {
+		var n;
+		if (e.posixIsAscii) throw Error("Unsupported flag \"P\"");
+		if (e.textSegmentMode === "word") throw Error("Unsupported flag \"y{w}\"");
+		[
+			"digitIsAscii",
+			"extended",
+			"posixIsAscii",
+			"spaceIsAscii",
+			"wordIsAscii",
+			"textSegmentMode"
+		].forEach((t) => delete e[t]), Object.assign(e, {
+			global: !1,
+			hasIndices: !1,
+			multiline: !1,
+			sticky: (n = e.sticky) == null ? !1 : n
+		}), t.options = {
+			disable: {
+				x: !0,
+				n: !0
+			},
+			force: { v: !0 }
+		};
+	},
+	Group({ node: e }) {
+		if (!e.flags) return;
+		let { enable: t, disable: n } = e.flags;
+		t != null && t.extended && delete t.extended, n != null && n.extended && delete n.extended, t != null && t.dotAll && n != null && n.dotAll && delete t.dotAll, t != null && t.ignoreCase && n != null && n.ignoreCase && delete t.ignoreCase, t && !Object.keys(t).length && delete e.flags.enable, n && !Object.keys(n).length && delete e.flags.disable, !e.flags.enable && !e.flags.disable && delete e.flags;
+	},
+	LookaroundAssertion({ node: e }, t) {
+		let { kind: n } = e;
+		n === "lookbehind" && (t.passedLookbehind = !0);
+	},
+	NamedCallout({ node: e, parent: t, replaceWith: n }) {
+		let { kind: r } = e;
+		if (r === "fail") n(Q(D({ negate: !0 }), t));
+		else throw Error(`Unsupported named callout "(*${r.toUpperCase()}"`);
+	},
+	Quantifier({ node: e }) {
+		if (e.body.type === "Quantifier") {
+			let t = E();
+			t.body[0].body.push(e.body), e.body = Q(t, e);
+		}
+	},
+	Regex: {
+		enter({ node: e }, { supportedGNodes: t }) {
+			let n = [], r = !1, i = !1;
+			for (let t of e.body) if (t.body.length === 1 && t.body[0].kind === "search_start") t.body.pop();
+			else {
+				let e = _n(t.body);
+				e ? (r = !0, Array.isArray(e) ? n.push(...e) : n.push(e)) : i = !0;
+			}
+			r && !i && n.forEach((e) => t.add(e));
+		},
+		exit(e, { accuracy: t, passedLookbehind: n, strategy: r }) {
+			if (t === "strict" && n && r) throw Error(G`Uses "\G" in a way that requires non-strict accuracy`);
+		}
+	},
+	Subroutine({ node: e }, { jsGroupNameMap: t }) {
+		let { ref: n } = e;
+		typeof n == "string" && !Sn(n) && (n = pn(n, t), e.ref = n);
+	}
+}, an = {
+	Backreference({ node: e }, { multiplexCapturesToLeftByRef: t, reffedNodesByReferencer: n }) {
+		let { orphan: r, ref: i } = e;
+		r || n.set(e, [...t.get(i).map(({ node: e }) => e)]);
+	},
+	CapturingGroup: {
+		enter({ node: e, parent: t, replaceWith: n, skip: r }, { groupOriginByCopy: i, groupsByName: a, multiplexCapturesToLeftByRef: o, openRefs: s, reffedNodesByReferencer: c }) {
+			var l;
+			let u = i.get(e);
+			if (u && s.has(e.number)) {
+				let r = Z(dn(e.number), t);
+				c.set(r, s.get(e.number)), n(r);
+				return;
+			}
+			s.set(e.number, e), o.set(e.number, []), e.name && q(o, e.name, []);
+			let d = o.get((l = e.name) == null ? e.number : l);
+			for (let t = 0; t < d.length; t++) {
+				let n = d[t];
+				if (u === n.node || u && u === n.origin || e === n.origin) {
+					d.splice(t, 1);
+					break;
+				}
+			}
+			if (o.get(e.number).push({
+				node: e,
+				origin: u
+			}), e.name && o.get(e.name).push({
+				node: e,
+				origin: u
+			}), e.name) {
+				let t = q(a, e.name, /* @__PURE__ */ new Map()), n = !1;
+				if (u) n = !0;
+				else for (let e of t.values()) if (!e.hasDuplicateNameToRemove) {
+					n = !0;
+					break;
+				}
+				a.get(e.name).set(e, {
+					node: e,
+					hasDuplicateNameToRemove: n
+				});
+			}
+		},
+		exit({ node: e }, { openRefs: t }) {
+			t.delete(e.number);
+		}
+	},
+	Group: {
+		enter({ node: e }, t) {
+			t.prevFlags = t.currentFlags, e.flags && (t.currentFlags = zt(t.currentFlags, e.flags));
+		},
+		exit(e, t) {
+			t.currentFlags = t.prevFlags;
+		}
+	},
+	Subroutine({ node: e, parent: t, replaceWith: n }, r) {
+		let { isRecursive: i, ref: a } = e;
+		if (i) {
+			let n = t;
+			for (; (n = n.parent) && !(n.type === "CapturingGroup" && (n.name === a || n.number === a)););
+			r.reffedNodesByReferencer.set(e, n);
+			return;
+		}
+		let o = r.subroutineRefMap.get(a), s = a === 0, c = s ? dn(0) : un(o, r.groupOriginByCopy, null), l = c;
+		if (!s) {
+			let e = mn(fn(o, (e) => e.type === "Group" && !!e.flags)), t = e ? zt(r.globalFlags, e) : r.globalFlags;
+			cn(t, r.currentFlags) || (l = E({ flags: hn(t) }), l.body[0].body.push(c));
+		}
+		n(Q(l, t), { traverse: !s });
+	}
+}, on = {
+	Backreference({ node: e, parent: t, replaceWith: n }, r) {
+		if (e.orphan) {
+			r.highestOrphanBackref = Math.max(r.highestOrphanBackref, e.ref);
+			return;
+		}
+		let i = r.reffedNodesByReferencer.get(e).filter((t) => ln(t, e));
+		i.length ? i.length > 1 ? n(Q(E({
+			atomic: !0,
+			body: i.reverse().map((e) => C({ body: [Xe(e.number)] }))
+		}), t)) : e.ref = i[0].number : n(Q(D({ negate: !0 }), t));
+	},
+	CapturingGroup({ node: e }, t) {
+		e.number = ++t.numCapturesToLeft, e.name && t.groupsByName.get(e.name).get(e).hasDuplicateNameToRemove && delete e.name;
+	},
+	Regex: { exit({ node: e }, t) {
+		let n = Math.max(t.highestOrphanBackref - t.numCapturesToLeft, 0);
+		for (let t = 0; t < n; t++) {
+			let t = Ze();
+			e.body.at(-1).body.push(t);
+		}
+	} },
+	Subroutine({ node: e }, t) {
+		!e.isRecursive || e.ref === 0 || (e.ref = t.reffedNodesByReferencer.get(e).number);
+	}
+};
+function sn(e) {
+	j(e, { "*"({ node: e, parent: t }) {
+		e.parent = t;
+	} });
+}
+function cn(e, t) {
+	return e.dotAll === t.dotAll && e.ignoreCase === t.ignoreCase;
+}
+function ln(e, t) {
+	let n = t;
+	do {
+		if (n.type === "Regex") return !1;
+		if (n.type === "Alternative") continue;
+		if (n === e) return !1;
+		let t = gn(n.parent);
+		for (let r of t) {
+			if (r === n) break;
+			if (r === e || vn(r, e)) return !0;
+		}
+	} while (n = n.parent);
+	throw Error("Unexpected path");
+}
+function un(e, t, n, r) {
+	let i = Array.isArray(e) ? [] : {};
+	for (let [o, s] of Object.entries(e)) if (o === "parent") i.parent = Array.isArray(n) ? r : n;
+	else if (s && typeof s == "object") i[o] = un(s, t, i, n);
+	else {
+		if (o === "type" && s === "CapturingGroup") {
+			var a;
+			t.set(i, (a = t.get(e)) == null ? e : a);
+		}
+		i[o] = s;
+	}
+	return i;
+}
+function dn(e) {
+	let t = ot(e);
+	return t.isRecursive = !0, t;
+}
+function fn(e, t) {
+	let n = [];
+	for (; e = e.parent;) (!t || t(e)) && n.push(e);
+	return n;
+}
+function pn(e, t) {
+	if (t.has(e)) return t.get(e);
+	let n = `$${t.size}_${e.replace(/* @__PURE__ */ RegExp("^[^$_\\p{IDS}]|[^$\\u200C\\u200D\\p{IDC}]", "gu"), "_")}`;
+	return t.set(e, n), n;
+}
+function mn(e) {
+	let t = ["dotAll", "ignoreCase"], n = {
+		enable: {},
+		disable: {}
+	};
+	return e.forEach(({ flags: e }) => {
+		t.forEach((t) => {
+			var r, i;
+			(r = e.enable) != null && r[t] && (delete n.disable[t], n.enable[t] = !0), (i = e.disable) != null && i[t] && (n.disable[t] = !0);
+		});
+	}), Object.keys(n.enable).length || delete n.enable, Object.keys(n.disable).length || delete n.disable, n.enable || n.disable ? n : null;
+}
+function hn({ dotAll: e, ignoreCase: t }) {
+	let n = {};
+	return (e || t) && (n.enable = {}, e && (n.enable.dotAll = !0), t && (n.enable.ignoreCase = !0)), (!e || !t) && (n.disable = {}, !e && (n.disable.dotAll = !0), !t && (n.disable.ignoreCase = !0)), n;
+}
+function gn(e) {
+	if (!e) throw Error("Node expected");
+	let { body: t } = e;
+	return Array.isArray(t) ? t : t ? [t] : null;
+}
+function _n(e) {
+	let t = e.find((e) => e.kind === "search_start" || xn(e, { negate: !1 }) || !yn(e));
+	if (!t) return null;
+	if (t.kind === "search_start") return t;
+	if (t.type === "LookaroundAssertion") return t.body[0].body[0];
+	if (t.type === "CapturingGroup" || t.type === "Group") {
+		let e = [];
+		for (let n of t.body) {
+			let t = _n(n.body);
+			if (!t) return null;
+			Array.isArray(t) ? e.push(...t) : e.push(t);
+		}
+		return e;
+	}
+	return null;
+}
+function vn(e, t) {
+	var n;
+	let r = (n = gn(e)) == null ? [] : n;
+	for (let e of r) if (e === t || vn(e, t)) return !0;
+	return !1;
+}
+function yn({ type: e }) {
+	return e === "Assertion" || e === "Directive" || e === "LookaroundAssertion";
+}
+function bn(e) {
+	let t = [
+		"Character",
+		"CharacterClass",
+		"CharacterSet"
+	];
+	return t.includes(e.type) || e.type === "Quantifier" && e.min && t.includes(e.body.type);
+}
+function xn(e, n) {
+	let r = t({ negate: null }, n);
+	return e.type === "LookaroundAssertion" && (r.negate === null || e.negate === r.negate) && e.body.length === 1 && Ie(e.body[0], {
+		type: "Assertion",
+		kind: "search_start"
+	});
+}
+function Sn(e) {
+	return (/* @__PURE__ */ RegExp("^[$_\\p{IDS}][$\\u200C\\u200D\\p{IDC}]*$", "u")).test(e);
+}
+function X(e, n) {
+	let r = ze(e, t(t({}, n), {}, { unicodePropertyMap: Jt })).body;
+	return r.length > 1 || r[0].body.length > 1 ? E({ body: r }) : r[0].body[0];
+}
+function Cn(e, t) {
+	return e.negate = t, e;
+}
+function Z(e, t) {
+	return e.parent = t, e;
+}
+function Q(e, t) {
+	return sn(e), e.parent = t, e;
+}
+function wn(e, n) {
+	let r = Wt(n), i = Bt(r.target, "ES2024"), a = Bt(r.target, "ES2025"), o = r.rules.recursionLimit;
+	if (!Number.isInteger(o) || o < 2 || o > 20) throw Error("Invalid recursionLimit; use 2-20");
+	let s = null, c = null;
+	if (!a) {
+		let t = [e.flags.ignoreCase];
+		j(e, Tn, {
+			getCurrentModI: () => t.at(-1),
+			popModI() {
+				t.pop();
+			},
+			pushModI(e) {
+				t.push(e);
+			},
+			setHasCasedChar() {
+				t.at(-1) ? s = !0 : c = !0;
+			}
+		});
+	}
+	let l = {
+		dotAll: e.flags.dotAll,
+		ignoreCase: !!((e.flags.ignoreCase || s) && !c)
+	}, u = e, d = {
+		accuracy: r.accuracy,
+		appliedGlobalFlags: l,
+		captureMap: /* @__PURE__ */ new Map(),
+		currentFlags: {
+			dotAll: e.flags.dotAll,
+			ignoreCase: e.flags.ignoreCase
+		},
+		inCharClass: !1,
+		lastNode: u,
+		originMap: e._originMap,
+		recursionLimit: o,
+		useAppliedIgnoreCase: !!(!a && s && c),
+		useFlagMods: a,
+		useFlagV: i,
+		verbose: r.verbose
+	};
+	function f(e) {
+		return d.lastNode = u, u = e, Vt(En[e.type], `Unexpected node type "${e.type}"`)(e, d, f);
+	}
+	let p = {
+		pattern: e.body.map(f).join("|"),
+		flags: f(e.flags),
+		options: t({}, e.options)
+	};
+	return i || (delete p.options.force.v, p.options.disable.v = !0, p.options.unicodeSetsPlugin = null), p._captureTransfers = /* @__PURE__ */ new Map(), p._hiddenCaptures = [], d.captureMap.forEach((e, t) => {
+		e.hidden && p._hiddenCaptures.push(t), e.transferTo && q(p._captureTransfers, e.transferTo, []).push(t);
+	}), p;
+}
+var Tn = {
+	"*": {
+		enter({ node: e }, t) {
+			if (Ln(e)) {
+				let n = t.getCurrentModI();
+				t.pushModI(e.flags ? zt({ ignoreCase: n }, e.flags).ignoreCase : n);
+			}
+		},
+		exit({ node: e }, t) {
+			Ln(e) && t.popModI();
+		}
+	},
+	Backreference(e, t) {
+		t.setHasCasedChar();
+	},
+	Character({ node: e }, t) {
+		Mn(W(e.value)) && t.setHasCasedChar();
+	},
+	CharacterClassRange({ node: e, skip: t }, n) {
+		t(), Nn(e, { firstOnly: !0 }).length && n.setHasCasedChar();
+	},
+	CharacterSet({ node: e }, t) {
+		e.kind === "property" && tn.has(e.value) && t.setHasCasedChar();
+	}
+}, En = {
+	Alternative({ body: e }, t, n) {
+		return e.map(n).join("");
+	},
+	Assertion({ kind: e, negate: t }) {
+		if (e === "string_end") return "$";
+		if (e === "string_start") return "^";
+		if (e === "word_boundary") return t ? G`\B` : G`\b`;
+		throw Error(`Unexpected assertion kind "${e}"`);
+	},
+	Backreference({ ref: e }, t) {
+		if (typeof e != "number") throw Error("Unexpected named backref in transformed AST");
+		if (!t.useFlagMods && t.accuracy === "strict" && t.currentFlags.ignoreCase && !t.captureMap.get(e).ignoreCase) throw Error("Use of case-insensitive backref to case-sensitive group requires target ES2025 or non-strict accuracy");
+		return "\\" + e;
+	},
+	CapturingGroup(e, t, n) {
+		let { body: r, name: i, number: a } = e, o = { ignoreCase: t.currentFlags.ignoreCase }, s = t.originMap.get(e);
+		return s && (o.hidden = !0, a > s.number && (o.transferTo = s.number)), t.captureMap.set(a, o), `(${i ? `?<${i}>` : ""}${r.map(n).join("|")})`;
+	},
+	Character({ value: e }, t) {
+		let n = W(e), r = $(e, {
+			escDigit: t.lastNode.type === "Backreference",
+			inCharClass: t.inCharClass,
+			useFlagV: t.useFlagV
+		});
+		if (r !== n) return r;
+		if (t.useAppliedIgnoreCase && t.currentFlags.ignoreCase && Mn(n)) {
+			let e = qt(n);
+			return t.inCharClass ? e.join("") : e.length > 1 ? `[${e.join("")}]` : e[0];
+		}
+		return n;
+	},
+	CharacterClass(e, t, n) {
+		let { kind: r, negate: i, parent: a } = e, { body: o } = e;
+		if (r === "intersection" && !t.useFlagV) throw Error("Use of character class intersection requires min target ES2024");
+		K.bugFlagVLiteralHyphenIsRange && t.useFlagV && o.some(zn) && (o = [w(45), ...o.filter((e) => !zn(e))]);
+		let s = () => `[${i ? "^" : ""}${o.map(n).join(r === "intersection" ? "&&" : "")}]`;
+		if (!t.inCharClass) {
+			if ((!t.useFlagV || K.bugNestedClassIgnoresNegation) && !i) {
+				let t = o.filter((e) => e.type === "CharacterClass" && e.kind === "union" && e.negate);
+				if (t.length) {
+					let r = E(), i = r.body[0];
+					return r.parent = a, i.parent = r, o = o.filter((e) => !t.includes(e)), e.body = o, o.length ? (e.parent = i, i.body.push(e)) : r.body.pop(), t.forEach((e) => {
+						let t = C({ body: [e] });
+						e.parent = t, t.parent = r, r.body.push(t);
+					}), n(r);
+				}
+			}
+			t.inCharClass = !0;
+			let r = s();
+			return t.inCharClass = !1, r;
+		}
+		let c = o[0];
+		if (r === "union" && !i && c && ((!t.useFlagV || !t.verbose) && a.kind === "union" && !(K.bugFlagVLiteralHyphenIsRange && t.useFlagV) || !t.verbose && a.kind === "intersection" && o.length === 1 && c.type !== "CharacterClassRange")) return o.map(n).join("");
+		if (!t.useFlagV && a.type === "CharacterClass") throw Error("Uses nested character class in a way that requires min target ES2024");
+		return s();
+	},
+	CharacterClassRange(e, t) {
+		let n = e.min.value, r = e.max.value, i = {
+			escDigit: !1,
+			inCharClass: !0,
+			useFlagV: t.useFlagV
+		}, a = $(n, i), o = $(r, i), s = /* @__PURE__ */ new Set();
+		return t.useAppliedIgnoreCase && t.currentFlags.ignoreCase && Pn(Nn(e)).forEach((e) => {
+			s.add(Array.isArray(e) ? `${$(e[0], i)}-${$(e[1], i)}` : $(e, i));
+		}), `${a}-${o}${[...s].join("")}`;
+	},
+	CharacterSet({ kind: e, negate: t, value: n, key: r }, i) {
+		if (e === "dot") return i.currentFlags.dotAll ? i.appliedGlobalFlags.dotAll || i.useFlagMods ? "." : "[^]" : G`[^\n]`;
+		if (e === "digit") return t ? G`\D` : G`\d`;
+		if (e === "property") {
+			if (i.useAppliedIgnoreCase && i.currentFlags.ignoreCase && tn.has(n)) throw Error(`Unicode property "${n}" can't be case-insensitive when other chars have specific case`);
+			return `${t ? G`\P` : G`\p`}{${r ? `${r}=` : ""}${n}}`;
+		}
+		if (e === "word") return t ? G`\W` : G`\w`;
+		throw Error(`Unexpected character set kind "${e}"`);
+	},
+	Flags(e, t) {
+		return (t.appliedGlobalFlags.ignoreCase ? "i" : "") + (e.dotAll ? "s" : "") + (e.sticky ? "y" : "");
+	},
+	Group({ atomic: e, body: t, flags: n, parent: r }, i, a) {
+		let o = i.currentFlags;
+		n && (i.currentFlags = zt(o, n));
+		let s = t.map(a).join("|"), c = !i.verbose && t.length === 1 && r.type !== "Quantifier" && !e && (!i.useFlagMods || !n) ? s : `(?${Fn(e, n, i.useFlagMods)}${s})`;
+		return i.currentFlags = o, c;
+	},
+	LookaroundAssertion({ body: e, kind: t, negate: n }, r, i) {
+		return `(?${`${t === "lookahead" ? "" : "<"}${n ? "!" : "="}`}${e.map(i).join("|")})`;
+	},
+	Quantifier(e, t, n) {
+		return n(e.body) + In(e);
+	},
+	Subroutine({ isRecursive: e, ref: t }, n) {
+		if (!e) throw Error("Unexpected non-recursive subroutine in transformed AST");
+		let r = n.recursionLimit;
+		return t === 0 ? `(?R=${r})` : G`\g<${t}&R=${r}>`;
+	}
+}, Dn = /* @__PURE__ */ new Set([
+	"$",
+	"(",
+	")",
+	"*",
+	"+",
+	".",
+	"?",
+	"[",
+	"\\",
+	"]",
+	"^",
+	"{",
+	"|",
+	"}"
+]), On = /* @__PURE__ */ new Set([
+	"-",
+	"\\",
+	"]",
+	"^",
+	"["
+]), kn = /* @__PURE__ */ new Set(/* @__PURE__ */ "()-/[\\]^{|}!#$%&*+,.:;<=>?@`~".split("")), An = /* @__PURE__ */ new Map([
+	[9, G`\t`],
+	[10, G`\n`],
+	[11, G`\v`],
+	[12, G`\f`],
+	[13, G`\r`],
+	[8232, G`\u2028`],
+	[8233, G`\u2029`],
+	[65279, G`\uFEFF`]
+]), jn = /* @__PURE__ */ RegExp("^\\p{Cased}$", "u");
+function Mn(e) {
+	return jn.test(e);
+}
+function Nn(e, t) {
+	let n = !!(t != null && t.firstOnly), r = e.min.value, i = e.max.value, a = [];
+	if (r < 65 && (i === 65535 || i >= 131071) || r === 65536 && i >= 131071) return a;
+	for (let e = r; e <= i; e++) {
+		let t = W(e);
+		if (!Mn(t)) continue;
+		let o = qt(t).filter((e) => {
+			let t = e.codePointAt(0);
+			return t < r || t > i;
+		});
+		if (o.length && (a.push(...o), n)) break;
+	}
+	return a;
+}
+function $(e, { escDigit: t, inCharClass: n, useFlagV: r }) {
+	if (An.has(e)) return An.get(e);
+	if (e < 32 || e > 126 && e < 160 || e > 262143 || t && Rn(e)) return e > 255 ? `\\u{${e.toString(16).toUpperCase()}}` : `\\x${e.toString(16).toUpperCase().padStart(2, "0")}`;
+	let i = n ? r ? kn : On : Dn, a = W(e);
+	return (i.has(a) ? "\\" : "") + a;
+}
+function Pn(e) {
+	let t = e.map((e) => e.codePointAt(0)).sort((e, t) => e - t), n = [], r = null;
+	for (let e = 0; e < t.length; e++) t[e + 1] === t[e] + 1 ? r != null || (r = t[e]) : r === null ? n.push(t[e]) : (n.push([r, t[e]]), r = null);
+	return n;
+}
+function Fn(e, t, n) {
+	if (e) return ">";
+	let r = "";
+	if (t && n) {
+		let { enable: e, disable: n } = t;
+		r = (e != null && e.ignoreCase ? "i" : "") + (e != null && e.dotAll ? "s" : "") + (n ? "-" : "") + (n != null && n.ignoreCase ? "i" : "") + (n != null && n.dotAll ? "s" : "");
+	}
+	return `${r}:`;
+}
+function In({ kind: e, max: t, min: n }) {
+	let r;
+	return r = !n && t === 1 ? "?" : !n && t === Infinity ? "*" : n === 1 && t === Infinity ? "+" : n === t ? `{${n}}` : `{${n},${t === Infinity ? "" : t}}`, r + {
+		greedy: "",
+		lazy: "?",
+		possessive: "+"
+	}[e];
+}
+function Ln({ type: e }) {
+	return e === "CapturingGroup" || e === "Group" || e === "LookaroundAssertion";
+}
+function Rn(e) {
+	return e > 47 && e < 58;
+}
+function zn({ type: e, value: t }) {
+	return e === "Character" && t === 45;
+}
+var Bn = (z = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), H = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap(), Lt = /* @__PURE__ */ new WeakSet(), Rt = class r extends RegExp {
+	get source() {
+		return l(V, this) || "(?:)";
+	}
+	constructor(n, i, a) {
+		var c = (...t) => (super(...t), o(this, Lt), s(this, z, /* @__PURE__ */ new Map()), s(this, B, null), s(this, V, void 0), s(this, H, null), s(this, U, null), e(this, "rawOptions", {}), this);
+		let d = !!(a != null && a.lazyCompile);
+		if (n instanceof RegExp) {
+			if (a) throw Error("Cannot provide options when copying a regexp");
+			let e = n;
+			c(e, i), u(V, this, e.source), e instanceof r && (u(z, this, l(z, e)), u(H, this, l(H, e)), u(U, this, l(U, e)), this.rawOptions = e.rawOptions);
+		} else {
+			let e = t({
+				hiddenCaptures: [],
+				strategy: null,
+				transfers: []
+			}, a);
+			c(d ? "" : n, i), u(V, this, n), u(z, this, Un(e.hiddenCaptures, e.transfers)), u(U, this, e.strategy), this.rawOptions = a == null ? {} : a;
+		}
+		d || u(B, this, this);
+	}
+	exec(e) {
+		if (!l(B, this)) {
+			let e = this.rawOptions, { lazyCompile: t } = e, i = n(e, It);
+			u(B, this, new r(l(V, this), this.flags, i));
+		}
+		let t = this.global || this.sticky, i = this.lastIndex;
+		if (l(U, this) === "clip_search" && t && i) {
+			this.lastIndex = 0;
+			let t = c(Lt, this, Vn).call(this, e.slice(i));
+			return t && (Hn(t, i, e, this.hasIndices), this.lastIndex += i), t;
+		}
+		return c(Lt, this, Vn).call(this, e);
+	}
+}, Rt);
+function Vn(e) {
+	l(B, this).lastIndex = this.lastIndex;
+	let t = m(Rt.prototype, "exec", this).call(l(B, this), e);
+	if (this.lastIndex = l(B, this).lastIndex, !t || !l(z, this).size) return t;
+	let n = [...t];
+	t.length = 1;
+	let r;
+	this.hasIndices && (r = [...t.indices], t.indices.length = 1);
+	let i = [0];
+	for (let e = 1; e < n.length; e++) {
+		var a;
+		let { hidden: o, transferTo: s } = (a = l(z, this).get(e)) == null ? {} : a;
+		if (o ? i.push(null) : (i.push(t.length), t.push(n[e]), this.hasIndices && t.indices.push(r[e])), s && n[e] !== void 0) {
+			let a = i[s];
+			if (!a) throw Error(`Invalid capture transfer to "${a}"`);
+			if (t[a] = n[e], this.hasIndices && (t.indices[a] = r[e]), t.groups) {
+				l(H, this) || u(H, this, Wn(this.source));
+				let i = l(H, this).get(s);
+				i && (t.groups[i] = n[e], this.hasIndices && (t.indices.groups[i] = r[e]));
+			}
+		}
+	}
+	return t;
+}
+function Hn(e, t, n, r) {
+	if (e.index += t, e.input = n, r) {
+		let n = e.indices;
+		for (let e = 0; e < n.length; e++) {
+			let r = n[e];
+			r && (n[e] = [r[0] + t, r[1] + t]);
+		}
+		let r = n.groups;
+		r && Object.keys(r).forEach((e) => {
+			let n = r[e];
+			n && (r[e] = [n[0] + t, n[1] + t]);
+		});
+	}
+}
+function Un(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) n.set(t, { hidden: !0 });
+	for (let [e, r] of t) for (let t of r) q(n, t, {}).transferTo = e;
+	return n;
+}
+function Wn(e) {
+	let t = /* @__PURE__ */ RegExp("(?<capture>\\((?:\\?<(?![=!])(?<name>[^>]+)>|(?!\\?)))|\\\\?.", "gsu"), n = /* @__PURE__ */ new Map(), r = 0, i = 0, a;
+	for (; a = t.exec(e);) {
+		let { 0: e, groups: { capture: t, name: o } } = a;
+		e === "[" ? r++ : r ? e === "]" && r-- : t && (i++, o && n.set(i, o));
+	}
+	return n;
+}
+function Gn(e, t) {
+	let n = Kn(e, t);
+	return n.options ? new Bn(n.pattern, n.flags, n.options) : new RegExp(n.pattern, n.flags);
+}
+function Kn(e, n) {
+	let r = Wt(n), i = nn(ze(e, {
+		flags: r.flags,
+		normalizeUnknownPropertyNames: !0,
+		rules: {
+			captureGroup: r.rules.captureGroup,
+			singleline: r.rules.singleline
+		},
+		skipBackrefValidation: r.rules.allowOrphanBackrefs,
+		unicodePropertyMap: Jt
+	}), {
+		accuracy: r.accuracy,
+		asciiWordBoundaries: r.rules.asciiWordBoundaries,
+		avoidSubclass: r.avoidSubclass,
+		bestEffortTarget: r.target
+	}), a = wn(i, r), o = At(a.pattern, {
+		captureTransfers: a._captureTransfers,
+		hiddenCaptures: a._hiddenCaptures,
+		mode: "external"
+	}), s = Ct(Et(o.pattern).pattern, {
+		captureTransfers: o.captureTransfers,
+		hiddenCaptures: o.hiddenCaptures
+	}), c = {
+		pattern: s.pattern,
+		flags: `${r.hasIndices ? "d" : ""}${r.global ? "g" : ""}${a.flags}${a.options.disable.v ? "u" : "v"}`
+	};
+	if (r.avoidSubclass) {
+		if (r.lazyCompileLength !== Infinity) throw Error("Lazy compilation requires subclass");
+	} else {
+		let e = s.hiddenCaptures.sort((e, t) => e - t), n = Array.from(s.captureTransfers), a = i._strategy, o = c.pattern.length >= r.lazyCompileLength;
+		(e.length || n.length || a || o) && (c.options = t(t(t(t({}, e.length && { hiddenCaptures: e }), n.length && { transfers: n }), a && { strategy: a }), o && { lazyCompile: o }));
+	}
+	return c;
+}
+//#endregion
+//#region node_modules/@shikijs/engine-javascript/dist/engine-compile.mjs
+function qn(e, n) {
+	return Gn(e, t({
+		global: !0,
+		hasIndices: !0,
+		lazyCompileLength: 3e3,
+		rules: {
+			allowOrphanBackrefs: !0,
+			asciiWordBoundaries: !0,
+			captureGroup: !0,
+			recursionLimit: 5,
+			singleline: !0
+		}
+	}, n));
+}
+function Jn(e = {}) {
+	let t = Object.assign({
+		target: "auto",
+		cache: /* @__PURE__ */ new Map()
+	}, e);
+	return t.regexConstructor || (t.regexConstructor = (e) => qn(e, { target: t.target })), {
+		createScanner(e) {
+			return new i(e, t);
+		},
+		createString(e) {
+			return { content: e };
+		}
+	};
+}
+//#endregion
+export { Jn as createJavaScriptRegexEngine };