@stll/regex-set-wasm 1.0.9 → 1.1.0

package/dist/single-thread.mjs

@@ -0,0 +1,1015 @@
+//#region src/core.ts
+const encoder$1 = new TextEncoder();
+const ALTERNATION_CHUNK_MIN_BRANCHES = 64;
+const ALTERNATION_CHUNK_SIZE = 20;
+const ALTERNATION_CHUNK_MAX_BODY_START = 32;
+let binding;
+/** Set the native backend. Must be called once
+*  before any class constructor. */
+const initBinding = (b) => {
+	binding = b;
+};
+function unpack(packed, haystack, names, indexMap) {
+	const len = packed.length;
+	const matches = new Array(len / 3);
+	for (let i = 0, j = 0; i < len; i += 3, j++) {
+		const idx = packed[i];
+		const s = packed[i + 1];
+		const e = packed[i + 2];
+		if (idx === void 0 || s === void 0 || e === void 0) throw new Error(`Corrupt packed match data at offset ${i}`);
+		const pattern = indexMap ? indexMap[idx] : idx;
+		if (pattern === void 0) throw new Error(`Missing native index map ${idx}`);
+		const m = {
+			pattern,
+			start: s,
+			end: e,
+			text: haystack.slice(s, e)
+		};
+		if (names && names[pattern] !== void 0) m.name = names[pattern];
+		matches[j] = m;
+	}
+	return matches;
+}
+/**
+* Replace unescaped `\b` and `\B` with their
+* ASCII-only equivalents `(?-u:\b)` / `(?-u:\B)`.
+* Skips character classes `[...]` (where `\b` means
+* backspace) and escaped backslashes `\\b`.
+*/
+function asciiBoundaries(src) {
+	let result = "";
+	let inClass = false;
+	let i = 0;
+	while (i < src.length) if (src.charAt(i) === "\\" && i + 1 < src.length) {
+		const next = src.charAt(i + 1);
+		if (!inClass && (next === "b" || next === "B")) result += `(?-u:\\${next})`;
+		else result += src.charAt(i) + src.charAt(i + 1);
+		i += 2;
+	} else {
+		if (src.charAt(i) === "[") inClass = true;
+		if (src.charAt(i) === "]") inClass = false;
+		result += src.charAt(i);
+		i++;
+	}
+	return result;
+}
+/**
+* Convert a RegExp to Rust regex syntax string.
+*/
+function regexpToRust(re) {
+	let flags = "";
+	if (re.flags.includes("i")) flags += "i";
+	if (re.flags.includes("m")) flags += "m";
+	if (re.flags.includes("s")) flags += "s";
+	if (!flags) return javascriptCharacterClasses(re);
+	if (!flags.includes("i")) return `(?${flags})${javascriptCharacterClasses(re)}`;
+	let src = re.unicode || re.unicodeSets ? javascriptCharacterClasses(re) : javascriptLegacyCaseFolding(re);
+	let leading = "";
+	let trailing = "";
+	if (src.startsWith("\\b")) {
+		leading = "\\b";
+		src = src.slice(2);
+	} else if (src.startsWith("\\B")) {
+		leading = "\\B";
+		src = src.slice(2);
+	}
+	if (src.length >= 2) {
+		const last = src.at(-1);
+		if (last === "b" || last === "B") {
+			let bs = 0;
+			let k = src.length - 2;
+			while (k >= 0 && src[k] === "\\") {
+				bs++;
+				k--;
+			}
+			if (bs > 0 && bs % 2 === 1) {
+				trailing = "\\" + last;
+				src = src.slice(0, -2);
+			}
+		}
+	}
+	return `${leading}(?${flags}:${src})${trailing}`;
+}
+const JS_WHITESPACE = "\\x{0009}-\\x{000D}\\x{0020}\\x{00A0}\\x{1680}\\x{2000}-\\x{200A}\\x{2028}\\x{2029}\\x{202F}\\x{205F}\\x{3000}\\x{FEFF}";
+function javascriptCharacterClasses(re) {
+	let result = "";
+	let classDepth = 0;
+	const unicodeCase = re.ignoreCase && (re.unicode || re.unicodeSets);
+	const word = "a-zA-Z0-9_" + (unicodeCase ? "\\x{017F}\\x{212A}" : "");
+	for (let i = 0; i < re.source.length; i++) {
+		const char = re.source.charAt(i);
+		if (char !== "\\") {
+			if (char === "[" && (classDepth === 0 || re.unicodeSets)) classDepth++;
+			if (char === "]" && classDepth > 0) classDepth--;
+			result += char;
+			continue;
+		}
+		const escaped = re.source.charAt(++i);
+		if (escaped === "b" || escaped === "B") {
+			if (classDepth > 0) {
+				result += escaped === "b" ? "\\x{0008}" : "B";
+				continue;
+			}
+			if (!unicodeCase) {
+				result += `(?-u:\\${escaped})`;
+				continue;
+			}
+			const beforeWord = `(?<=[${word}])`;
+			const beforeNonword = `(?<![${word}])`;
+			const afterWord = `(?=[${word}])`;
+			const afterNonword = `(?![${word}])`;
+			result += escaped === "b" ? `(?-i:(?:${beforeWord}${afterNonword}|${beforeNonword}${afterWord}))` : `(?-i:(?:${beforeWord}${afterWord}|${beforeNonword}${afterNonword}))`;
+			continue;
+		}
+		let members;
+		switch (escaped.toLowerCase()) {
+			case "s":
+				members = JS_WHITESPACE;
+				break;
+			case "d":
+				members = "0-9";
+				break;
+			case "w":
+				members = word;
+				break;
+			default:
+				result += "\\" + escaped;
+				continue;
+		}
+		const negation = escaped === escaped.toUpperCase() ? "^" : "";
+		result += `[${negation}${members}]`;
+	}
+	return result;
+}
+let legacyUnicodeFolds;
+/** Legacy JS folding uses one UTF-16 unit's uppercase, excluding ASCII folds. */
+function getLegacyUnicodeFolds() {
+	if (legacyUnicodeFolds) return legacyUnicodeFolds;
+	const groups = /* @__PURE__ */ new Map();
+	for (let code = 128; code <= 65535; code++) {
+		const char = String.fromCharCode(code);
+		const canonical = char.toUpperCase();
+		if (canonical.length !== 1 || canonical === char || canonical.charCodeAt(0) < 128) continue;
+		const members = groups.get(canonical);
+		if (members) members.push(char);
+		else groups.set(canonical, [canonical, char]);
+	}
+	legacyUnicodeFolds = groups;
+	return groups;
+}
+function legacyLiteralPattern(literal) {
+	if (/[a-z]/i.test(literal)) return `(?-i:[${literal.toLowerCase()}${literal.toUpperCase()}])`;
+	const code = literal.codePointAt(0);
+	if (code === void 0) throw new Error("Missing literal");
+	const canonical = literal.toUpperCase();
+	const members = canonical.length === 1 && canonical.charCodeAt(0) >= 128 ? getLegacyUnicodeFolds().get(canonical) : void 0;
+	return members ? `(?-i:[${members.join("")}])` : `(?-i:\\x{${code.toString(16)}})`;
+}
+/** Keep legacy /i folding local so dots and complements remain Unicode-safe. */
+function javascriptLegacyCaseFolding(re) {
+	let result = "";
+	for (let i = 0; i < re.source.length; i++) {
+		const char = re.source.charAt(i);
+		if (char === "\\") {
+			const escaped = re.source.charAt(++i);
+			if ("sSwWdDbB".includes(escaped)) {
+				const token = new RegExp("\\" + escaped, "i");
+				result += `(?-i:${javascriptCharacterClasses(token)})`;
+				continue;
+			}
+			const hex = re.source.slice(i).match(/^(?:x[\da-f]{2}|u[\da-f]{4})/i)?.[0];
+			if (hex) {
+				const literal = String.fromCharCode(Number.parseInt(hex.slice(1), 16));
+				result += legacyLiteralPattern(literal);
+				i += hex.length - 1;
+				continue;
+			}
+			if (escaped === "k" && re.source.charAt(i + 1) === "<") {
+				const end = re.source.indexOf(">", i + 2);
+				if (end !== -1) {
+					result += re.source.slice(i - 1, end + 1);
+					i = end;
+					continue;
+				}
+			}
+			result += "\\" + escaped;
+			continue;
+		}
+		if (re.source.startsWith("(?<", i) && !"=!".includes(re.source.charAt(i + 3))) {
+			const end = re.source.indexOf(">", i + 3);
+			if (end !== -1) {
+				result += re.source.slice(i, end + 1);
+				i = end;
+				continue;
+			}
+		}
+		if (char !== "[") {
+			const code = re.source.codePointAt(i);
+			if (code !== void 0 && code >= 128) {
+				const literal = String.fromCodePoint(code);
+				result += legacyLiteralPattern(literal);
+				i += literal.length - 1;
+			} else result += /[a-z]/i.test(char) ? legacyLiteralPattern(char) : char;
+			continue;
+		}
+		const start = i;
+		while (++i < re.source.length) {
+			const member = re.source.charAt(i);
+			if (member === "]") break;
+			if (member !== "\\") continue;
+			i++;
+		}
+		const original = re.source.slice(start, i + 1);
+		let normalized = "";
+		let previousShortcut = false;
+		for (let j = 0; j < original.length; j++) {
+			const member = original.charAt(j);
+			if (member === "\\") {
+				const escaped = original.charAt(++j);
+				normalized += "\\" + escaped;
+				previousShortcut = "sSwWdD".includes(escaped);
+				continue;
+			}
+			const nextShortcut = original.charAt(j + 1) === "\\" && "sSwWdD".includes(original.charAt(j + 2));
+			normalized += member === "-" && (previousShortcut || nextShortcut) ? "\\-" : member;
+			previousShortcut = false;
+		}
+		const classRegexp = new RegExp(normalized, "i");
+		const escapedNonAscii = [...normalized.matchAll(/\\(?:x([\da-f]{2})|u([\da-f]{4}))/gi)].some((match) => Number.parseInt(match[1] ?? match[2] ?? "0", 16) >= 128);
+		const body = original.slice(original.startsWith("[^") ? 2 : 1, -1);
+		const positive = new RegExp(`[${body}]`, "i");
+		let folds = "";
+		for (const letter of "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") if (positive.test(letter)) folds += letter;
+		if (hasNonAscii(original) || escapedNonAscii) {
+			for (const [canonical, members] of getLegacyUnicodeFolds()) if (positive.test(canonical)) folds += members.join("");
+		}
+		const translated = javascriptCharacterClasses(classRegexp);
+		result += `(?-i:${translated.slice(0, -1)}${folds}])`;
+	}
+	return result;
+}
+/**
+* Check if content uses character class shortcuts
+* (\w, \W, \d, \D, \s, \S, \b, \B) that have
+* Unicode-aware versions. Only these benefit from
+* -u (ASCII-only mode). Literal strings like
+* "dollars" produce identical DFAs with or without
+* -u, so skipping -u for them is zero-cost.
+*/
+function needsAsciiMode(s) {
+	for (let i = 0; i < s.length; i++) {
+		if (s.charAt(i) !== "\\") continue;
+		const escaped = s.charAt(++i);
+		if ("wWdDsSbB".includes(escaped)) return true;
+	}
+	return false;
+}
+/**
+* Check if a string contains non-ASCII characters.
+* When true, -u MUST NOT be added: regex-automata
+* rejects (?-u) alongside non-ASCII content like
+* [ACDE] or literal zlotych.
+*/
+function hasNonAscii(s) {
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) > 127) return true;
+	return false;
+}
+/**
+* Convert inline (?i) flags to (?i-u) for ASCII
+* case folding. Handles bare and scoped groups.
+*
+* Bare (?i) at the start of a pattern is converted
+* to a scoped group (?i-u:...) with edge \b pulled
+* outside, matching the RegExp path behaviour. This
+* prevents -u from affecting \b word boundary
+* semantics (which should remain Unicode when
+* unicodeBoundaries is true).
+*
+* NOTE: -u also disables Unicode character classes
+* (\w, \d, \s become ASCII-only), matching the
+* behaviour of regexpToRust() for non-Unicode /i RegExps.
+*/
+function scopeInlineFlags(src) {
+	const leadingBare = src.match(/^\(\?([ims]+)(?:-([imsu]+))?\)/);
+	const enableGroup = leadingBare?.[1];
+	if (leadingBare && enableGroup?.includes("i")) {
+		const enable = enableGroup;
+		const disable = leadingBare[2] ?? "";
+		let rest = src.slice(leadingBare[0].length);
+		let leading = "";
+		let trailing = "";
+		if (rest.startsWith("\\b")) {
+			leading = "\\b";
+			rest = rest.slice(2);
+		} else if (rest.startsWith("\\B")) {
+			leading = "\\B";
+			rest = rest.slice(2);
+		}
+		if (rest.length >= 2) {
+			const last = rest.at(-1);
+			if (last === "b" || last === "B") {
+				let bs = 0;
+				let k = rest.length - 2;
+				while (k >= 0 && rest[k] === "\\") {
+					bs++;
+					k--;
+				}
+				if (bs > 0 && bs % 2 === 1) {
+					trailing = "\\" + last;
+					rest = rest.slice(0, -2);
+				}
+			}
+		}
+		const inner = scopeInnerFlags(rest);
+		const merged = needsAsciiMode(rest) && !hasNonAscii(rest) && !disable.includes("u") ? disable + "u" : disable;
+		const disablePart = merged ? `-${merged}` : "";
+		return `${leading}(?${enable}${disablePart}:${inner})${trailing}`;
+	}
+	return scopeInnerFlags(src);
+}
+/**
+* Replace inline (?i) / (?i:...) groups with -u
+* variants. Does not handle leading bare flags
+* (that's done by scopeInlineFlags above).
+*/
+function scopeInnerFlags(src) {
+	let result = "";
+	let inClass = false;
+	let i = 0;
+	while (i < src.length) {
+		if (src[i] === "\\" && i + 1 < src.length) {
+			result += src.charAt(i) + src.charAt(i + 1);
+			i += 2;
+			continue;
+		}
+		if (src.charAt(i) === "[") inClass = true;
+		if (src.charAt(i) === "]") inClass = false;
+		if (!inClass && src.charAt(i) === "(" && src.charAt(i + 1) === "?") {
+			let j = i + 2;
+			let enable = "";
+			while (j < src.length && "ims".includes(src.charAt(j))) {
+				enable += src.charAt(j);
+				j++;
+			}
+			let disable = "";
+			if (j < src.length && src.charAt(j) === "-") {
+				j++;
+				while (j < src.length && "imsu".includes(src.charAt(j))) {
+					disable += src.charAt(j);
+					j++;
+				}
+			}
+			if (enable.length > 0 && (src.charAt(j) === ")" || src.charAt(j) === ":")) {
+				if (enable.includes("i")) {
+					if (disable.length > 0) result += `(?${enable}-${disable}${src.charAt(j)}`;
+					else result += `(?${enable}${src.charAt(j)}`;
+				} else if (disable.length > 0) result += `(?${enable}-${disable}${src.charAt(j)}`;
+				else result += `(?${enable}${src.charAt(j)}`;
+				i = j + 1;
+				continue;
+			}
+		}
+		result += src.charAt(i);
+		i++;
+	}
+	return result;
+}
+/**
+* Normalize a pattern entry to { pattern, name }.
+*/
+function normalizeEntry(p, i) {
+	if (typeof p === "string") return {
+		pattern: scopeInlineFlags(p),
+		name: void 0
+	};
+	if (p instanceof RegExp) return {
+		pattern: regexpToRust(p),
+		name: void 0
+	};
+	if (typeof p !== "object" || p === null || !("pattern" in p)) throw new TypeError(`Pattern at index ${i} must be a string, RegExp, or { pattern, name }`);
+	const pattern = p.pattern;
+	if (typeof pattern !== "string" && !(pattern instanceof RegExp)) throw new TypeError(`Pattern at index ${i}: "pattern" field must be a string or RegExp`);
+	const name = "name" in p ? p.name : void 0;
+	if (name !== void 0 && typeof name !== "string") throw new TypeError(`Pattern at index ${i}: "name" field must be a string`);
+	return {
+		pattern: pattern instanceof RegExp ? regexpToRust(pattern) : scopeInlineFlags(pattern),
+		name
+	};
+}
+function expandLargeAlternation(pattern) {
+	const group = findLargestChunkableAlternation(pattern);
+	if (!group) return [pattern];
+	if (group.branches.length < ALTERNATION_CHUNK_MIN_BRANCHES) return [pattern];
+	const expanded = [];
+	for (let i = 0; i < group.branches.length; i += ALTERNATION_CHUNK_SIZE) expanded.push(pattern.slice(0, group.bodyStart) + group.branches.slice(i, i + ALTERNATION_CHUNK_SIZE).join("|") + pattern.slice(group.bodyEnd));
+	return expanded;
+}
+function findLargestChunkableAlternation(pattern) {
+	let best;
+	let inClass = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern.charAt(i);
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			inClass = true;
+			continue;
+		}
+		if (ch === "]") {
+			inClass = false;
+			continue;
+		}
+		if (inClass || ch !== "(" || pattern.charAt(i + 1) !== "?" || pattern.charAt(i + 2) !== ":") continue;
+		const bodyStart = i + 3;
+		const bodyEnd = findGroupEnd(pattern, bodyStart);
+		if (bodyEnd === void 0) continue;
+		const branches = splitTopLevelAlternatives(pattern.slice(bodyStart, bodyEnd));
+		if (bodyStart <= ALTERNATION_CHUNK_MAX_BODY_START && branches.length >= ALTERNATION_CHUNK_MIN_BRANCHES && pattern.slice(bodyStart, bodyEnd).includes("(?i:") && (!best || branches.length > best.branches.length)) best = {
+			bodyStart,
+			bodyEnd,
+			branches
+		};
+	}
+	return best;
+}
+function findGroupEnd(pattern, bodyStart) {
+	let depth = 0;
+	let inClass = false;
+	for (let i = bodyStart; i < pattern.length; i++) {
+		const ch = pattern.charAt(i);
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			inClass = true;
+			continue;
+		}
+		if (ch === "]") {
+			inClass = false;
+			continue;
+		}
+		if (inClass) continue;
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch !== ")") continue;
+		if (depth === 0) return i;
+		depth--;
+	}
+}
+function splitTopLevelAlternatives(body) {
+	const branches = [];
+	let depth = 0;
+	let inClass = false;
+	let start = 0;
+	for (let i = 0; i < body.length; i++) {
+		const ch = body.charAt(i);
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			inClass = true;
+			continue;
+		}
+		if (ch === "]") {
+			inClass = false;
+			continue;
+		}
+		if (inClass) continue;
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			continue;
+		}
+		if (ch === "|" && depth === 0) {
+			branches.push(body.slice(start, i));
+			start = i + 1;
+		}
+	}
+	branches.push(body.slice(start));
+	return branches;
+}
+function buildNativeInput(patterns, options) {
+	const entries = patterns.map(normalizeEntry);
+	const names = entries.map((e) => e.name);
+	const unicode = options?.unicodeBoundaries ?? true;
+	const wholeWords = options?.wholeWords ?? false;
+	const ci = options?.caseInsensitive ?? false;
+	let processed = entries.map((e) => e.pattern);
+	if (ci) processed = processed.map(caseInsensitivePattern);
+	if (!unicode) processed = processed.map(asciiBoundaries);
+	const nativeOpts = options ? {
+		...options.wholeWords !== void 0 ? { wholeWords: options.wholeWords } : {},
+		...options.unicodeBoundaries !== void 0 ? { unicodeBoundaries: options.unicodeBoundaries } : {}
+	} : void 0;
+	const nativePatterns = [];
+	const nativeIndexMap = [];
+	const jsFallbacks = [];
+	for (let i = 0; i < processed.length; i++) {
+		const pattern = processed[i];
+		if (pattern === void 0) throw new Error(`Missing processed pattern ${i}`);
+		const expanded = expandLargeAlternation(pattern);
+		for (const expandedPattern of expanded) {
+			const jsFallback = jsFallbackRegExp(expandedPattern, unicode);
+			if (jsFallback) jsFallbacks.push({
+				pattern: i,
+				re: jsFallback
+			});
+			else {
+				nativeIndexMap.push(i);
+				nativePatterns.push(expandedPattern);
+			}
+		}
+	}
+	return {
+		names,
+		hasNames: entries.some((e) => e.name !== void 0),
+		patternCount: entries.length,
+		nativePatterns,
+		nativeOpts,
+		nativeIndexMap,
+		jsFallbacks,
+		boundaryOptions: {
+			wholeWords,
+			unicodeBoundaries: unicode
+		}
+	};
+}
+function caseInsensitivePattern(p) {
+	if (/^(?:\\[bB]|\(\?[ims]+(?:-[imsu]+)?\))*\(\?[ims]*i[ims]*(?:-[imsu]+)?[:(]/.test(p)) return p;
+	let src = p;
+	let flagPrefix = "";
+	const bareFlagMatch = src.match(/^\(\?[ims]+(?:-[imsu]+)?\)/);
+	if (bareFlagMatch) {
+		flagPrefix = bareFlagMatch[0];
+		src = src.slice(flagPrefix.length);
+	}
+	let leading = "";
+	let trailing = "";
+	if (src.startsWith("\\b")) {
+		leading = "\\b";
+		src = src.slice(2);
+	} else if (src.startsWith("\\B")) {
+		leading = "\\B";
+		src = src.slice(2);
+	}
+	if (src.length >= 2) {
+		const last = src.at(-1);
+		if (last === "b" || last === "B") {
+			let bs = 0;
+			let k = src.length - 2;
+			while (k >= 0 && src[k] === "\\") {
+				bs++;
+				k--;
+			}
+			if (bs > 0 && bs % 2 === 1) {
+				trailing = "\\" + last;
+				src = src.slice(0, -2);
+			}
+		}
+	}
+	const uFlag = needsAsciiMode(src) && !hasNonAscii(src) ? "-u" : "";
+	return `${flagPrefix}${leading}(?i${uFlag}:${src})${trailing}`;
+}
+/**
+* Multi-pattern regex matcher.
+*
+* Compiles multiple regex patterns into a single
+* automaton for the main matching path. Standard
+* scans use Rust's DFA engine without catastrophic
+* backtracking. Some lookaround cases may use a
+* targeted fallback verifier to preserve
+* correctness. Uses Rust regex syntax for string
+* patterns (no lookaheads/backreferences).
+*
+* @example
+* ```ts
+* // Simple
+* new RegexSet([/\d{8}/, "\\+?\\d{9,12}"]);
+*
+* // Named
+* new RegexSet([
+*   { pattern: /\d{8}/, name: "ico" },
+*   { pattern: /\d{2}\.\d{2}\.\d{4}/, name: "date" },
+* ]);
+* // match.name === "date"
+* ```
+*/
+var RegexSet = class {
+	_inner;
+	_names;
+	_hasNames;
+	_patternCount;
+	_nativeIndexMap;
+	_jsFallbacks;
+	_nativeSingles;
+	_boundaryOptions;
+	constructor(patterns, options, prepared) {
+		const nativeInput = buildNativeInput(patterns, options);
+		this._names = nativeInput.names;
+		this._hasNames = nativeInput.hasNames;
+		this._patternCount = nativeInput.patternCount;
+		this._boundaryOptions = nativeInput.boundaryOptions;
+		this._nativeIndexMap = nativeInput.nativeIndexMap;
+		this._jsFallbacks = nativeInput.jsFallbacks;
+		this._nativeSingles = [];
+		this._inner = new binding.RegexSet(nativeInput.nativePatterns, nativeInput.nativeOpts, prepared);
+		if (this._jsFallbacks.length > 0) this._nativeSingles = nativeInput.nativePatterns.map((pattern, i) => {
+			const original = this._nativeIndexMap[i];
+			if (original === void 0) throw new Error(`Missing native index map ${i}`);
+			return {
+				pattern: original,
+				inner: new binding.RegexSet([pattern], nativeInput.nativeOpts)
+			};
+		});
+	}
+	static prepare(patterns, options) {
+		const nativeInput = buildNativeInput(patterns, options);
+		return binding._prepareRegexSet(nativeInput.nativePatterns, nativeInput.nativeOpts);
+	}
+	/** Number of patterns. */
+	get patternCount() {
+		return this._patternCount;
+	}
+	/** Internal diagnostics: fast DFA, verified DFA, and fallback pattern counts. */
+	_enginePathCounts() {
+		return [...this._inner._enginePathCounts()];
+	}
+	/** Returns `true` if any pattern matches. */
+	isMatch(haystack) {
+		if (this._inner._isMatchBuf(encoder$1.encode(haystack))) return true;
+		for (const fb of this._jsFallbacks) if (this.findFirstJsFallback(haystack, fb)) return true;
+		return false;
+	}
+	/** Find all non-overlapping matches. */
+	findIter(haystack) {
+		if (this._jsFallbacks.length > 0) return selectNonOverlapping(this.findNativeSingles(haystack).concat(this.findJsFallbacks(haystack)));
+		return unpack(this._inner._findIterPackedBuf(encoder$1.encode(haystack)), haystack, this._hasNames ? this._names : null, this._nativeIndexMap);
+	}
+	/** Which pattern indices matched (not where). */
+	whichMatch(haystack) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const pattern of this._inner.whichMatch(haystack)) {
+			const original = this._nativeIndexMap[pattern];
+			if (original === void 0) throw new Error(`Missing native index map ${pattern}`);
+			seen.add(original);
+		}
+		for (const fb of this._jsFallbacks) if (this.findFirstJsFallback(haystack, fb)) seen.add(fb.pattern);
+		return [...seen];
+	}
+	/**
+	* Replace all non-overlapping matches.
+	* `replacements[i]` replaces pattern `i`.
+	*/
+	replaceAll(haystack, replacements) {
+		if (this._jsFallbacks.length === 0 && this._nativeIndexMap.length === this._patternCount && this._nativeIndexMap.every((idx, i) => idx === i)) return this._inner.replaceAll(haystack, replacements);
+		if (replacements.length !== this._patternCount) throw new Error(`Expected ${this._patternCount} replacements, got ${replacements.length}`);
+		const matches = this.findIter(haystack);
+		let result = "";
+		let last = 0;
+		for (const m of matches) {
+			result += haystack.slice(last, m.start);
+			const replacement = replacements[m.pattern];
+			if (replacement === void 0) throw new Error(`Missing replacement for pattern ${m.pattern}`);
+			result += replacement;
+			last = m.end;
+		}
+		result += haystack.slice(last);
+		return result;
+	}
+	findJsFallbacks(haystack) {
+		const matches = [];
+		for (const fb of this._jsFallbacks) {
+			fb.re.lastIndex = 0;
+			for (;;) {
+				const m = fb.re.exec(haystack);
+				if (!m) break;
+				const text = m[0];
+				const start = m.index;
+				const end = start + text.length;
+				if (this.acceptJsFallbackMatch(haystack, start, end)) {
+					const match = {
+						pattern: fb.pattern,
+						start,
+						end,
+						text
+					};
+					const name = this._names[fb.pattern];
+					if (name !== void 0) match.name = name;
+					matches.push(match);
+					if (text.length === 0) fb.re.lastIndex = nextRegexStart(haystack, start);
+				} else fb.re.lastIndex = nextRegexStart(haystack, start);
+			}
+		}
+		return matches;
+	}
+	findNativeSingles(haystack) {
+		const encoded = encoder$1.encode(haystack);
+		const matches = [];
+		for (const single of this._nativeSingles) matches.push(...unpack(single.inner._findIterPackedBuf(encoded), haystack, this._hasNames ? this._names : null, [single.pattern]));
+		return matches;
+	}
+	findFirstJsFallback(haystack, fb) {
+		fb.re.lastIndex = 0;
+		for (;;) {
+			const m = fb.re.exec(haystack);
+			if (!m) return false;
+			const text = m[0];
+			const start = m.index;
+			const end = start + text.length;
+			if (this.acceptJsFallbackMatch(haystack, start, end)) return true;
+			fb.re.lastIndex = nextRegexStart(haystack, start);
+		}
+	}
+	acceptJsFallbackMatch(haystack, start, end) {
+		if (!this._boundaryOptions.wholeWords) return true;
+		return isWordBoundary(haystack, start, this._boundaryOptions.unicodeBoundaries) && isWordBoundary(haystack, end, this._boundaryOptions.unicodeBoundaries);
+	}
+};
+function jsFallbackRegExp(pattern, unicodeBoundaries) {
+	if (!hasLookaround(pattern) || unicodeBoundaries && hasRegexWordBoundary(pattern) || hasRustUnicodeShorthand(pattern) || hasRustClassSetOperation(pattern) || countAlternations(pattern) < 128) return;
+	try {
+		return new RegExp(pattern, "gu");
+	} catch {
+		return;
+	}
+}
+function hasLookaround(pattern) {
+	return pattern.includes("(?=") || pattern.includes("(?!") || pattern.includes("(?<=") || pattern.includes("(?<!");
+}
+function countAlternations(pattern) {
+	let count = 0;
+	let inClass = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === "[") inClass = true;
+		else if (ch === "]") inClass = false;
+		else if (ch === "|" && !inClass) count++;
+	}
+	return count;
+}
+function hasRegexWordBoundary(pattern) {
+	let inClass = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\") {
+			const next = pattern[i + 1];
+			if (!inClass && (next === "b" || next === "B")) return true;
+			i++;
+			continue;
+		}
+		if (ch === "[") inClass = true;
+		else if (ch === "]") inClass = false;
+	}
+	return false;
+}
+function hasRustUnicodeShorthand(pattern) {
+	for (let i = 0; i < pattern.length; i++) {
+		if (pattern[i] !== "\\") continue;
+		const next = pattern[i + 1];
+		if (next === "d" || next === "D" || next === "w" || next === "W" || next === "s" || next === "S") return true;
+		i++;
+	}
+	return false;
+}
+function hasRustClassSetOperation(pattern) {
+	let inClass = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			inClass = true;
+			continue;
+		}
+		if (ch === "]") {
+			inClass = false;
+			continue;
+		}
+		if (inClass && i + 1 < pattern.length && (ch === "&" && pattern[i + 1] === "&" || ch === "-" && pattern[i + 1] === "-" || ch === "~" && pattern[i + 1] === "~")) return true;
+	}
+	return false;
+}
+function nextRegexStart(text, index) {
+	if (index >= text.length) return index + 1;
+	const first = text.charCodeAt(index);
+	if (first >= 55296 && first <= 56319 && index + 1 < text.length) {
+		const second = text.charCodeAt(index + 1);
+		if (second >= 56320 && second <= 57343) return index + 2;
+	}
+	return index + 1;
+}
+function selectNonOverlapping(matches) {
+	if (matches.length <= 1) return matches;
+	matches.sort((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		const lengthOrder = b.end - b.start - (a.end - a.start);
+		if (lengthOrder !== 0) return lengthOrder;
+		return a.pattern - b.pattern;
+	});
+	const selected = [];
+	let lastEnd = 0;
+	for (const m of matches) if (m.start >= lastEnd) {
+		selected.push(m);
+		lastEnd = m.end;
+	}
+	return selected;
+}
+function isWordBoundary(text, pos, unicode) {
+	const before = previousCodePoint(text, pos);
+	const after = nextCodePoint(text, pos);
+	return isWordChar(before, unicode) !== isWordChar(after, unicode);
+}
+function previousCodePoint(text, pos) {
+	if (pos <= 0) return void 0;
+	return Array.from(text.slice(0, pos)).at(-1);
+}
+function nextCodePoint(text, pos) {
+	if (pos >= text.length) return void 0;
+	const cp = text.codePointAt(pos);
+	return cp === void 0 ? void 0 : String.fromCodePoint(cp);
+}
+function isWordChar(ch, unicode) {
+	if (ch === void 0) return false;
+	return unicode ? /^[\p{Alphabetic}\p{Number}_]$/u.test(ch) : /^[A-Za-z0-9_]$/.test(ch);
+}
+//#endregion
+//#region src/single-thread-binding.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/gu;
+const REINITIALIZE = "The single-thread WebAssembly instance trapped; call init() or initSync() again";
+const napiString = (value) => value.replaceAll(LONE_SURROGATE, "�");
+const createSingleThreadBinding = (wasm, onTrap) => {
+	let trapped = false;
+	const request = (body) => {
+		if (trapped) throw new Error(REINITIALIZE);
+		const bytes = encoder.encode(JSON.stringify(body, (_key, value) => typeof value === "string" ? napiString(value) : value));
+		try {
+			const pointer = wasm.alloc(bytes.length);
+			new Uint8Array(wasm.memory.buffer, pointer, bytes.length).set(bytes);
+			wasm.dispatch(pointer, bytes.length);
+			const output = new Uint8Array(wasm.memory.buffer, wasm.output_pointer(), wasm.output_length());
+			const reply = JSON.parse(decoder.decode(output));
+			if (!reply.ok) throw new Error(reply.error ?? "WASM operation failed");
+			return reply.value;
+		} catch (error) {
+			if (error instanceof WebAssembly.RuntimeError) {
+				trapped = true;
+				onTrap();
+			}
+			throw error;
+		}
+	};
+	const numbers = (value) => {
+		if (!Array.isArray(value) || !value.every(Number.isInteger)) throw new TypeError("Invalid numeric response from single-thread WebAssembly");
+		return value;
+	};
+	const bytes = (value) => [...value];
+	const options = (opts) => ({
+		whole_words: opts?.wholeWords ?? false,
+		unicode_boundaries: opts?.unicodeBoundaries ?? true
+	});
+	class WasmRegexSet {
+		handle;
+		patternCount;
+		constructor(patterns, opts, prepared) {
+			this.patternCount = patterns.length;
+			const value = request({
+				op: "create",
+				patterns,
+				...options(opts),
+				prepared: prepared ? bytes(prepared) : null
+			});
+			if (!Number.isInteger(value)) throw new TypeError("Invalid matcher handle from single-thread WebAssembly");
+			this.handle = Number(value);
+			finalizers.register(this, this.handle);
+		}
+		_enginePathCounts() {
+			return Uint32Array.from(numbers(request({
+				op: "counts",
+				handle: this.handle
+			})));
+		}
+		isMatch(haystack) {
+			return Boolean(request({
+				op: "is_match",
+				handle: this.handle,
+				haystack
+			}));
+		}
+		_isMatchBuf(haystack) {
+			return Boolean(request({
+				op: "is_match_buf",
+				handle: this.handle,
+				haystack: bytes(haystack)
+			}));
+		}
+		_findIterPacked(haystack) {
+			return Uint32Array.from(numbers(request({
+				op: "find",
+				handle: this.handle,
+				haystack
+			})));
+		}
+		_findIterPackedBuf(haystack) {
+			return Uint32Array.from(numbers(request({
+				op: "find_buf",
+				handle: this.handle,
+				haystack: bytes(haystack)
+			})));
+		}
+		whichMatch(haystack) {
+			return numbers(request({
+				op: "which",
+				handle: this.handle,
+				haystack
+			}));
+		}
+		replaceAll(haystack, replacements) {
+			const value = request({
+				op: "replace",
+				handle: this.handle,
+				haystack,
+				replacements
+			});
+			if (typeof value !== "string") throw new TypeError("Invalid replacement response from single-thread WebAssembly");
+			return value;
+		}
+	}
+	const finalizers = new FinalizationRegistry((handle) => {
+		if (!trapped) request({
+			op: "free",
+			handle
+		});
+	});
+	return {
+		RegexSet: WasmRegexSet,
+		_prepareRegexSet(patterns, opts) {
+			return Uint8Array.from(numbers(request({
+				op: "prepare",
+				patterns,
+				...options(opts)
+			})));
+		},
+		_uax29Boundaries(haystack) {
+			return numbers(request({
+				op: "boundaries",
+				haystack: bytes(haystack)
+			}));
+		}
+	};
+};
+//#endregion
+//#region src/single-thread-runtime.ts
+const isWasmExports = (value) => value["memory"] instanceof WebAssembly.Memory && typeof value["alloc"] === "function" && typeof value["dispatch"] === "function" && typeof value["output_pointer"] === "function" && typeof value["output_length"] === "function";
+const requireWasmExports = (instance) => {
+	if (!isWasmExports(instance.exports)) throw new TypeError("Invalid single-thread WebAssembly exports: expected memory and alloc, dispatch, output_pointer, and output_length functions");
+	return instance.exports;
+};
+//#endregion
+//#region src/single-thread.ts
+let generation = 0;
+const install = (instance) => {
+	const current = ++generation;
+	initBinding(createSingleThreadBinding(requireWasmExports(instance), () => {
+		if (generation === current) generation++;
+	}));
+};
+const isBufferSource = (source) => Object.prototype.toString.call(source) === "[object ArrayBuffer]" || ArrayBuffer.isView(source);
+const isResponse = (source) => typeof source === "object" && "arrayBuffer" in source && "ok" in source && "status" in source;
+const initSync = (source) => {
+	install(new WebAssembly.Instance(new WebAssembly.Module(source), {}));
+};
+const init = async (source) => {
+	let bytes;
+	if (isBufferSource(source)) bytes = source;
+	else if (isResponse(source)) {
+		if (!source.ok) throw new Error(`Unable to load WebAssembly: HTTP ${source.status}`);
+		bytes = await source.arrayBuffer();
+	} else {
+		const response = await fetch(source);
+		if (!response.ok) throw new Error(`Unable to load WebAssembly: HTTP ${response.status}`);
+		bytes = await response.arrayBuffer();
+	}
+	const result = await WebAssembly.instantiate(bytes, {});
+	install(result.instance);
+};
+//#endregion
+export { RegexSet, init, initSync };
+
+//# sourceMappingURL=single-thread.mjs.map