@stll/regex-set-wasm 1.0.5 → 1.0.8

package/dist/wasm.mjs

@@ -1,40 +1,930 @@
-import { WASI, getDefaultContext, instantiateNapiModuleSync } from "@napi-rs/wasm-runtime";
+import { WASI, emnapiAsyncWorkPlugin, emnapiTSFNPlugin, instantiateNapiModule } from "@napi-rs/wasm-runtime";
+import { createContext } from "@emnapi/runtime";
 //#region regex-set.wasi-browser.js
+const __napiBindingTarget = "wasm32-wasi";
+function __napiStampBindingTarget(exportsObject, target) {
+	if (Object.prototype.hasOwnProperty.call(exportsObject, "__napiBindingTarget")) {
+		if (exportsObject.__napiBindingTarget === target) return target;
+		const error = /* @__PURE__ */ new Error("`__napiBindingTarget` is reserved by the generated binding loader, but the loaded binding already exports it. Rename the export, e.g. #[napi(js_name = \"...\")].");
+		error.code = "ERR_NAPI_BINDING_TARGET_CONFLICT";
+		throw error;
+	}
+	if (!Object.isExtensible(exportsObject)) return target;
+	try {
+		Object.defineProperty(exportsObject, "__napiBindingTarget", {
+			configurable: true,
+			enumerable: true,
+			value: target,
+			writable: true
+		});
+	} catch {}
+	return target;
+}
 const __wasi = new WASI({ version: "preview1" });
 const __wasmUrl = new URL("./regex-set.wasm32-wasi.wasm", import.meta.url).href;
-const __emnapiContext = getDefaultContext();
+const __wasmResponse = await globalThis.fetch(__wasmUrl);
+if (!__wasmResponse.ok) throw new Error("Failed to fetch WASI module " + __wasmUrl + ": " + __wasmResponse.status + " " + (__wasmResponse.statusText || "Unknown Status"));
+const __wasmFile = await __wasmResponse.arrayBuffer();
+const __wasmView = new Uint8Array(__wasmFile);
+if (__wasmView.length < 4 || __wasmView[0] !== 0 || __wasmView[1] !== 97 || __wasmView[2] !== 115 || __wasmView[3] !== 109) throw new Error("@stll/regex-set-wasm failed to load its .wasm binary. The response did not contain WebAssembly bytes, which commonly happens when a bundler (Vite, webpack dev server, etc.) rewrites import.meta.url during pre-bundling.\n\nIf you are using Vite, import the bundled plugin:\n  import stllWasm from \"@stll/regex-set-wasm/vite\"\n  // ...\n  plugins: [stllWasm()]");
 const __sharedMemory = new WebAssembly.Memory({
 	initial: 4e3,
 	maximum: 65536,
 	shared: true
 });
-const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = instantiateNapiModuleSync(await fetch(__wasmUrl).then(async (res) => {
-	const bytes = await res.arrayBuffer();
-	const view = new Uint8Array(bytes);
-	if (view.length < 4 || view[0] !== 0 || view[1] !== 97 || view[2] !== 115 || view[3] !== 109) throw new Error("@stll/regex-set-wasm failed to load its .wasm binary. The response did not contain WebAssembly bytes, which commonly happens when a bundler (Vite, webpack dev server, etc.) rewrites import.meta.url during pre-bundling.\n\nIf you are using Vite, import the bundled plugin:\n  import stllWasm from \"@stll/regex-set-wasm/vite\"\n  // ...\n  plugins: [stllWasm()]");
-	return bytes;
-}), {
-	context: __emnapiContext,
-	asyncWorkPoolSize: 4,
-	wasi: __wasi,
-	onCreateWorker() {
-		return new Worker(new URL("./wasi-worker-browser.mjs", import.meta.url), { type: "module" });
-	},
-	overwriteImports(importObject) {
-		importObject.env = {
-			...importObject.env,
-			...importObject.napi,
-			...importObject.emnapi,
-			memory: __sharedMemory
+const __asyncWorkPoolSize = 4;
+const __workerPoolSize = Math.max(2, globalThis.navigator?.hardwareConcurrency ?? 4);
+let __emnapiContext;
+const __wasiDisposeSymbol = Symbol.for("napi.rs.wasi.dispose");
+const __wasiWorkers = /* @__PURE__ */ new Set();
+let __wasiThreadManager;
+function __captureWasiThreadManager(context) {
+	if (context && context.PThread) __wasiThreadManager = context.PThread;
+	return {};
+}
+function __getWasiThreadManager() {
+	const manager = __wasiThreadManager !== void 0 ? __wasiThreadManager : __napiModule ? __napiModule.PThread : void 0;
+	if (manager && typeof manager.terminateWorker === "function") return manager;
+}
+let __napiInstance;
+let __emnapiContextDestroyed = false;
+let __emnapiContextDestroyPromise;
+let __emnapiWasmEnvCleanupPrepared = false;
+let __emnapiWasmEnvCleanupPreparing = false;
+let __finishParkedWasmEnvCleanup;
+let __emnapiWasmEnvCleanupYielding = false;
+let __emnapiWasmEnvSettlementLossReported = false;
+let __emnapiWasmEnvCleanupRan = false;
+let __emnapiWasmEnvCleanupDrained = false;
+let __emnapiWasmEnvCleanupDrainPromise;
+let __wasiDisposed = false;
+let __wasiAsyncWorkDrainPromise;
+let __wasiDisposePromise;
+let __completeWasiDisposal = function() {};
+function __isThenable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function __createCleanupError(errors, message) {
+	if (errors.length === 1) return errors[0];
+	const __AggregateError = globalThis.AggregateError;
+	if (typeof __AggregateError === "function") return new __AggregateError(errors, message);
+	const error = new Error(message);
+	error.errors = errors;
+	return error;
+}
+function __attachCleanupErrors(error, cleanupErrors) {
+	if (cleanupErrors.length === 0) return error;
+	const cleanupError = __createCleanupError(cleanupErrors, "WASI binding cleanup failed");
+	try {
+		if (error && (typeof error === "object" || typeof error === "function")) {
+			if (error.cause === void 0) {
+				error.cause = cleanupError;
+				if (error.cause === cleanupError) return error;
+			}
+			if (Array.isArray(error.cleanupErrors)) {
+				error.cleanupErrors.push(cleanupError);
+				return error;
+			} else {
+				const attachedCleanupErrors = [cleanupError];
+				error.cleanupErrors = attachedCleanupErrors;
+				if (error.cleanupErrors === attachedCleanupErrors) return error;
+			}
+		}
+	} catch {}
+	const aggregate = __createCleanupError([error, cleanupError], "WASI binding initialization and cleanup failed");
+	try {
+		aggregate.cause = error;
+	} catch {}
+	return aggregate;
+}
+function __wrapEmnapiContextDestroyForSettlement(context, prepareEnvCleanup, isPreparingEnvCleanup) {
+	let destroy;
+	try {
+		destroy = context.destroy;
+	} catch {
+		return context;
+	}
+	if (typeof destroy !== "function") return context;
+	try {
+		Object.defineProperty(context, "destroy", {
+			configurable: true,
+			enumerable: false,
+			writable: true,
+			value: function() {
+				if (isPreparingEnvCleanup?.()) return;
+				prepareEnvCleanup?.();
+				return Reflect.apply(destroy, this, arguments);
+			}
+		});
+	} catch {}
+	return context;
+}
+function __isPreparingWasmEnvCleanup() {
+	return __emnapiWasmEnvCleanupPreparing;
+}
+function __prepareWasmEnvCleanup() {
+	if (__emnapiWasmEnvCleanupPrepared) return;
+	const finishParked = __finishParkedWasmEnvCleanup;
+	if (finishParked !== void 0) {
+		finishParked();
+		__reportUnreachedWasmEnvSettlements();
+		return;
+	}
+	if (__emnapiWasmEnvCleanupPreparing) return;
+	const prepare = __napiInstance?.exports?.napi_prepare_wasm_env_cleanup;
+	if (typeof prepare === "function") {
+		__emnapiWasmEnvCleanupPreparing = true;
+		try {
+			prepare();
+		} finally {
+			__emnapiWasmEnvCleanupPreparing = false;
+		}
+		__emnapiWasmEnvCleanupRan = true;
+		__reportUnreachedWasmEnvSettlements();
+	}
+	__emnapiWasmEnvCleanupPrepared = true;
+}
+/**
+* Say so when the barrier leaves settlements queued and nothing is left that
+* could deliver them.
+*
+* Only the disposal chain yields the event-loop turns @emnapi/core needs to
+* dispatch its queue. Every other caller of the barrier destroys in the same
+* turn — a raw `Context.destroy()`, the 'exit' teardown — and
+* `Context.destroy()` runs the threadsafe function's cleanup hook, which drains
+* that queue with a null env and discards it. The promises those settlements
+* were for then hang forever, silently.
+*
+* Loud, once, and never throwing: this runs from inside `Context.destroy()`,
+* emnapi's own beforeExit destroy included, where throwing would take the whole
+* teardown down with it. Destroying anyway is still the right trade — the queue
+* is already unreachable by then.
+*/
+function __reportUnreachedWasmEnvSettlements() {
+	if (__emnapiWasmEnvCleanupYielding || __emnapiWasmEnvSettlementLossReported) return;
+	const pending = __napiInstance?.exports?.napi_wasm_env_cleanup_pending;
+	if (typeof pending !== "function") return;
+	let queued;
+	try {
+		queued = pending();
+	} catch {
+		return;
+	}
+	if (!queued) return;
+	__emnapiWasmEnvSettlementLossReported = true;
+	try {
+		const consoleHost = globalThis.console;
+		if (consoleHost && typeof consoleHost.error === "function") consoleHost.error("napi-rs: the wasm environment is being destroyed with " + queued + " queued promise settlement(s). Context.destroy() discards them, so those promises never settle. Dispose with binding[Symbol.for('napi.rs.wasi.dispose')]() instead: only it yields the event-loop turns the settlements need.");
+	} catch {}
+}
+const __scheduleMacrotask = (function() {
+	if (typeof setImmediate === "function") return function(callback) {
+		setImmediate(callback);
+	};
+	const __MessageChannel = globalThis.MessageChannel;
+	if (typeof __MessageChannel === "function") return function(callback) {
+		const channel = new __MessageChannel();
+		channel.port1.onmessage = function() {
+			channel.port1.onmessage = null;
+			try {
+				channel.port1.close();
+			} catch {}
+			try {
+				channel.port2.close();
+			} catch {}
+			callback();
 		};
-		return importObject;
-	},
-	beforeInit({ instance }) {
-		for (const name of Object.keys(instance.exports)) if (name.startsWith("__napi_register__")) instance.exports[name]();
+		channel.port2.postMessage(null);
+	};
+	return function(callback) {
+		setTimeout(callback, 0);
+	};
+})();
+function __scheduleTimer(callback, delay) {
+	const setTimer = globalThis.setTimeout;
+	if (typeof setTimer !== "function") {
+		__scheduleMacrotask(callback);
+		return;
 	}
-});
+	try {
+		setTimer(callback, delay);
+	} catch {
+		__scheduleMacrotask(callback);
+	}
+}
+const __WASM_RUNTIME_WORK_POLL_INTERVAL_MS = 1;
+const __WASM_RUNTIME_WORK_POLL_TRUSTED_ARRIVALS = 2;
+const __WASM_RUNTIME_WORK_POLL_STALL_MS = 50;
+const __WASM_RUNTIME_WORK_POLL_BACKUP_MS = 200;
+/**
+* Pacing state for one runtime-work poll.
+*
+* Per poll, never per module: whether the host's timers arrive is not a
+* property of the module. A host can lose its timers between two disposals,
+* and in the deferred shape every instance shares this module — one healthy
+* instance must not disarm the fallback for the next one.
+*/
+function __createWasmRuntimePollPace() {
+	return {
+		arrivals: 0,
+		settleTurn: void 0,
+		turnTimerDueAt: 0
+	};
+}
+/**
+* The backup that ends a turn whose timer is never going to arrive.
+*
+* Once the poll paces on the timer alone it has nothing left to fall back on
+* if the host's timers stop mid-poll: the turn that armed the dead timer is
+* the turn that parks, and a parked poll schedules nothing that could notice.
+* So every turn arms one of these before it yields, and each one compares due
+* times instead of measuring how long the parked turn has been waiting.
+*
+* Invariant: a parked turn is ended by the newest backup that was armed while
+* the host's timers still worked, and a backup ends a turn only when that
+* turn's own timer was already due a whole window before the backup itself.
+* Neither half turns on how far apart the arms happen to fall — what bounds
+* the rescue is how far back that newest live backup is:
+*
+* - *Ends it.* Hosts run timers in due order, so a backup that runs while a
+*   turn due a whole window earlier is still parked proves that turn's timer
+*   was dropped rather than merely late. That same comparison is what leaves a
+*   healthy host alone: there the turn's timer has already run and cleared
+*   `settleTurn` before any backup due after it can look.
+* - *Two turns back, not one.* A turn that ended does not prove its own timer
+*   arrived: until `…_TRUSTED_ARRIVALS` is reached every turn arms both
+*   primitives and the macrotask wins, so such a turn can end with its own
+*   timer — and the backup armed one line before it — already dead. The
+*   arrival that then flips the poll onto the timer alone can itself be a
+*   timer armed before the host's timers died. So the turn that parks can sit
+*   two turns past the last live arm, and the newest live backup is due
+*   `…_BACKUP_MS` less *two* turn lengths after that turn's own timer.
+*   Arming on every turn is what holds it to two, rather than however far back
+*   a throttle last let one through.
+* - *Ceiling.* Coverage therefore holds while two consecutive poll turns fit
+*   inside `…_BACKUP_MS` less the slack and one interval: 149 ms, so 74 ms
+*   per turn (measured: a 74 ms turn is still rescued, a 75 ms one parks).
+*   Past that the turn stays parked and the disposal promise never settles.
+*   The bound is deliberate: reaching it takes a host that drops timers
+*   mid-poll *and* keeps every poll turn busy for more than 74 ms, and neither
+*   Node nor WebContainer — the hosts that run the threaded artifact — does
+*   the second.
+*
+* The poll then goes back to arming both primitives until two fresh arrivals
+* prove the timers again. A host that stops running the timers it has
+* *already* accepted leaves nothing to fire, and the disposal promise stays
+* pending rather than wedging the thread — the same outcome as a blocking
+* closure that never returns. Unreferenced wherever the host allows it: the
+* poll's own turn timers are what keep the loop alive, never these.
+*/
+function __armWasmRuntimePollStallBackup(pace) {
+	const setTimer = globalThis.setTimeout;
+	if (typeof setTimer !== "function") return;
+	const dueAt = Date.now() + __WASM_RUNTIME_WORK_POLL_BACKUP_MS;
+	let handle;
+	try {
+		handle = setTimer(() => {
+			const settleTurn = pace.settleTurn;
+			if (!settleTurn || pace.turnTimerDueAt > dueAt - __WASM_RUNTIME_WORK_POLL_STALL_MS) return;
+			pace.arrivals = 0;
+			pace.settleTurn = void 0;
+			settleTurn();
+		}, __WASM_RUNTIME_WORK_POLL_BACKUP_MS);
+	} catch {
+		return;
+	}
+	if (handle && typeof handle.unref === "function") try {
+		handle.unref();
+	} catch {}
+}
+/**
+* One turn of the runtime-work poll.
+*
+* `__scheduleTimer` falls back to the macrotask scheduler when `setTimeout` is
+* missing or throws, but not when it is present, returns a handle and never
+* fires — fake timers in a test suite that disposes from an `afterEach`, or a
+* host whose timers belong to an IO context that is already gone. That host
+* would park this poll forever, and the poll is unbounded, so nothing would
+* ever call `…_finish`.
+*
+* Arm both primitives until timers armed by this poll have arrived twice, and
+* let whichever lands first end the turn; the loser resolves nothing. A host
+* with working timers therefore pays the double arming for the first turn or
+* two — the macrotask wins the race, but the timers behind it still arrive and
+* are counted — and paces on the timer alone from then on, instead of spinning
+* the loop on a zero-delay queue. A host whose timers never arrive keeps both,
+* and the macrotask is what keeps the poll moving. A host whose timers stop
+* after proving themselves is caught by `__armWasmRuntimePollStallBackup`,
+* which ends the parked turn and puts this poll back on both.
+*/
+function __yieldWasmRuntimePollTurn(pace) {
+	__armWasmRuntimePollStallBackup(pace);
+	return new Promise((resolve) => {
+		let settled = false;
+		const settle = () => {
+			if (settled) return;
+			settled = true;
+			if (pace.settleTurn === settle) pace.settleTurn = void 0;
+			resolve();
+		};
+		__scheduleTimer(() => {
+			pace.arrivals++;
+			settle();
+		}, __WASM_RUNTIME_WORK_POLL_INTERVAL_MS);
+		const turnTimerDueAt = Date.now() + __WASM_RUNTIME_WORK_POLL_INTERVAL_MS;
+		if (pace.arrivals < __WASM_RUNTIME_WORK_POLL_TRUSTED_ARRIVALS) {
+			__scheduleMacrotask(settle);
+			return;
+		}
+		pace.settleTurn = settle;
+		pace.turnTimerDueAt = turnTimerDueAt;
+	});
+}
+/**
+* The barrier for callers that can yield: `__prepareWasmEnvCleanup` with real
+* event-loop turns in the middle.
+*
+* `napi_prepare_wasm_env_cleanup` waits — it returns only once the addon's
+* async runtime has quiesced, and on `wasm32-wasip1-threads` the thread it
+* waits on is this one, the only thread that can give a running blocking
+* closure the JavaScript turn *it* is waiting for. A single call there can wait
+* for work that can never finish. The addon's two-phase form splits that:
+* `…_begin` stops the runtime without joining and reports whether anything is
+* still live, `napi_wasm_runtime_work_pending` answers that question again
+* without blocking, and `…_finish` joins. The turns yielded in between are the
+* entire point.
+*
+* The poll has no deadline, for the same reason the async-work drain below has
+* none: giving up means calling `…_finish`, which joins on this thread, and the
+* work it would join is the work that is waiting for a turn from this thread —
+* so a bound does not end the wait, it only moves it somewhere the JavaScript
+* thread can no longer be reached. A blocking closure that never returns keeps
+* the disposal promise pending instead, exactly as a task whose `execute` never
+* returns already keeps an *undisposed* process alive. The host contract is in
+* `crates/async-runtime/README.md`: a blocking closure must never wait on a
+* JavaScript turn. The process-exit path still blocks in `…_finish`, because it
+* has no turns left to give (see `__prepareWasmEnvCleanup`).
+*
+* Feature-detected like every other export in this teardown, so an addon built
+* against a napi crate that predates the split keeps the single blocking call.
+* Returns nothing whenever the handshake finished without yielding, which keeps
+* an idle disposal synchronous.
+*/
+function __prepareWasmEnvCleanupWithTurns() {
+	if (__emnapiWasmEnvCleanupPrepared || __emnapiWasmEnvCleanupPreparing) return;
+	const exports = __napiInstance?.exports;
+	const begin = exports?.napi_prepare_wasm_env_cleanup_begin;
+	const finish = exports?.napi_prepare_wasm_env_cleanup_finish;
+	if (typeof begin !== "function" || typeof finish !== "function") {
+		__emnapiWasmEnvCleanupYielding = true;
+		try {
+			__prepareWasmEnvCleanup();
+		} finally {
+			__emnapiWasmEnvCleanupYielding = false;
+		}
+		return;
+	}
+	const workPending = exports?.napi_wasm_runtime_work_pending;
+	__emnapiWasmEnvCleanupPreparing = true;
+	let live;
+	try {
+		live = begin();
+	} catch (error) {
+		__emnapiWasmEnvCleanupPreparing = false;
+		throw error;
+	}
+	__emnapiWasmEnvCleanupRan = true;
+	const finishCleanup = () => {
+		if (__emnapiWasmEnvCleanupPrepared) return;
+		__finishParkedWasmEnvCleanup = void 0;
+		try {
+			finish();
+		} finally {
+			__emnapiWasmEnvCleanupPreparing = false;
+		}
+		__emnapiWasmEnvCleanupPrepared = true;
+	};
+	if (!live || typeof workPending !== "function") {
+		finishCleanup();
+		return;
+	}
+	__finishParkedWasmEnvCleanup = finishCleanup;
+	return (async () => {
+		const pace = __createWasmRuntimePollPace();
+		for (;;) {
+			await __yieldWasmRuntimePollTurn(pace);
+			try {
+				if (!workPending()) return;
+			} catch {
+				return;
+			}
+		}
+	})().then(finishCleanup, finishCleanup);
+}
+const __WASM_ENV_CLEANUP_DRAIN_TURNS = 128;
+const __WASM_ENV_CLEANUP_BLIND_DRAIN_TURNS = 4;
+/**
+* `napi_prepare_wasm_env_cleanup` only *queues* the promise settlements of the
+* tasks it cancelled: `napi_call_threadsafe_function` appends to the
+* threadsafe-function queue, and @emnapi/core dispatches that queue from a
+* macrotask — two coalescing turns later, even for a call made on this very
+* thread. `Context.destroy()` then runs the threadsafe function's cleanup hook,
+* which drains the queue with a null env and *discards* whatever is still in it.
+*
+* So destroying without yielding first strands exactly the promises the barrier
+* exists to settle. Yield real event-loop turns until the addon reports the
+* queue empty; microtask checkpoints cannot help, no number of them lets a
+* macrotask run.
+*
+* Returns nothing when there is nothing to wait for, which keeps disposal
+* synchronous in the common case.
+*
+* The "already drained" flag is set only once a wait has actually finished.
+* Scheduling a macrotask can fail — a host-provided or patched `setImmediate`
+* that throws is enough — and a disposal that rejects stays retryable, so
+* marking the drain complete up front would make the retry skip it and destroy
+* the context with the barrier's settlements still queued.
+*
+* A wait that runs out of turns with the counter still nonzero rejects with
+* `ERR_NAPI_WASI_CLEANUP_PENDING` for the same reason: at that point
+* "finished" is indistinguishable from the stranding above, and destroying
+* would discard the very settlement the wait was for. The rejection leaves the
+* flag unset and disposal retryable.
+*/
+function __drainWasmEnvCleanup() {
+	if (__emnapiWasmEnvCleanupDrained || !__emnapiWasmEnvCleanupRan) return;
+	if (__emnapiWasmEnvCleanupDrainPromise) return __emnapiWasmEnvCleanupDrainPromise;
+	const pending = __napiInstance?.exports?.napi_wasm_env_cleanup_pending;
+	const observable = typeof pending === "function";
+	if (observable) {
+		let queued;
+		try {
+			queued = pending();
+		} catch {
+			__emnapiWasmEnvCleanupDrained = true;
+			return;
+		}
+		if (!queued) {
+			__emnapiWasmEnvCleanupDrained = true;
+			return;
+		}
+	}
+	const limit = observable ? __WASM_ENV_CLEANUP_DRAIN_TURNS : __WASM_ENV_CLEANUP_BLIND_DRAIN_TURNS;
+	const drainPromise = (async () => {
+		let queued = 0;
+		for (let turn = 0; turn < limit; turn++) {
+			await new Promise((resolve) => {
+				__scheduleMacrotask(resolve);
+			});
+			if (!observable) continue;
+			try {
+				queued = pending();
+			} catch {
+				return;
+			}
+			if (!queued) return;
+		}
+		if (!observable) return;
+		const drainError = /* @__PURE__ */ new Error("the wasm environment still reports " + queued + " queued settlement(s) after " + limit + " event-loop turns; the context was not destroyed - retry dispose() to wait for the queue again");
+		drainError.code = "ERR_NAPI_WASI_CLEANUP_PENDING";
+		throw drainError;
+	})().then((value) => {
+		__emnapiWasmEnvCleanupDrained = true;
+		__emnapiWasmEnvCleanupDrainPromise = void 0;
+		return value;
+	}, (error) => {
+		__emnapiWasmEnvCleanupDrainPromise = void 0;
+		throw error;
+	});
+	__emnapiWasmEnvCleanupDrainPromise = drainPromise;
+	return drainPromise;
+}
+function __destroyEmnapiContext() {
+	if (__emnapiContextDestroyed || __emnapiContext === void 0) {
+		__emnapiContextDestroyed = true;
+		return;
+	}
+	if (__emnapiContextDestroyPromise) return __emnapiContextDestroyPromise;
+	__prepareWasmEnvCleanup();
+	if (__isPreparingWasmEnvCleanup()) return;
+	const result = __emnapiContext.destroy();
+	if (!__isThenable(result)) {
+		__emnapiContextDestroyed = true;
+		return;
+	}
+	const destroyPromise = Promise.resolve(result).then((value) => {
+		__emnapiContextDestroyed = true;
+		return value;
+	}, (error) => {
+		__emnapiContextDestroyPromise = void 0;
+		throw error;
+	});
+	__emnapiContextDestroyPromise = destroyPromise;
+	return destroyPromise;
+}
+/**
+* Holds the event loop open until `work` settles.
+*
+* Nothing else can: the pool workers are deliberately unreferenced so an idle
+* binding cannot keep a process alive, and referencing them again for the
+* termination does not hold either — emnapi unreferences a worker the moment it
+* reports `async-thread-ready`, which for a worker that was still starting
+* lands *after* the termination began. Without a handle of its own, an
+* `await dispose()` with nothing else pending exits the process with its
+* promise unsettled, and everything after the `await` is skipped.
+*
+* The timer is cleared as soon as the work settles, so this never outlives the
+* disposal that asked for it.
+*/
+function __keepEventLoopAliveUntil(work) {
+	const setTimer = globalThis.setInterval;
+	const clearTimer = globalThis.clearInterval;
+	if (typeof setTimer !== "function" || typeof clearTimer !== "function") return work;
+	let timer;
+	try {
+		timer = setTimer(function() {}, 50);
+	} catch {
+		return work;
+	}
+	const release = function() {
+		try {
+			clearTimer(timer);
+		} catch {}
+	};
+	return work.then((value) => {
+		release();
+		return value;
+	}, (error) => {
+		release();
+		throw error;
+	});
+}
+const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1;
+/**
+* Settles this addon's outstanding `napi_async_work` before the teardown that
+* would strand it.
+*
+* `napi_prepare_wasm_env_cleanup` does not cover async work, and nothing about
+* it is observable from JavaScript: the threadless archive resolves
+* `napi_*_async_work` through the `@emnapi/core` plugins, but the threaded one
+* links the C `async_work.c` on the uv threadpool, so there the wasm neither
+* imports nor exports those symbols and the only brackets a loader could watch
+* (`_emnapi_ctx_*_waiting_request_counter`) are shared with threadsafe
+* functions. The addon is the one place both flavors go through, so it answers
+* for both, through the same kind of handshake the settlement drain uses:
+*
+*   - `napi_wasm_cancel_pending_async_work()` cancels what no thread has
+*     started. Those completion callbacks run with `napi_cancelled`, which
+*     napi-rs turns into a promise rejected with an `AbortError`.
+*   - `napi_wasm_async_work_pending()` counts what is still owed a completion
+*     callback. Work already executing refuses cancellation and stays counted
+*     until it finishes normally — which it can, because this runs before the
+*     barrier, before `Context.destroy()` and before anything is terminated.
+*
+* Both exports are optional: an addon built against a napi crate that predates
+* them drains nothing and keeps the previous behavior, exactly as the
+* `napi_wasm_env_cleanup_pending` handshake degrades.
+*
+* Returns nothing when there is nothing outstanding, which keeps disposal
+* synchronous in the common case. The promise it returns otherwise never
+* rejects.
+*
+* The wait has no deadline, and that is the point: giving up would destroy the
+* environment with a completion callback still owed, which is the stranding
+* this exists to prevent. A task whose `execute` never returns already keeps an
+* *undisposed* process alive in exactly the same way, so disposal inherits that
+* rather than inventing a bound it cannot honor.
+*
+* Safe to call from inside a completion callback, which is reachable: settling
+* a task runs addon code that can re-enter JavaScript — a setter on the value
+* being handed back, a threadsafe-function callback — and that JavaScript can
+* call `dispose()`. Two things make it terminate rather than wait on itself:
+*
+*   - The addon keeps a work registered until its completion callback
+*     *finishes*, so the count read here is at least one and this takes the
+*     polling path instead of declaring the environment drained and tearing it
+*     down from inside the frame that is still settling a promise.
+*   - The poll is a timer, so it cannot run until the callback has returned to
+*     the host — by which time that work has left the registry. The count the
+*     next poll reads is the one taken after the callback finished.
+*
+* `__disposeWasiBinding` hands every caller the same in-flight promise, so the
+* nested call joins this disposal rather than starting a second one.
+*/
+function __drainWasiAsyncWork() {
+	if (__wasiAsyncWorkDrainPromise !== void 0) return __wasiAsyncWorkDrainPromise;
+	const exports = __napiInstance?.exports;
+	const pending = exports?.napi_wasm_async_work_pending;
+	const cancelPending = exports?.napi_wasm_cancel_pending_async_work;
+	if (typeof pending !== "function" || typeof cancelPending !== "function") return;
+	const readPending = () => {
+		try {
+			return pending();
+		} catch (error) {
+			if (error instanceof globalThis.WebAssembly.RuntimeError) return 0;
+			throw error;
+		}
+	};
+	if (!readPending()) return;
+	try {
+		cancelPending();
+	} catch {}
+	if (!readPending()) return;
+	const drainPromise = __keepEventLoopAliveUntil((async () => {
+		while (readPending()) await new Promise((resolve) => {
+			__scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS);
+		});
+	})()).then(() => {
+		__wasiAsyncWorkDrainPromise = void 0;
+	}, (error) => {
+		__wasiAsyncWorkDrainPromise = void 0;
+		throw error;
+	});
+	__wasiAsyncWorkDrainPromise = drainPromise;
+	return drainPromise;
+}
+/**
+* `@emnapi/wasi-threads` counts a worker exit as expected only when its own
+* thread manager performed the termination. A bare `worker.terminate()` reaches
+* the manager's `exit` listener instead, which reports
+* `worker (tid = N) sent an error! ... stopped with exit code 1` and rethrows
+* inside the emit — aborting the `once('exit')` that backs the terminate
+* promise, so disposal never settles and the process dies with an uncaught
+* exception. Mark the termination through the manager first.
+*
+* The manager comes from `__getWasiThreadManager`, not from `__napiModule`:
+* the initialization rollback runs on the one path where instantiation never
+* returned, so `__napiModule` is still undefined there while the workers it
+* spawned are already registered and loaded.
+*
+* Not `terminateAllThreads()`: that one recreates the pool it just shut down.
+*/
+function __terminateWasiWorkers() {
+	const cleanupErrors = [];
+	const pending = [];
+	const threadManager = __getWasiThreadManager();
+	for (const worker of __wasiWorkers) {
+		let result;
+		try {
+			if (threadManager) {
+				threadManager.terminateWorker(worker);
+				worker.onmessage = void 0;
+			}
+			result = worker.terminate();
+		} catch (error) {
+			cleanupErrors.push(error);
+			continue;
+		}
+		if (__isThenable(result)) pending.push(Promise.resolve(result).then(() => {
+			__wasiWorkers.delete(worker);
+		}, (error) => {
+			cleanupErrors.push(error);
+		}));
+		else __wasiWorkers.delete(worker);
+	}
+	const finish = () => {
+		if (cleanupErrors.length > 0) throw __createCleanupError(cleanupErrors, "Failed to terminate WASI workers");
+	};
+	return pending.length > 0 ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish) : finish();
+}
+function __finishWasiDisposal() {
+	const workerResult = __terminateWasiWorkers();
+	if (__isThenable(workerResult)) return Promise.resolve(workerResult).then(__completeWasiDisposal);
+}
+function __continueWasiDisposal() {
+	const destroyResult = __destroyEmnapiContext();
+	if (__isThenable(destroyResult)) return Promise.resolve(destroyResult).then(__finishWasiDisposal);
+	return __finishWasiDisposal();
+}
+function __drainWasmEnvForWasiDisposal() {
+	const drainResult = __drainWasmEnvCleanup();
+	if (__isThenable(drainResult)) return Promise.resolve(drainResult).then(__continueWasiDisposal);
+	return __continueWasiDisposal();
+}
+function __cleanUpWasmEnvForWasiDisposal() {
+	const prepareResult = __prepareWasmEnvCleanupWithTurns();
+	if (__isThenable(prepareResult)) return Promise.resolve(prepareResult).then(__drainWasmEnvForWasiDisposal);
+	return __drainWasmEnvForWasiDisposal();
+}
+function __startWasiDisposal() {
+	const asyncWorkResult = __drainWasiAsyncWork();
+	if (__isThenable(asyncWorkResult)) return Promise.resolve(asyncWorkResult).then(__cleanUpWasmEnvForWasiDisposal);
+	return __cleanUpWasmEnvForWasiDisposal();
+}
+/**
+* Disposes this generated WASI binding.
+*
+* Access this function with:
+* binding[Symbol.for('napi.rs.wasi.dispose')]()
+*/
+function __disposeWasiBinding() {
+	if (__wasiDisposePromise) return __wasiDisposePromise;
+	if (__wasiDisposed) return Promise.resolve();
+	let resolveDispose;
+	let rejectDispose;
+	const disposePromise = new Promise((resolve, reject) => {
+		resolveDispose = resolve;
+		rejectDispose = reject;
+	});
+	__wasiDisposePromise = disposePromise;
+	let result;
+	try {
+		result = __startWasiDisposal();
+	} catch (error) {
+		__wasiDisposePromise = void 0;
+		rejectDispose(error);
+		return disposePromise;
+	}
+	Promise.resolve(result).then((value) => {
+		__wasiDisposed = true;
+		resolveDispose(value);
+	}, (error) => {
+		__wasiDisposePromise = void 0;
+		rejectDispose(error);
+	});
+	return disposePromise;
+}
+function __publishWasiDispose(exports) {
+	Object.defineProperty(exports, __wasiDisposeSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: __disposeWasiBinding,
+		writable: false
+	});
+}
+function __finishWasiInitializationRollback(cleanupErrors) {
+	let workerResult;
+	try {
+		workerResult = __terminateWasiWorkers();
+	} catch (cleanupError) {
+		cleanupErrors.push(cleanupError);
+		return cleanupErrors;
+	}
+	if (__isThenable(workerResult)) return Promise.resolve(workerResult).catch((cleanupError) => {
+		cleanupErrors.push(cleanupError);
+	}).then(() => cleanupErrors);
+	return cleanupErrors;
+}
+function __destroyContextForWasiRollback(cleanupErrors) {
+	let destroyResult;
+	try {
+		destroyResult = __destroyEmnapiContext();
+	} catch (cleanupError) {
+		cleanupErrors.push(cleanupError);
+		return __finishWasiInitializationRollback(cleanupErrors);
+	}
+	if (__isThenable(destroyResult)) return Promise.resolve(destroyResult).catch((cleanupError) => {
+		cleanupErrors.push(cleanupError);
+	}).then(() => __finishWasiInitializationRollback(cleanupErrors));
+	return __finishWasiInitializationRollback(cleanupErrors);
+}
+/**
+* Leaves a rollback that could not reach the queued settlements undestroyed, and
+* hands it to whatever this flavor has that can still reclaim it.
+*/
+function __retainFailedWasiRollback(cleanupErrors) {
+	return cleanupErrors;
+}
+/**
+* Initialization can fail *after* registration has already run, and registration
+* runs with a live environment: a module-init hook can start async work and then
+* return an error, and the promise it created may already have escaped into
+* JavaScript. The barrier cancels that work and *queues* the settlement, so this
+* path needs the same drain the ordinary disposal does — destroying without
+* yielding discards the queue with a null env and strands the promise.
+*
+* Stays synchronous when nothing is queued, which covers every failure before
+* `beforeInit`: there is no instance to run the barrier on, so nothing to drain.
+*
+* A barrier or drain that did *not* finish stops the rollback short of
+* destroying, which is what `dispose()` already does — a rejected drain there
+* never reaches `__continueWasiDisposal`. Destroying anyway is the worse of the
+* two trades, and not because of what it saves:
+*
+*   - It cannot deliver the settlements. `Context.destroy()` runs the
+*     threadsafe function's cleanup hook, which drains the queue with a null env
+*     and discards it, so a promise that already escaped into JavaScript hangs
+*     forever with nothing left that could ever settle it.
+*   - It saves less than it looks. `Context.destroy()` stops JavaScript calls
+*     and runs cleanup hooks; it does not free the wasm instance or its Memory,
+*     which this module's scope holds either way. What stopping short retains is
+*     the emnapi context's bookkeeping and its un-run cleanup hooks.
+*   - Retry is not theoretical. A rollback that records a cleanup error is
+*     already kept in the process-wide registry above, so re-`require()`ing this
+*     file replays it instead of re-instantiating — and the `6e15de6f` flag fix
+*     means the replay drains again rather than skipping it. Destroying first is
+*     what makes that retained record useless.
+*
+* The residual cost is honest: the CJS flavor hands the context to its
+* `process.on('exit')` teardown, so a process that never retries still reclaims
+* it on the way out. The ESM browser flavor has no equivalent — a module that
+* throws while evaluating is permanently errored, so re-importing rethrows
+* without re-running this file — and there the context stays until the realm
+* 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 __rollbackWasmEnvForWasiInitialization() {
+		const cleanupErrors = [];
+		let prepareResult;
+		try {
+			prepareResult = __prepareWasmEnvCleanupWithTurns();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		}
+		if (__isThenable(prepareResult)) return Promise.resolve(prepareResult).then(() => __drainWasmEnvForWasiRollback(cleanupErrors), (cleanupError) => {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		});
+		return __drainWasmEnvForWasiRollback(cleanupErrors);
+	}
+	function __drainWasmEnvForWasiRollback(cleanupErrors) {
+		let drainResult;
+		try {
+			drainResult = __drainWasmEnvCleanup();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		}
+		if (__isThenable(drainResult)) return Promise.resolve(drainResult).then(() => __destroyContextForWasiRollback(cleanupErrors), (cleanupError) => {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		});
+		return __destroyContextForWasiRollback(cleanupErrors);
+	}
+	const __retainAfterAsyncWorkDrainFailure = (cleanupError) => __retainFailedWasiRollback([cleanupError]);
+	let asyncWorkResult;
+	try {
+		asyncWorkResult = __drainWasiAsyncWork();
+	} catch (cleanupError) {
+		return __retainAfterAsyncWorkDrainFailure(cleanupError);
+	}
+	if (__isThenable(asyncWorkResult)) return Promise.resolve(asyncWorkResult).then(__rollbackWasmEnvForWasiInitialization, __retainAfterAsyncWorkDrainFailure);
+	return __rollbackWasmEnvForWasiInitialization();
+}
+let __wasiAddonCrashFlag;
+function __captureWasiAddonCrashFlag(instance) {
+	try {
+		const getAddress = instance.exports.napi_wasm_thread_crash_flag_address;
+		if (typeof getAddress !== "function") return;
+		const address = getAddress() >>> 0;
+		const buffer = __sharedMemory.buffer;
+		if (address === 0 || address % 4 !== 0 || address + 4 > buffer.byteLength) return;
+		__wasiAddonCrashFlag = new Int32Array(buffer, address, 1);
+	} catch {}
+}
+function __shareWasiAddonCrashFlag(worker) {
+	if (__wasiAddonCrashFlag === void 0) return;
+	try {
+		worker.postMessage({ __napiRsAddonCrashFlag: __wasiAddonCrashFlag });
+	} catch {}
+}
+let __wasiModule;
+let __napiModule;
+try {
+	__emnapiContext = __wrapEmnapiContextDestroyForSettlement(createContext({ autoDestroy: false }), __prepareWasmEnvCleanup, __isPreparingWasmEnvCleanup);
+	__emnapiContext.suppressDestroy();
+	({instance: __napiInstance, module: __wasiModule, napiModule: __napiModule} = await instantiateNapiModule(__wasmFile, {
+		context: __emnapiContext,
+		asyncWorkPoolSize: __asyncWorkPoolSize,
+		reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },
+		plugins: [
+			__captureWasiThreadManager,
+			emnapiAsyncWorkPlugin,
+			emnapiTSFNPlugin
+		],
+		wasi: __wasi,
+		onCreateWorker() {
+			const worker = new Worker(new URL("./wasi-worker-browser.mjs", import.meta.url), { type: "module" });
+			__wasiWorkers.add(worker);
+			__shareWasiAddonCrashFlag(worker);
+			return worker;
+		},
+		overwriteImports(importObject) {
+			importObject.env = {
+				...importObject.env,
+				...importObject.napi,
+				...importObject.emnapi,
+				memory: __sharedMemory
+			};
+			return importObject;
+		},
+		beforeInit({ instance }) {
+			__napiInstance = instance;
+			__captureWasiAddonCrashFlag(instance);
+			for (const worker of __wasiWorkers) __shareWasiAddonCrashFlag(worker);
+			for (const name of Object.keys(instance.exports)) if (name.startsWith("__napi_register__")) instance.exports[name]();
+		}
+	}));
+	__publishWasiDispose(__napiModule.exports);
+	__napiStampBindingTarget(__napiModule.exports, __napiBindingTarget);
+} catch (error) {
+	throw __attachCleanupErrors(error, await __rollbackWasiInitialization());
+}
 var regex_set_wasi_browser_default = __napiModule.exports;
 __napiModule.exports.RegexSet;
+__napiModule.exports._prepareRegexSet;
 __napiModule.exports._uax29Boundaries;
 //#endregion
 //#region src/core.ts
@@ -81,13 +971,9 @@ function asciiBoundaries(src) {
 	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})`;
-			i += 2;
-		} else {
-			result += src.charAt(i) + src.charAt(i + 1);
-			i += 2;
-		}
+		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;
@@ -241,9 +1127,10 @@ function scopeInnerFlags(src) {
 				}
 			}
 			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)}`;
+				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;
@@ -377,6 +1264,88 @@ function splitTopLevelAlternatives(body) {
 	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.
 *
@@ -410,90 +1379,29 @@ var RegexSet = class {
 	_jsFallbacks;
 	_nativeSingles;
 	_boundaryOptions;
-	constructor(patterns, options) {
-		const entries = patterns.map(normalizeEntry);
-		this._names = entries.map((e) => e.name);
-		this._hasNames = entries.some((e) => e.name !== void 0);
-		this._patternCount = entries.length;
-		const unicode = options?.unicodeBoundaries ?? true;
-		const wholeWords = options?.wholeWords ?? false;
-		const ci = options?.caseInsensitive ?? false;
-		this._boundaryOptions = {
-			wholeWords,
-			unicodeBoundaries: unicode
-		};
-		let processed = entries.map((e) => e.pattern);
-		if (ci) processed = processed.map((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}`;
-		});
-		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 = [];
-		this._nativeIndexMap = [];
-		this._jsFallbacks = [];
+	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 = [];
-		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) this._jsFallbacks.push({
-					pattern: i,
-					re: jsFallback
-				});
-				else {
-					this._nativeIndexMap.push(i);
-					nativePatterns.push(expandedPattern);
-				}
-			}
-		}
-		this._inner = new binding.RegexSet(nativePatterns, nativeOpts);
-		if (this._jsFallbacks.length > 0) this._nativeSingles = nativePatterns.map((pattern, i) => {
+		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], nativeOpts)
+				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;