@stll/regex-set-wasm 1.0.8 → 1.1.0

package/dist/wasm.mjs

@@ -1,5 +1,5 @@
-import { WASI, emnapiAsyncWorkPlugin, emnapiTSFNPlugin, instantiateNapiModule } from "@napi-rs/wasm-runtime";
 import { createContext } from "@emnapi/runtime";
+import { WASI, emnapiAsyncWorkPlugin, emnapiTSFNPlugin, instantiateNapiModule } from "@napi-rs/wasm-runtime";
 //#region regex-set.wasi-browser.js
 const __napiBindingTarget = "wasm32-wasi";
 function __napiStampBindingTarget(exportsObject, target) {
@@ -60,6 +60,54 @@ let __emnapiWasmEnvCleanupDrainPromise;
 let __wasiDisposed = false;
 let __wasiAsyncWorkDrainPromise;
 let __wasiDisposePromise;
+let __wasiThreadCrashDisposePromise;
+let __wasiInitializationRollbackActive = false;
+let __wasiThreadCrashed = false;
+let __wasiThreadCrashWorkerError;
+function __recordWasiThreadCrashError(error) {
+	__wasiThreadCrashed = true;
+	if (__wasiThreadCrashWorkerError === void 0 && error !== void 0) __wasiThreadCrashWorkerError = error;
+}
+function __hasWasiThreadCrashed() {
+	if (__wasiThreadCrashed || __wasiAddonCrashFlag !== void 0 && Atomics.load(__wasiAddonCrashFlag, 0) !== 0) return true;
+	const manager = typeof __getWasiThreadManager === "function" ? __getWasiThreadManager() : void 0;
+	return Boolean(manager && manager._fatalError);
+}
+function __getWasiThreadCrashError() {
+	const error = /* @__PURE__ */ new Error("napi-rs: WASI binding cannot be disposed after a worker thread crashed");
+	const manager = typeof __getWasiThreadManager === "function" ? __getWasiThreadManager() : void 0;
+	const cause = __wasiThreadCrashWorkerError ?? (manager ? manager._fatalError : void 0);
+	if (cause !== void 0 && cause !== null) error.cause = cause;
+	return error;
+}
+function __disposeWasiBindingAfterThreadCrash() {
+	if (__wasiThreadCrashDisposePromise) return __wasiThreadCrashDisposePromise;
+	let workerResult;
+	try {
+		workerResult = __terminateWasiWorkers();
+	} catch (error) {
+		workerResult = Promise.reject(error);
+	}
+	__wasiThreadCrashDisposePromise = Promise.resolve(workerResult).then(() => {
+		throw __getWasiThreadCrashError();
+	}, (error) => {
+		throw error;
+	});
+	return __wasiThreadCrashDisposePromise;
+}
+function __abortWasiDisposalIfThreadCrashed() {
+	if ((__wasiDisposePromise !== void 0 || __wasiInitializationRollbackActive) && __hasWasiThreadCrashed()) throw __getWasiThreadCrashError();
+}
+function __settleWasiDisposalAfterThreadCrash(resolve, reject) {
+	if (!__hasWasiThreadCrashed()) return false;
+	__disposeWasiBindingAfterThreadCrash().then(resolve, reject);
+	return true;
+}
+function __rollbackWasiInitializationAfterThreadCrash() {
+	const crashError = __getWasiThreadCrashError();
+	__disposeWasiBindingAfterThreadCrash().catch(() => {});
+	return [crashError];
+}
 let __completeWasiDisposal = function() {};
 function __isThenable(value) {
 	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
@@ -111,6 +159,7 @@ function __wrapEmnapiContextDestroyForSettlement(context, prepareEnvCleanup, isP
 			enumerable: false,
 			writable: true,
 			value: function() {
+				__abortWasiDisposalIfThreadCrashed();
 				if (isPreparingEnvCleanup?.()) return;
 				prepareEnvCleanup?.();
 				return Reflect.apply(destroy, this, arguments);
@@ -123,6 +172,7 @@ function __isPreparingWasmEnvCleanup() {
 	return __emnapiWasmEnvCleanupPreparing;
 }
 function __prepareWasmEnvCleanup() {
+	__abortWasiDisposalIfThreadCrashed();
 	if (__emnapiWasmEnvCleanupPrepared) return;
 	const finishParked = __finishParkedWasmEnvCleanup;
 	if (finishParked !== void 0) {
@@ -388,6 +438,7 @@ function __prepareWasmEnvCleanupWithTurns() {
 	__emnapiWasmEnvCleanupPreparing = true;
 	let live;
 	try {
+		__abortWasiDisposalIfThreadCrashed();
 		live = begin();
 	} catch (error) {
 		__emnapiWasmEnvCleanupPreparing = false;
@@ -395,6 +446,7 @@ function __prepareWasmEnvCleanupWithTurns() {
 	}
 	__emnapiWasmEnvCleanupRan = true;
 	const finishCleanup = () => {
+		__abortWasiDisposalIfThreadCrashed();
 		if (__emnapiWasmEnvCleanupPrepared) return;
 		__finishParkedWasmEnvCleanup = void 0;
 		try {
@@ -409,17 +461,27 @@ function __prepareWasmEnvCleanupWithTurns() {
 		return;
 	}
 	__finishParkedWasmEnvCleanup = finishCleanup;
+	const finishCleanupUnlessCrashed = () => {
+		try {
+			__abortWasiDisposalIfThreadCrashed();
+		} catch (error) {
+			__finishParkedWasmEnvCleanup = void 0;
+			throw error;
+		}
+		finishCleanup();
+	};
 	return (async () => {
 		const pace = __createWasmRuntimePollPace();
 		for (;;) {
 			await __yieldWasmRuntimePollTurn(pace);
+			__abortWasiDisposalIfThreadCrashed();
 			try {
 				if (!workPending()) return;
 			} catch {
 				return;
 			}
 		}
-	})().then(finishCleanup, finishCleanup);
+	})().then(finishCleanupUnlessCrashed, finishCleanupUnlessCrashed);
 }
 const __WASM_ENV_CLEANUP_DRAIN_TURNS = 128;
 const __WASM_ENV_CLEANUP_BLIND_DRAIN_TURNS = 4;
@@ -500,6 +562,7 @@ function __drainWasmEnvCleanup() {
 	return drainPromise;
 }
 function __destroyEmnapiContext() {
+	__abortWasiDisposalIfThreadCrashed();
 	if (__emnapiContextDestroyed || __emnapiContext === void 0) {
 		__emnapiContextDestroyed = true;
 		return;
@@ -692,16 +755,19 @@ function __finishWasiDisposal() {
 	if (__isThenable(workerResult)) return Promise.resolve(workerResult).then(__completeWasiDisposal);
 }
 function __continueWasiDisposal() {
+	__abortWasiDisposalIfThreadCrashed();
 	const destroyResult = __destroyEmnapiContext();
 	if (__isThenable(destroyResult)) return Promise.resolve(destroyResult).then(__finishWasiDisposal);
 	return __finishWasiDisposal();
 }
 function __drainWasmEnvForWasiDisposal() {
+	__abortWasiDisposalIfThreadCrashed();
 	const drainResult = __drainWasmEnvCleanup();
 	if (__isThenable(drainResult)) return Promise.resolve(drainResult).then(__continueWasiDisposal);
 	return __continueWasiDisposal();
 }
 function __cleanUpWasmEnvForWasiDisposal() {
+	__abortWasiDisposalIfThreadCrashed();
 	const prepareResult = __prepareWasmEnvCleanupWithTurns();
 	if (__isThenable(prepareResult)) return Promise.resolve(prepareResult).then(__drainWasmEnvForWasiDisposal);
 	return __drainWasmEnvForWasiDisposal();
@@ -719,6 +785,7 @@ function __startWasiDisposal() {
 */
 function __disposeWasiBinding() {
 	if (__wasiDisposePromise) return __wasiDisposePromise;
+	if (!__wasiDisposed && __hasWasiThreadCrashed()) return __disposeWasiBindingAfterThreadCrash();
 	if (__wasiDisposed) return Promise.resolve();
 	let resolveDispose;
 	let rejectDispose;
@@ -731,6 +798,7 @@ function __disposeWasiBinding() {
 	try {
 		result = __startWasiDisposal();
 	} catch (error) {
+		if (__settleWasiDisposalAfterThreadCrash(resolveDispose, rejectDispose)) return disposePromise;
 		__wasiDisposePromise = void 0;
 		rejectDispose(error);
 		return disposePromise;
@@ -739,6 +807,7 @@ function __disposeWasiBinding() {
 		__wasiDisposed = true;
 		resolveDispose(value);
 	}, (error) => {
+		if (__settleWasiDisposalAfterThreadCrash(resolveDispose, rejectDispose)) return;
 		__wasiDisposePromise = void 0;
 		rejectDispose(error);
 	});
@@ -766,6 +835,7 @@ function __finishWasiInitializationRollback(cleanupErrors) {
 	return cleanupErrors;
 }
 function __destroyContextForWasiRollback(cleanupErrors) {
+	__abortWasiDisposalIfThreadCrashed();
 	let destroyResult;
 	try {
 		destroyResult = __destroyEmnapiContext();
@@ -823,8 +893,9 @@ function __retainFailedWasiRollback(cleanupErrors) {
 * goes away. That is the deliberate choice: a hung promise is a silent liveness
 * bug with no upper bound, while the retained bookkeeping is bounded by the page.
 */
-function __rollbackWasiInitialization() {
+function __runWasiInitializationRollbackSteps() {
 	function __rollbackWasmEnvForWasiInitialization() {
+		__abortWasiDisposalIfThreadCrashed();
 		const cleanupErrors = [];
 		let prepareResult;
 		try {
@@ -840,6 +911,7 @@ function __rollbackWasiInitialization() {
 		return __drainWasmEnvForWasiRollback(cleanupErrors);
 	}
 	function __drainWasmEnvForWasiRollback(cleanupErrors) {
+		__abortWasiDisposalIfThreadCrashed();
 		let drainResult;
 		try {
 			drainResult = __drainWasmEnvCleanup();
@@ -863,6 +935,30 @@ function __rollbackWasiInitialization() {
 	if (__isThenable(asyncWorkResult)) return Promise.resolve(asyncWorkResult).then(__rollbackWasmEnvForWasiInitialization, __retainAfterAsyncWorkDrainFailure);
 	return __rollbackWasmEnvForWasiInitialization();
 }
+function __rollbackWasiInitialization() {
+	if (__hasWasiThreadCrashed()) return __rollbackWasiInitializationAfterThreadCrash();
+	__wasiInitializationRollbackActive = true;
+	let result;
+	try {
+		result = __runWasiInitializationRollbackSteps();
+	} catch (error) {
+		__wasiInitializationRollbackActive = false;
+		if (__hasWasiThreadCrashed()) return __rollbackWasiInitializationAfterThreadCrash();
+		throw error;
+	}
+	if (!__isThenable(result)) {
+		__wasiInitializationRollbackActive = false;
+		return __hasWasiThreadCrashed() ? __rollbackWasiInitializationAfterThreadCrash() : result;
+	}
+	return Promise.resolve(result).then((cleanupErrors) => {
+		__wasiInitializationRollbackActive = false;
+		return __hasWasiThreadCrashed() ? __rollbackWasiInitializationAfterThreadCrash() : cleanupErrors;
+	}, (error) => {
+		__wasiInitializationRollbackActive = false;
+		if (__hasWasiThreadCrashed()) return __rollbackWasiInitializationAfterThreadCrash();
+		throw error;
+	});
+}
 let __wasiAddonCrashFlag;
 function __captureWasiAddonCrashFlag(instance) {
 	try {
@@ -898,6 +994,12 @@ try {
 		onCreateWorker() {
 			const worker = new Worker(new URL("./wasi-worker-browser.mjs", import.meta.url), { type: "module" });
 			__wasiWorkers.add(worker);
+			worker.addEventListener("error", (event) => {
+				__recordWasiThreadCrashError(event.error ?? event);
+			});
+			worker.addEventListener("messageerror", (event) => {
+				__recordWasiThreadCrashError(event);
+			});
 			__shareWasiAddonCrashFlag(worker);
 			return worker;
 		},
@@ -990,9 +1092,9 @@ function regexpToRust(re) {
 	if (re.flags.includes("i")) flags += "i";
 	if (re.flags.includes("m")) flags += "m";
 	if (re.flags.includes("s")) flags += "s";
-	if (!flags) return re.source;
-	if (!flags.includes("i")) return `(?${flags})${re.source}`;
-	let src = re.source;
+	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")) {
@@ -1017,8 +1119,165 @@ function regexpToRust(re) {
 			}
 		}
 	}
-	const uFlag = needsAsciiMode(src) && !hasNonAscii(src) ? "-u" : "";
-	return `${leading}(?${flags}${uFlag}:${src})${trailing}`;
+	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
@@ -1029,7 +1288,12 @@ function regexpToRust(re) {
 * -u, so skipping -u for them is zero-cost.
 */
 function needsAsciiMode(s) {
-	return /\\[wWdDsSbB]/.test(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.
@@ -1054,7 +1318,7 @@ function hasNonAscii(s) {
 *
 * NOTE: -u also disables Unicode character classes
 * (\w, \d, \s become ASCII-only), matching the
-* behaviour of regexpToRust() for /i RegExps.
+* behaviour of regexpToRust() for non-Unicode /i RegExps.
 */
 function scopeInlineFlags(src) {
 	const leadingBare = src.match(/^\(\?([ims]+)(?:-([imsu]+))?\)/);
@@ -1406,6 +1670,10 @@ var RegexSet = class {
 	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.encode(haystack))) return true;