@septkit/ui 0.0.42 → 0.0.44

package/dist/external/.pnpm/oniguruma-to-es@4.3.6/node_modules/oniguruma-to-es/dist/esm/index.js

@@ -0,0 +1,970 @@
+import { hasOnlyChild as e } from "../../../../../oniguruma-parser@0.12.2/node_modules/oniguruma-parser/dist/parser/node-utils.js";
+import { createAlternative as t, createAssertion as n, createBackreference as r, createCapturingGroup as i, createCharacter as a, createCharacterClass as o, createCharacterSet as s, createGroup as c, createLookaroundAssertion as l, createQuantifier as u, createSubroutine as d, createUnicodeProperty as f, parse as p, slug as m } from "../../../../../oniguruma-parser@0.12.2/node_modules/oniguruma-parser/dist/parser/parse.js";
+import { traverse as h } from "../../../../../oniguruma-parser@0.12.2/node_modules/oniguruma-parser/dist/traverser/traverse.js";
+import { atomic as g, possessive as _ } from "../../../../../regex@6.1.0/node_modules/regex/src/atomic.js";
+import "../../../../../regex@6.1.0/node_modules/regex/src/internals.js";
+import { recursion as ee } from "../../../../../regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js";
+//#region node_modules/.pnpm/oniguruma-to-es@4.3.6/node_modules/oniguruma-to-es/dist/esm/index.js
+var v = String.fromCodePoint, y = String.raw, b = {}, x = globalThis.RegExp;
+b.flagGroups = (() => {
+	try {
+		new x("(?i:)");
+	} catch {
+		return !1;
+	}
+	return !0;
+})(), b.unicodeSets = (() => {
+	try {
+		new x("[[]]", "v");
+	} catch {
+		return !1;
+	}
+	return !0;
+})(), b.bugFlagVLiteralHyphenIsRange = b.unicodeSets ? (() => {
+	try {
+		new x(y`[\d\-a]`, "v");
+	} catch {
+		return !0;
+	}
+	return !1;
+})() : !1, b.bugNestedClassIgnoresNegation = b.unicodeSets && new x("[[^a]]", "v").test("a");
+function S(e, { enable: t, disable: n }) {
+	return {
+		dotAll: !n?.dotAll && !!(t?.dotAll || e.dotAll),
+		ignoreCase: !n?.ignoreCase && !!(t?.ignoreCase || e.ignoreCase)
+	};
+}
+function C(e, t, n) {
+	return e.has(t) || e.set(t, n), e.get(t);
+}
+function w(e, t) {
+	return T[e] >= T[t];
+}
+function te(e, t) {
+	if (e == null) throw Error(t ?? "Value expected");
+	return e;
+}
+var T = {
+	ES2025: 2025,
+	ES2024: 2024,
+	ES2018: 2018
+}, ne = {
+	auto: "auto",
+	ES2025: "ES2025",
+	ES2024: "ES2024",
+	ES2018: "ES2018"
+};
+function E(e = {}) {
+	if ({}.toString.call(e) !== "[object Object]") throw Error("Unexpected options");
+	if (e.target !== void 0 && !ne[e.target]) throw Error(`Unexpected target "${e.target}"`);
+	let t = {
+		accuracy: "default",
+		avoidSubclass: !1,
+		flags: "",
+		global: !1,
+		hasIndices: !1,
+		lazyCompileLength: Infinity,
+		target: "auto",
+		verbose: !1,
+		...e,
+		rules: {
+			allowOrphanBackrefs: !1,
+			asciiWordBoundaries: !1,
+			captureGroup: !1,
+			recursionLimit: 20,
+			singleline: !1,
+			...e.rules
+		}
+	};
+	return t.target === "auto" && (t.target = b.flagGroups ? "ES2025" : b.unicodeSets ? "ES2024" : "ES2018"), t;
+}
+var re = "[	-\r ]", ie = /* @__PURE__ */ new Set([v(304), v(305)]), D = y`[\p{L}\p{M}\p{N}\p{Pc}]`;
+function O(e) {
+	if (ie.has(e)) return [e];
+	let t = /* @__PURE__ */ new Set(), n = e.toLowerCase(), r = n.toUpperCase(), i = se.get(n), a = ae.get(n), o = oe.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 k = /* @__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) => [m(e), e])), ae = /* @__PURE__ */ new Map([["s", v(383)], [v(383), "s"]]), oe = /* @__PURE__ */ new Map([
+	[v(223), v(7838)],
+	[v(107), v(8490)],
+	[v(229), v(8491)],
+	[v(969), v(8486)]
+]), se = new Map([
+	A(453),
+	A(456),
+	A(459),
+	A(498),
+	...j(8072, 8079),
+	...j(8088, 8095),
+	...j(8104, 8111),
+	A(8124),
+	A(8140),
+	A(8188)
+]), ce = /* @__PURE__ */ new Map([
+	["alnum", y`[\p{Alpha}\p{Nd}]`],
+	["alpha", y`\p{Alpha}`],
+	["ascii", y`\p{ASCII}`],
+	["blank", y`[\p{Zs}\t]`],
+	["cntrl", y`\p{Cc}`],
+	["digit", y`\p{Nd}`],
+	["graph", y`[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]`],
+	["lower", y`\p{Lower}`],
+	["print", y`[[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]\p{Zs}]`],
+	["punct", y`[\p{P}\p{S}]`],
+	["space", y`\p{space}`],
+	["upper", y`\p{Upper}`],
+	["word", y`[\p{Alpha}\p{M}\p{Nd}\p{Pc}]`],
+	["xdigit", y`\p{AHex}`]
+]);
+function le(e, t) {
+	let n = [];
+	for (let r = e; r <= t; r++) n.push(r);
+	return n;
+}
+function A(e) {
+	let t = v(e);
+	return [t.toLowerCase(), t];
+}
+function j(e, t) {
+	return le(e, t).map((e) => A(e));
+}
+var M = /* @__PURE__ */ new Set([
+	"Lower",
+	"Lowercase",
+	"Upper",
+	"Uppercase",
+	"Ll",
+	"Lowercase_Letter",
+	"Lt",
+	"Titlecase_Letter",
+	"Lu",
+	"Uppercase_Letter"
+]);
+function ue(e, t) {
+	let n = {
+		accuracy: "default",
+		asciiWordBoundaries: !1,
+		avoidSubclass: !1,
+		bestEffortTarget: "ES2025",
+		...t
+	};
+	N(e);
+	let r = {
+		accuracy: n.accuracy,
+		asciiWordBoundaries: n.asciiWordBoundaries,
+		avoidSubclass: n.avoidSubclass,
+		flagDirectivesByAlt: /* @__PURE__ */ new Map(),
+		jsGroupNameMap: /* @__PURE__ */ new Map(),
+		minTargetEs2024: w(n.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
+	};
+	h(e, de, r);
+	let i = {
+		dotAll: e.flags.dotAll,
+		ignoreCase: e.flags.ignoreCase
+	}, a = {
+		currentFlags: i,
+		prevFlags: null,
+		globalFlags: i,
+		groupOriginByCopy: /* @__PURE__ */ new Map(),
+		groupsByName: /* @__PURE__ */ new Map(),
+		multiplexCapturesToLeftByRef: /* @__PURE__ */ new Map(),
+		openRefs: /* @__PURE__ */ new Map(),
+		reffedNodesByReferencer: /* @__PURE__ */ new Map(),
+		subroutineRefMap: r.subroutineRefMap
+	};
+	return h(e, fe, a), h(e, pe, {
+		groupsByName: a.groupsByName,
+		highestOrphanBackref: 0,
+		numCapturesToLeft: 0,
+		reffedNodesByReferencer: a.reffedNodesByReferencer
+	}), e._originMap = a.groupOriginByCopy, e._strategy = r.strategy, e;
+}
+var de = {
+	AbsenceFunction({ node: e, parent: t, replaceWith: n }) {
+		let { body: r, kind: i } = e;
+		if (i === "repeater") {
+			let e = c();
+			e.body[0].body.push(l({
+				negate: !0,
+				body: r
+			}), f("Any"));
+			let i = c();
+			i.body[0].body.push(u("greedy", 0, Infinity, e)), n(G(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];
+				C(r, n, []).push(...i);
+			}
+		},
+		exit({ node: e }, { flagDirectivesByAlt: t }) {
+			if (t.get(e)?.length) {
+				let n = L(t.get(e));
+				if (n) {
+					let t = c({ flags: n });
+					t.body[0].body = e.body, e.body = [G(t, e)];
+				}
+			}
+		}
+	},
+	Assertion({ node: e, parent: r, key: i, container: o, root: s, remove: c, replaceWith: u }, d) {
+		let { kind: f, negate: p } = e, { asciiWordBoundaries: m, avoidSubclass: h, supportedGNodes: g, wordIsAscii: _ } = d;
+		if (f === "text_segment_boundary") throw Error(`Unsupported text segment boundary "\\${p ? "Y" : "y"}"`);
+		if (f === "line_end") u(G(l({ body: [t({ body: [n("string_end")] }), t({ body: [a(10)] })] }), r));
+		else if (f === "line_start") u(G(H(y`(?<=\A|\n(?!\z))`, { skipLookbehindValidation: !0 }), r));
+		else if (f === "search_start") if (g.has(e)) s.flags.sticky = !0, c();
+		else {
+			let e = o[i - 1];
+			if (e && ye(e)) u(G(l({ negate: !0 }), r));
+			else if (h) throw Error(y`Uses "\G" in a way that requires a subclass`);
+			else u(W(n("string_start"), r)), d.strategy = "clip_search";
+		}
+		else if (!(f === "string_end" || f === "string_start")) if (f === "string_end_newline") u(G(H(y`(?=\n?\z)`), r));
+		else if (f === "word_boundary") {
+			if (!_ && !m) {
+				let e = `(?:(?<=${D})(?!${D})|(?<!${D})(?=${D}))`, t = `(?:(?<=${D})(?=${D})|(?<!${D})(?!${D}))`;
+				u(G(H(p ? t : e), r));
+			}
+		} else throw Error(`Unexpected assertion kind "${f}"`);
+	},
+	Backreference({ node: e }, { jsGroupNameMap: t }) {
+		let { ref: n } = e;
+		typeof n == "string" && !V(n) && (n = I(n, t), e.ref = n);
+	},
+	CapturingGroup({ node: e }, { jsGroupNameMap: t, subroutineRefMap: n }) {
+		let { name: r } = e;
+		r && !V(r) && (r = I(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(G(o({ body: [e] }), t), { traverse: !0 });
+	},
+	CharacterSet({ node: e, parent: t, replaceWith: n }, { accuracy: r, minTargetEs2024: i, digitIsAscii: a, spaceIsAscii: o, wordIsAscii: c }) {
+		let { kind: l, negate: u, value: d } = e;
+		if (a && (l === "digit" || d === "digit")) {
+			n(W(s("digit", { negate: u }), t));
+			return;
+		}
+		if (o && (l === "space" || d === "space")) {
+			n(G(U(H(re), u), t));
+			return;
+		}
+		if (c && (l === "word" || d === "word")) {
+			n(W(s("word", { negate: u }), t));
+			return;
+		}
+		if (l === "any") n(W(f("Any"), t));
+		else if (l === "digit") n(W(f("Nd", { negate: u }), t));
+		else if (l !== "dot") if (l === "text_segment") {
+			if (r === "strict") throw Error(y`Use of "\X" requires non-strict accuracy`);
+			let e = "\\p{Emoji}(?:\\p{EMod}|\\uFE0F\\u20E3?|[\\x{E0020}-\\x{E007E}]+\\x{E007F})?", a = y`\p{RI}{2}|${e}(?:\u200D${e})*`;
+			n(G(H(y`(?>\r\n|${i ? y`\p{RGI_Emoji}` : a}|\P{M}\p{M}*)`, { skipPropertyNameValidation: !0 }), t));
+		} else if (l === "hex") n(W(f("AHex", { negate: u }), t));
+		else if (l === "newline") n(G(H(u ? "[^\n]" : "(?>\r\n?|[\n\v\f…\u2028\u2029])"), t));
+		else if (l === "posix") if (!i && (d === "graph" || d === "print")) {
+			if (r === "strict") throw Error(`POSIX class "${d}" requires min target ES2024 or non-strict accuracy`);
+			let e = {
+				graph: "!-~",
+				print: " -~"
+			}[d];
+			u && (e = `\0-${v(e.codePointAt(0) - 1)}${v(e.codePointAt(2) + 1)}-\u{10FFFF}`), n(G(H(`[${e}]`), t));
+		} else n(G(U(H(ce.get(d)), u), t));
+		else if (l === "property") k.has(m(d)) || (e.key = "sc");
+		else if (l === "space") n(W(f("space", { negate: u }), t));
+		else if (l === "word") n(G(U(H(D), u), t));
+		else throw Error(`Unexpected character set kind "${l}"`);
+	},
+	Directive({ node: t, parent: n, root: r, remove: i, replaceWith: a, removeAllPrevSiblings: o, removeAllNextSiblings: s }) {
+		let { kind: u, flags: d } = t;
+		if (u === "flags") if (!d.enable && !d.disable) i();
+		else {
+			let e = c({ flags: d });
+			e.body[0].body = s(), a(G(e, n), { traverse: !0 });
+		}
+		else if (u === "keep") {
+			let t = r.body[0], i = r.body.length === 1 && e(t, { type: "Group" }) && t.body[0].body.length === 1 ? t.body[0] : r;
+			if (n.parent !== i || i.body.length > 1) throw Error(y`Uses "\K" in a way that's unsupported`);
+			let s = l({ behind: !0 });
+			s.body[0].body = o(), a(G(s, n));
+		} else throw Error(`Unexpected directive kind "${u}"`);
+	},
+	Flags({ node: e, parent: t }) {
+		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: e.sticky ?? !1
+		}), 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?.extended && delete t.extended, n?.extended && delete n.extended, t?.dotAll && n?.dotAll && delete t.dotAll, t?.ignoreCase && 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(G(l({ negate: !0 }), t));
+		else throw Error(`Unsupported named callout "(*${r.toUpperCase()}"`);
+	},
+	Quantifier({ node: e }) {
+		if (e.body.type === "Quantifier") {
+			let t = c();
+			t.body[0].body.push(e.body), e.body = G(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 = z(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(y`Uses "\G" in a way that requires non-strict accuracy`);
+		}
+	},
+	Subroutine({ node: e }, { jsGroupNameMap: t }) {
+		let { ref: n } = e;
+		typeof n == "string" && !V(n) && (n = I(n, t), e.ref = n);
+	}
+}, fe = {
+	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 }) {
+			let l = i.get(e);
+			if (l && s.has(e.number)) {
+				let r = W(F(e.number), t);
+				c.set(r, s.get(e.number)), n(r);
+				return;
+			}
+			s.set(e.number, e), o.set(e.number, []), e.name && C(o, e.name, []);
+			let u = o.get(e.name ?? e.number);
+			for (let t = 0; t < u.length; t++) {
+				let n = u[t];
+				if (l === n.node || l && l === n.origin || e === n.origin) {
+					u.splice(t, 1);
+					break;
+				}
+			}
+			if (o.get(e.number).push({
+				node: e,
+				origin: l
+			}), e.name && o.get(e.name).push({
+				node: e,
+				origin: l
+			}), e.name) {
+				let t = C(a, e.name, /* @__PURE__ */ new Map()), n = !1;
+				if (l) 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.get(e.number) === e && t.delete(e.number);
+		}
+	},
+	Group: {
+		enter({ node: e }, t) {
+			t.prevFlags = t.currentFlags, e.flags && (t.currentFlags = S(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, l = s ? F(0) : P(o, r.groupOriginByCopy, null), u = l;
+		if (!s) {
+			let e = L(ge(o, (e) => e.type === "Group" && !!e.flags)), t = e ? S(r.globalFlags, e) : r.globalFlags;
+			me(t, r.currentFlags) || (u = c({ flags: _e(t) }), u.body[0].body.push(l));
+		}
+		n(G(u, t), { traverse: !s });
+	}
+}, pe = {
+	Backreference({ node: e, parent: n, replaceWith: i }, a) {
+		if (e.orphan) {
+			a.highestOrphanBackref = Math.max(a.highestOrphanBackref, e.ref);
+			return;
+		}
+		let o = a.reffedNodesByReferencer.get(e).filter((t) => he(t, e));
+		o.length ? o.length > 1 ? i(G(c({
+			atomic: !0,
+			body: o.reverse().map((e) => t({ body: [r(e.number)] }))
+		}), n)) : e.ref = o[0].number : i(G(l({ negate: !0 }), n));
+	},
+	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 = i();
+			e.body.at(-1).body.push(t);
+		}
+	} },
+	Subroutine({ node: e }, t) {
+		!e.isRecursive || e.ref === 0 || (e.ref = t.reffedNodesByReferencer.get(e).number);
+	}
+};
+function N(e) {
+	h(e, { "*"({ node: e, parent: t }) {
+		e.parent = t;
+	} });
+}
+function me(e, t) {
+	return e.dotAll === t.dotAll && e.ignoreCase === t.ignoreCase;
+}
+function he(e, t) {
+	let n = t;
+	do {
+		if (n.type === "Regex") return !1;
+		if (n.type === "Alternative") continue;
+		if (n === e) return !1;
+		let t = R(n.parent);
+		for (let r of t) {
+			if (r === n) break;
+			if (r === e || B(r, e)) return !0;
+		}
+	} while (n = n.parent);
+	throw Error("Unexpected path");
+}
+function P(e, t, n, r) {
+	let i = Array.isArray(e) ? [] : {};
+	for (let [a, o] of Object.entries(e)) a === "parent" ? i.parent = Array.isArray(n) ? r : n : o && typeof o == "object" ? i[a] = P(o, t, i, n) : (a === "type" && o === "CapturingGroup" && t.set(i, t.get(e) ?? e), i[a] = o);
+	return i;
+}
+function F(e) {
+	let t = d(e);
+	return t.isRecursive = !0, t;
+}
+function ge(e, t) {
+	let n = [];
+	for (; e = e.parent;) (!t || t(e)) && n.push(e);
+	return n;
+}
+function I(e, t) {
+	if (t.has(e)) return t.get(e);
+	let n = `$${t.size}_${e.replace(/^[^$_\p{IDS}]|[^$\u200C\u200D\p{IDC}]/gu, "_")}`;
+	return t.set(e, n), n;
+}
+function L(e) {
+	let t = ["dotAll", "ignoreCase"], n = {
+		enable: {},
+		disable: {}
+	};
+	return e.forEach(({ flags: e }) => {
+		t.forEach((t) => {
+			e.enable?.[t] && (delete n.disable[t], n.enable[t] = !0), e.disable?.[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 _e({ 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 R(e) {
+	if (!e) throw Error("Node expected");
+	let { body: t } = e;
+	return Array.isArray(t) ? t : t ? [t] : null;
+}
+function z(e) {
+	let t = e.find((e) => e.kind === "search_start" || be(e, { negate: !1 }) || !ve(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 = z(n.body);
+			if (!t) return null;
+			Array.isArray(t) ? e.push(...t) : e.push(t);
+		}
+		return e;
+	}
+	return null;
+}
+function B(e, t) {
+	let n = R(e) ?? [];
+	for (let e of n) if (e === t || B(e, t)) return !0;
+	return !1;
+}
+function ve({ type: e }) {
+	return e === "Assertion" || e === "Directive" || e === "LookaroundAssertion";
+}
+function ye(e) {
+	let t = [
+		"Character",
+		"CharacterClass",
+		"CharacterSet"
+	];
+	return t.includes(e.type) || e.type === "Quantifier" && e.min && t.includes(e.body.type);
+}
+function be(t, n) {
+	let r = {
+		negate: null,
+		...n
+	};
+	return t.type === "LookaroundAssertion" && (r.negate === null || t.negate === r.negate) && t.body.length === 1 && e(t.body[0], {
+		type: "Assertion",
+		kind: "search_start"
+	});
+}
+function V(e) {
+	return /^[$_\p{IDS}][$\u200C\u200D\p{IDC}]*$/u.test(e);
+}
+function H(e, t) {
+	let n = p(e, {
+		...t,
+		unicodePropertyMap: k
+	}).body;
+	return n.length > 1 || n[0].body.length > 1 ? c({ body: n }) : n[0].body[0];
+}
+function U(e, t) {
+	return e.negate = t, e;
+}
+function W(e, t) {
+	return e.parent = t, e;
+}
+function G(e, t) {
+	return N(e), e.parent = t, e;
+}
+function xe(e, t) {
+	let n = E(t), r = w(n.target, "ES2024"), i = w(n.target, "ES2025"), a = n.rules.recursionLimit;
+	if (!Number.isInteger(a) || a < 2 || a > 20) throw Error("Invalid recursionLimit; use 2-20");
+	let o = null, s = null;
+	if (!i) {
+		let t = [e.flags.ignoreCase];
+		h(e, Se, {
+			getCurrentModI: () => t.at(-1),
+			popModI() {
+				t.pop();
+			},
+			pushModI(e) {
+				t.push(e);
+			},
+			setHasCasedChar() {
+				t.at(-1) ? o = !0 : s = !0;
+			}
+		});
+	}
+	let c = {
+		dotAll: e.flags.dotAll,
+		ignoreCase: !!((e.flags.ignoreCase || o) && !s)
+	}, l = e, u = {
+		accuracy: n.accuracy,
+		appliedGlobalFlags: c,
+		captureMap: /* @__PURE__ */ new Map(),
+		currentFlags: {
+			dotAll: e.flags.dotAll,
+			ignoreCase: e.flags.ignoreCase
+		},
+		inCharClass: !1,
+		lastNode: l,
+		originMap: e._originMap,
+		recursionLimit: a,
+		useAppliedIgnoreCase: !!(!i && o && s),
+		useFlagMods: i,
+		useFlagV: r,
+		verbose: n.verbose
+	};
+	function d(e) {
+		return u.lastNode = l, l = e, te(Ce[e.type], `Unexpected node type "${e.type}"`)(e, u, d);
+	}
+	let f = {
+		pattern: e.body.map(d).join("|"),
+		flags: d(e.flags),
+		options: { ...e.options }
+	};
+	return r || (delete f.options.force.v, f.options.disable.v = !0, f.options.unicodeSetsPlugin = null), f._captureTransfers = /* @__PURE__ */ new Map(), f._hiddenCaptures = [], u.captureMap.forEach((e, t) => {
+		e.hidden && f._hiddenCaptures.push(t), e.transferTo && C(f._captureTransfers, e.transferTo, []).push(t);
+	}), f;
+}
+var Se = {
+	"*": {
+		enter({ node: e }, t) {
+			if (X(e)) {
+				let n = t.getCurrentModI();
+				t.pushModI(e.flags ? S({ ignoreCase: n }, e.flags).ignoreCase : n);
+			}
+		},
+		exit({ node: e }, t) {
+			X(e) && t.popModI();
+		}
+	},
+	Backreference(e, t) {
+		t.setHasCasedChar();
+	},
+	Character({ node: e }, t) {
+		q(v(e.value)) && t.setHasCasedChar();
+	},
+	CharacterClassRange({ node: e, skip: t }, n) {
+		t(), J(e, { firstOnly: !0 }).length && n.setHasCasedChar();
+	},
+	CharacterSet({ node: e }, t) {
+		e.kind === "property" && M.has(e.value) && t.setHasCasedChar();
+	}
+}, Ce = {
+	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 ? y`\B` : y`\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 = v(e), r = Y(e, {
+			escDigit: t.lastNode.type === "Backreference",
+			inCharClass: t.inCharClass,
+			useFlagV: t.useFlagV
+		});
+		if (r !== n) return r;
+		if (t.useAppliedIgnoreCase && t.currentFlags.ignoreCase && q(n)) {
+			let e = O(n);
+			return t.inCharClass ? e.join("") : e.length > 1 ? `[${e.join("")}]` : e[0];
+		}
+		return n;
+	},
+	CharacterClass(e, n, r) {
+		let { kind: i, negate: o, parent: s } = e, { body: l } = e;
+		if (i === "intersection" && !n.useFlagV) throw Error("Use of character class intersection requires min target ES2024");
+		b.bugFlagVLiteralHyphenIsRange && n.useFlagV && l.some(Z) && (l = [a(45), ...l.filter((e) => !Z(e))]);
+		let u = () => `[${o ? "^" : ""}${l.map(r).join(i === "intersection" ? "&&" : "")}]`;
+		if (!n.inCharClass) {
+			if ((!n.useFlagV || b.bugNestedClassIgnoresNegation) && !o) {
+				let n = l.filter((e) => e.type === "CharacterClass" && e.kind === "union" && e.negate);
+				if (n.length) {
+					let i = c(), a = i.body[0];
+					return i.parent = s, a.parent = i, l = l.filter((e) => !n.includes(e)), e.body = l, l.length ? (e.parent = a, a.body.push(e)) : i.body.pop(), n.forEach((e) => {
+						let n = t({ body: [e] });
+						e.parent = n, n.parent = i, i.body.push(n);
+					}), r(i);
+				}
+			}
+			n.inCharClass = !0;
+			let i = u();
+			return n.inCharClass = !1, i;
+		}
+		let d = l[0];
+		if (i === "union" && !o && d && ((!n.useFlagV || !n.verbose) && s.kind === "union" && !(b.bugFlagVLiteralHyphenIsRange && n.useFlagV) || !n.verbose && s.kind === "intersection" && l.length === 1 && d.type !== "CharacterClassRange")) return l.map(r).join("");
+		if (!n.useFlagV && s.type === "CharacterClass") throw Error("Uses nested character class in a way that requires min target ES2024");
+		return u();
+	},
+	CharacterClassRange(e, t) {
+		let n = e.min.value, r = e.max.value, i = {
+			escDigit: !1,
+			inCharClass: !0,
+			useFlagV: t.useFlagV
+		}, a = Y(n, i), o = Y(r, i), s = /* @__PURE__ */ new Set();
+		return t.useAppliedIgnoreCase && t.currentFlags.ignoreCase && Oe(J(e)).forEach((e) => {
+			s.add(Array.isArray(e) ? `${Y(e[0], i)}-${Y(e[1], i)}` : Y(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 ? "." : "[^]" : y`[^\n]`;
+		if (e === "digit") return t ? y`\D` : y`\d`;
+		if (e === "property") {
+			if (i.useAppliedIgnoreCase && i.currentFlags.ignoreCase && M.has(n)) throw Error(`Unicode property "${n}" can't be case-insensitive when other chars have specific case`);
+			return `${t ? y`\P` : y`\p`}{${r ? `${r}=` : ""}${n}}`;
+		}
+		if (e === "word") return t ? y`\W` : y`\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 = S(o, n));
+		let s = t.map(a).join("|"), c = !i.verbose && t.length === 1 && r.type !== "Quantifier" && !e && (!i.useFlagMods || !n) ? s : `(?${ke(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) + Ae(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})` : y`\g<${t}&R=${r}>`;
+	}
+}, we = /* @__PURE__ */ new Set([
+	"$",
+	"(",
+	")",
+	"*",
+	"+",
+	".",
+	"?",
+	"[",
+	"\\",
+	"]",
+	"^",
+	"{",
+	"|",
+	"}"
+]), Te = /* @__PURE__ */ new Set([
+	"-",
+	"\\",
+	"]",
+	"^",
+	"["
+]), Ee = /* @__PURE__ */ new Set(/* @__PURE__ */ "()-/[\\]^{|}!#$%&*+,.:;<=>?@`~".split("")), K = /* @__PURE__ */ new Map([
+	[9, y`\t`],
+	[10, y`\n`],
+	[11, y`\v`],
+	[12, y`\f`],
+	[13, y`\r`],
+	[8232, y`\u2028`],
+	[8233, y`\u2029`],
+	[65279, y`\uFEFF`]
+]), De = /^\p{Cased}$/u;
+function q(e) {
+	return De.test(e);
+}
+function J(e, t) {
+	let n = !!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 = v(e);
+		if (!q(t)) continue;
+		let o = O(t).filter((e) => {
+			let t = e.codePointAt(0);
+			return t < r || t > i;
+		});
+		if (o.length && (a.push(...o), n)) break;
+	}
+	return a;
+}
+function Y(e, { escDigit: t, inCharClass: n, useFlagV: r }) {
+	if (K.has(e)) return K.get(e);
+	if (e < 32 || e > 126 && e < 160 || e > 262143 || t && je(e)) return e > 255 ? `\\u{${e.toString(16).toUpperCase()}}` : `\\x${e.toString(16).toUpperCase().padStart(2, "0")}`;
+	let i = n ? r ? Ee : Te : we, a = v(e);
+	return (i.has(a) ? "\\" : "") + a;
+}
+function Oe(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 ??= t[e] : r === null ? n.push(t[e]) : (n.push([r, t[e]]), r = null);
+	return n;
+}
+function ke(e, t, n) {
+	if (e) return ">";
+	let r = "";
+	if (t && n) {
+		let { enable: e, disable: n } = t;
+		r = (e?.ignoreCase ? "i" : "") + (e?.dotAll ? "s" : "") + (n ? "-" : "") + (n?.ignoreCase ? "i" : "") + (n?.dotAll ? "s" : "");
+	}
+	return `${r}:`;
+}
+function Ae({ 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 X({ type: e }) {
+	return e === "CapturingGroup" || e === "Group" || e === "LookaroundAssertion";
+}
+function je(e) {
+	return e > 47 && e < 58;
+}
+function Z({ type: e, value: t }) {
+	return e === "Character" && t === 45;
+}
+var Q = class e extends RegExp {
+	#e = /* @__PURE__ */ new Map();
+	#t = null;
+	#n;
+	#r = null;
+	#i = null;
+	rawOptions = {};
+	get source() {
+		return this.#n || "(?:)";
+	}
+	constructor(t, n, r) {
+		let i = !!r?.lazyCompile;
+		if (t instanceof RegExp) {
+			if (r) throw Error("Cannot provide options when copying a regexp");
+			let i = t;
+			super(i, n), this.#n = i.source, i instanceof e && (this.#e = i.#e, this.#r = i.#r, this.#i = i.#i, this.rawOptions = i.rawOptions);
+		} else {
+			let e = {
+				hiddenCaptures: [],
+				strategy: null,
+				transfers: [],
+				...r
+			};
+			super(i ? "" : t, n), this.#n = t, this.#e = Ne(e.hiddenCaptures, e.transfers), this.#i = e.strategy, this.rawOptions = r ?? {};
+		}
+		i || (this.#t = this);
+	}
+	exec(t) {
+		if (!this.#t) {
+			let { lazyCompile: t, ...n } = this.rawOptions;
+			this.#t = new e(this.#n, this.flags, n);
+		}
+		let n = this.global || this.sticky, r = this.lastIndex;
+		if (this.#i === "clip_search" && n && r) {
+			this.lastIndex = 0;
+			let e = this.#a(t.slice(r));
+			return e && (Me(e, r, t, this.hasIndices), this.lastIndex += r), e;
+		}
+		return this.#a(t);
+	}
+	#a(e) {
+		this.#t.lastIndex = this.lastIndex;
+		let t = super.exec.call(this.#t, e);
+		if (this.lastIndex = this.#t.lastIndex, !t || !this.#e.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++) {
+			let { hidden: a, transferTo: o } = this.#e.get(e) ?? {};
+			if (a ? i.push(null) : (i.push(t.length), t.push(n[e]), this.hasIndices && t.indices.push(r[e])), o && n[e] !== void 0) {
+				let a = i[o];
+				if (!a) throw Error(`Invalid capture transfer to "${a}"`);
+				if (t[a] = n[e], this.hasIndices && (t.indices[a] = r[e]), t.groups) {
+					this.#r ||= Pe(this.source);
+					let i = this.#r.get(o);
+					i && (t.groups[i] = n[e], this.hasIndices && (t.indices.groups[i] = r[e]));
+				}
+			}
+		}
+		return t;
+	}
+};
+function Me(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 Ne(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) C(n, t, {}).transferTo = e;
+	return n;
+}
+function Pe(e) {
+	let t = /(?<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 Fe(e, t) {
+	let n = $(e, t);
+	return n.options ? new Q(n.pattern, n.flags, n.options) : new RegExp(n.pattern, n.flags);
+}
+function $(e, t) {
+	let n = E(t), r = ue(p(e, {
+		flags: n.flags,
+		normalizeUnknownPropertyNames: !0,
+		rules: {
+			captureGroup: n.rules.captureGroup,
+			singleline: n.rules.singleline
+		},
+		skipBackrefValidation: n.rules.allowOrphanBackrefs,
+		unicodePropertyMap: k
+	}), {
+		accuracy: n.accuracy,
+		asciiWordBoundaries: n.rules.asciiWordBoundaries,
+		avoidSubclass: n.avoidSubclass,
+		bestEffortTarget: n.target
+	}), i = xe(r, n), a = ee(i.pattern, {
+		captureTransfers: i._captureTransfers,
+		hiddenCaptures: i._hiddenCaptures,
+		mode: "external"
+	}), o = g(_(a.pattern).pattern, {
+		captureTransfers: a.captureTransfers,
+		hiddenCaptures: a.hiddenCaptures
+	}), s = {
+		pattern: o.pattern,
+		flags: `${n.hasIndices ? "d" : ""}${n.global ? "g" : ""}${i.flags}${i.options.disable.v ? "u" : "v"}`
+	};
+	if (n.avoidSubclass) {
+		if (n.lazyCompileLength !== Infinity) throw Error("Lazy compilation requires subclass");
+	} else {
+		let e = o.hiddenCaptures.sort((e, t) => e - t), t = Array.from(o.captureTransfers), i = r._strategy, a = s.pattern.length >= n.lazyCompileLength;
+		(e.length || t.length || i || a) && (s.options = {
+			...e.length && { hiddenCaptures: e },
+			...t.length && { transfers: t },
+			...i && { strategy: i },
+			...a && { lazyCompile: a }
+		});
+	}
+	return s;
+}
+//#endregion
+export { Q as EmulatedRegExp, Fe as toRegExp, $ as toRegExpDetails };