@septkit/ui 0.0.42 → 0.0.43

package/dist/external/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/dist/parser/parse.js

@@ -0,0 +1,419 @@
+import { PosixClassNames as e, cpOf as t, getOrInsert as n, r, throwIfNullish as i } from "../utils.js";
+import { tokenize as a } from "../tokenizer/tokenize.js";
+import { hasOnlyChild as o, isQuantifiable as s } from "./node-utils.js";
+//#region node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/dist/parser/parse.js
+function c(e, t = {}) {
+	let n = {
+		flags: "",
+		normalizeUnknownPropertyNames: !1,
+		skipBackrefValidation: !1,
+		skipLookbehindValidation: !1,
+		skipPropertyNameValidation: !1,
+		unicodePropertyMap: null,
+		...t,
+		rules: {
+			captureGroup: !1,
+			singleline: !1,
+			...t.rules
+		}
+	}, i = a(e, {
+		flags: n.flags,
+		rules: {
+			captureGroup: n.rules.captureGroup,
+			singleline: n.rules.singleline
+		}
+	}), o = (e, t) => {
+		let n = i.tokens[s.nextIndex];
+		switch (s.parent = e, s.nextIndex++, n.type) {
+			case "Alternator": return v();
+			case "Assertion": return l(n);
+			case "Backreference": return u(n, s);
+			case "Character": return S(n.value, { useLastValid: !!t.isCheckingRangeEnd });
+			case "CharacterClassHyphen": return d(n, s, t);
+			case "CharacterClassOpen": return f(n, s, t);
+			case "CharacterSet": return p(n, s);
+			case "Directive": return E(n.kind, { flags: n.flags });
+			case "GroupOpen": return m(n, s, t);
+			case "NamedCallout": return A(n.kind, n.tag, n.arguments);
+			case "Quantifier": return h(n, s);
+			case "Subroutine": return g(n, s);
+			default: throw Error(`Unexpected token type "${n.type}"`);
+		}
+	}, s = {
+		capturingGroups: [],
+		hasNumberedRef: !1,
+		namedGroupsByName: /* @__PURE__ */ new Map(),
+		nextIndex: 0,
+		normalizeUnknownPropertyNames: n.normalizeUnknownPropertyNames,
+		parent: null,
+		skipBackrefValidation: n.skipBackrefValidation,
+		skipLookbehindValidation: n.skipLookbehindValidation,
+		skipPropertyNameValidation: n.skipPropertyNameValidation,
+		subroutines: [],
+		tokens: i.tokens,
+		unicodePropertyMap: n.unicodePropertyMap,
+		walk: o
+	}, c = N(D(i.flags)), _ = c.body[0];
+	for (; s.nextIndex < i.tokens.length;) {
+		let e = o(_, {});
+		e.type === "Alternative" ? (c.body.push(e), _ = e) : _.body.push(e);
+	}
+	let { capturingGroups: y, hasNumberedRef: b, namedGroupsByName: x, subroutines: C } = s;
+	if (b && x.size && !n.rules.captureGroup) throw Error("Numbered backref/subroutine not allowed when using named capture");
+	for (let { ref: e } of C) if (typeof e == "number") {
+		if (e > y.length) throw Error("Subroutine uses a group number that's not defined");
+		e && (y[e - 1].isSubroutined = !0);
+	} else if (x.has(e)) {
+		if (x.get(e).length > 1) throw Error(r`Subroutine uses a duplicate group name "\g<${e}>"`);
+		x.get(e)[0].isSubroutined = !0;
+	} else throw Error(r`Subroutine uses a group name that's not defined "\g<${e}>"`);
+	return c;
+}
+function l({ kind: e }) {
+	return y(i({
+		"^": "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 === r`\B` || e === r`\Y` });
+}
+function u({ 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, b(r ? i + 1 - n : n, { orphan: a });
+	};
+	if (n) {
+		let n = /^(?<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 b(r);
+	}
+	return i(+r);
+}
+function d(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, {
+			...r,
+			isCheckingRangeEnd: !0
+		});
+		if (s.type === "Character" && e.type === "Character") return o.body.pop(), w(s, e);
+		throw Error("Invalid character class range");
+	}
+	return S(t("-"));
+}
+function f({ negate: e }, t, n) {
+	let { tokens: r, walk: i } = t, a = [C()], o = r[t.nextIndex], s = W(o);
+	for (; s.type !== "CharacterClassClose";) {
+		if (s.type === "CharacterClassIntersector") a.push(C()), t.nextIndex++;
+		else {
+			let e = a.at(-1);
+			e.body.push(i(e, n));
+		}
+		s = W(r[t.nextIndex], o);
+	}
+	let c = C({ negate: e });
+	return a.length === 1 ? c.body = a[0].body : (c.kind = "intersection", c.body = a.map((e) => e.body.length === 1 ? e.body[0] : e)), t.nextIndex++, c;
+}
+function p({ kind: t, negate: n, value: r }, i) {
+	let { normalizeUnknownPropertyNames: a, skipPropertyNameValidation: o, unicodePropertyMap: s } = i;
+	if (t === "property") {
+		let i = U(r);
+		if (e.has(i) && !s?.has(i)) t = "posix", r = i;
+		else return F(r, {
+			negate: n,
+			normalizeUnknownPropertyNames: a,
+			skipPropertyNameValidation: o,
+			unicodePropertyMap: s
+		});
+	}
+	return t === "posix" ? j(r, { negate: n }) : T(t, { negate: n });
+}
+function m(e, t, r) {
+	let { tokens: i, capturingGroups: a, namedGroupsByName: o, skipLookbehindValidation: s, walk: c } = t, l = I(e), u = l.type === "AbsenceFunction", d = B(l), f = d && l.negate;
+	if (l.type === "CapturingGroup" && (a.push(l), l.name && n(o, l.name, []).push(l)), u && r.isInAbsenceFunction) throw Error("Nested absence function not supported by Oniguruma");
+	let p = G(i[t.nextIndex]);
+	for (; p.type !== "GroupClose";) {
+		if (p.type === "Alternator") l.body.push(v()), t.nextIndex++;
+		else {
+			let e = l.body.at(-1), t = c(e, {
+				...r,
+				isInAbsenceFunction: r.isInAbsenceFunction || u,
+				isInLookbehind: r.isInLookbehind || d,
+				isInNegLookbehind: r.isInNegLookbehind || f
+			});
+			if (e.body.push(t), (d || r.isInLookbehind) && !s) {
+				let e = "Lookbehind includes a pattern not allowed by Oniguruma";
+				if (f || r.isInNegLookbehind) {
+					if (z(t) || t.type === "CapturingGroup") throw Error(e);
+				} else if (z(t) || B(t) && t.negate) throw Error(e);
+			}
+		}
+		p = G(i[t.nextIndex]);
+	}
+	return t.nextIndex++, l;
+}
+function h({ kind: e, min: t, max: n }, r) {
+	let i = r.parent, a = i.body.at(-1);
+	if (!a || !s(a)) throw Error("Quantifier requires a repeatable token");
+	let o = M(e, t, n, a);
+	return i.body.pop(), o;
+}
+function g({ raw: e }, t) {
+	let { capturingGroups: n, subroutines: r } = t, i = e.slice(3, -1), a = /^(?<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 = P(i);
+	return r.push(o), o;
+}
+function _(e, t) {
+	if (e !== "repeater") throw Error(`Unexpected absence function kind "${e}"`);
+	return {
+		type: "AbsenceFunction",
+		kind: e,
+		body: L(t?.body)
+	};
+}
+function v(e) {
+	return {
+		type: "Alternative",
+		body: R(e?.body)
+	};
+}
+function y(e, t) {
+	let n = {
+		type: "Assertion",
+		kind: e
+	};
+	return (e === "word_boundary" || e === "text_segment_boundary") && (n.negate = !!t?.negate), n;
+}
+function b(e, t) {
+	let n = !!t?.orphan;
+	return {
+		type: "Backreference",
+		ref: e,
+		...n && { orphan: n }
+	};
+}
+function x(e, t) {
+	let n = {
+		name: void 0,
+		isSubroutined: !1,
+		...t
+	};
+	if (n.name !== void 0 && !V(n.name)) throw Error(`Group name "${n.name}" invalid in Oniguruma`);
+	return {
+		type: "CapturingGroup",
+		number: e,
+		...n.name && { name: n.name },
+		...n.isSubroutined && { isSubroutined: n.isSubroutined },
+		body: L(t?.body)
+	};
+}
+function S(e, t) {
+	let n = {
+		useLastValid: !1,
+		...t
+	};
+	if (e > 1114111) {
+		let t = e.toString(16);
+		if (n.useLastValid) e = 1114111;
+		else throw Error(e > 1310719 ? `Invalid code point out of range "\\x{${t}}"` : `Invalid code point out of range in JS "\\x{${t}}"`);
+	}
+	return {
+		type: "Character",
+		value: e
+	};
+}
+function C(e) {
+	let t = {
+		kind: "union",
+		negate: !1,
+		...e
+	};
+	return {
+		type: "CharacterClass",
+		kind: t.kind,
+		negate: t.negate,
+		body: R(e?.body)
+	};
+}
+function w(e, t) {
+	if (t.value < e.value) throw Error("Character class range out of order");
+	return {
+		type: "CharacterClassRange",
+		min: e,
+		max: t
+	};
+}
+function T(e, t) {
+	let n = !!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 E(e, t = {}) {
+	if (e === "keep") return {
+		type: "Directive",
+		kind: e
+	};
+	if (e === "flags") return {
+		type: "Directive",
+		kind: e,
+		flags: i(t.flags)
+	};
+	throw Error(`Unexpected directive kind "${e}"`);
+}
+function D(e) {
+	return {
+		type: "Flags",
+		...e
+	};
+}
+function O(e) {
+	let t = e?.atomic, n = e?.flags;
+	if (t && n) throw Error("Atomic group cannot have flags");
+	return {
+		type: "Group",
+		...t && { atomic: t },
+		...n && { flags: n },
+		body: L(e?.body)
+	};
+}
+function k(e) {
+	let t = {
+		behind: !1,
+		negate: !1,
+		...e
+	};
+	return {
+		type: "LookaroundAssertion",
+		kind: t.behind ? "lookbehind" : "lookahead",
+		negate: t.negate,
+		body: L(e?.body)
+	};
+}
+function A(e, t, n) {
+	return {
+		type: "NamedCallout",
+		kind: e,
+		tag: t,
+		arguments: n
+	};
+}
+function j(t, n) {
+	let r = !!n?.negate;
+	if (!e.has(t)) throw Error(`Invalid POSIX class "${t}"`);
+	return {
+		type: "CharacterSet",
+		kind: "posix",
+		value: t,
+		negate: r
+	};
+}
+function M(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 N(e, t) {
+	return {
+		type: "Regex",
+		body: L(t?.body),
+		flags: e
+	};
+}
+function P(e) {
+	return {
+		type: "Subroutine",
+		ref: e
+	};
+}
+function F(e, t) {
+	let n = {
+		negate: !1,
+		normalizeUnknownPropertyNames: !1,
+		skipPropertyNameValidation: !1,
+		unicodePropertyMap: null,
+		...t
+	}, i = n.unicodePropertyMap?.get(U(e));
+	if (!i) {
+		if (n.normalizeUnknownPropertyNames) i = H(e);
+		else if (n.unicodePropertyMap && !n.skipPropertyNameValidation) throw Error(r`Invalid Unicode property "\p{${e}}"`);
+	}
+	return {
+		type: "CharacterSet",
+		kind: "property",
+		value: i ?? e,
+		negate: n.negate
+	};
+}
+function I({ flags: e, kind: t, name: n, negate: r, number: i }) {
+	switch (t) {
+		case "absence_repeater": return _("repeater");
+		case "atomic": return O({ atomic: !0 });
+		case "capturing": return x(i, { name: n });
+		case "group": return O({ flags: e });
+		case "lookahead":
+		case "lookbehind": return k({
+			behind: t === "lookbehind",
+			negate: r
+		});
+		default: throw Error(`Unexpected group kind "${t}"`);
+	}
+}
+function L(e) {
+	if (e === void 0) e = [v()];
+	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 R(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 z(e) {
+	return e.type === "LookaroundAssertion" && e.kind === "lookahead";
+}
+function B(e) {
+	return e.type === "LookaroundAssertion" && e.kind === "lookbehind";
+}
+function V(e) {
+	return /^[\p{Alpha}\p{Pc}][^)]*$/u.test(e);
+}
+function H(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 U(e) {
+	return e.replace(/[- _]+/g, "").toLowerCase();
+}
+function W(e, t) {
+	let n = t;
+	return i(e, `Unclosed character class${n?.type === "Character" && n.value === 93 && n.raw === "]" ? " (started with \"]\")" : ""}`);
+}
+function G(e) {
+	return i(e, "Unclosed group");
+}
+//#endregion
+export { _ as createAbsenceFunction, v as createAlternative, y as createAssertion, b as createBackreference, x as createCapturingGroup, S as createCharacter, C as createCharacterClass, w as createCharacterClassRange, T as createCharacterSet, E as createDirective, D as createFlags, O as createGroup, k as createLookaroundAssertion, A as createNamedCallout, j as createPosixClass, M as createQuantifier, N as createRegex, P as createSubroutine, F as createUnicodeProperty, o as hasOnlyChild, s as isQuantifiable, c as parse, U as slug };