@qds.dev/code 0.8.2 → 0.9.1

package/lib/preview/bundler/repl-bundler-worker.qwik.mjs

@@ -1,42 +1,626 @@
-import { ThreadManager, ThreadMessageHandler, WASIThreads } from "@emnapi/wasi-threads";
-
 //#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@emnapi+wasi-threads@1.1.0/node_modules/@emnapi/wasi-threads/dist/wasi-threads.esm-bundler.js
+var _WebAssembly$2 = typeof WebAssembly !== "undefined" ? WebAssembly : typeof WXWebAssembly !== "undefined" ? WXWebAssembly : void 0;
+var ENVIRONMENT_IS_NODE = typeof process === "object" && process !== null && typeof process.versions === "object" && process.versions !== null && typeof process.versions.node === "string";
+function getPostMessage(options$1) {
+	return typeof (options$1 === null || options$1 === void 0 ? void 0 : options$1.postMessage) === "function" ? options$1.postMessage : typeof postMessage === "function" ? postMessage : void 0;
+}
+function deserizeErrorFromBuffer(sab) {
+	var _a, _b;
+	var i32array = new Int32Array(sab);
+	if (Atomics.load(i32array, 0) <= 1) return null;
+	var nameLength = Atomics.load(i32array, 1);
+	var messageLength = Atomics.load(i32array, 2);
+	var stackLength = Atomics.load(i32array, 3);
+	var buffer = new Uint8Array(sab);
+	var nameBuffer = buffer.slice(16, 16 + nameLength);
+	var messageBuffer = buffer.slice(16 + nameLength, 16 + nameLength + messageLength);
+	var stackBuffer = buffer.slice(16 + nameLength + messageLength, 16 + nameLength + messageLength + stackLength);
+	var name = new TextDecoder().decode(nameBuffer);
+	var message = new TextDecoder().decode(messageBuffer);
+	var stack = new TextDecoder().decode(stackBuffer);
+	var error$1 = new ((_a = globalThis[name]) !== null && _a !== void 0 ? _a : name === "RuntimeError" ? (_b = _WebAssembly$2.RuntimeError) !== null && _b !== void 0 ? _b : Error : Error)(message);
+	Object.defineProperty(error$1, "stack", {
+		value: stack,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+	return error$1;
+}
+/** @public */
+function isSharedArrayBuffer(value) {
+	return typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer || Object.prototype.toString.call(value) === "[object SharedArrayBuffer]";
+}
+/** @public */
+function isTrapError(e$1) {
+	try {
+		return e$1 instanceof _WebAssembly$2.RuntimeError;
+	} catch (_) {
+		return false;
 	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
+}
+function createMessage(type$1, payload) {
+	return { __emnapi__: {
+		type: type$1,
+		payload
+	} };
+}
+var WASI_THREADS_MAX_TID = 536870911;
+function checkSharedWasmMemory(wasmMemory) {
+	if (wasmMemory) {
+		if (!isSharedArrayBuffer(wasmMemory.buffer)) throw new Error("Multithread features require shared wasm memory. Try to compile with `-matomics -mbulk-memory` and use `--import-memory --shared-memory` during linking, then create WebAssembly.Memory with `shared: true` option");
+	} else if (typeof SharedArrayBuffer === "undefined") throw new Error("Current environment does not support SharedArrayBuffer, threads are not available!");
+}
+function getReuseWorker(value) {
+	var _a;
+	if (typeof value === "boolean") return value ? {
+		size: 0,
+		strict: false
+	} : false;
+	if (typeof value === "number") {
+		if (!(value >= 0)) throw new RangeError("reuseWorker: size must be a non-negative integer");
+		return {
+			size: value,
+			strict: false
+		};
 	}
-	return target;
-};
-var __copyProps = (to, from$1, except, desc) => {
-	if (from$1 && typeof from$1 === "object" || typeof from$1 === "function") {
-		for (var keys = __getOwnPropNames(from$1), i = 0, n$1 = keys.length, key; i < n$1; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from$1[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from$1, key)) || desc.enumerable
+	if (!value) return false;
+	var size = (_a = Number(value.size)) !== null && _a !== void 0 ? _a : 0;
+	var strict = Boolean(value.strict);
+	if (!(size > 0) && strict) throw new RangeError("reuseWorker: size must be set to positive integer if strict is set to true");
+	return {
+		size,
+		strict
+	};
+}
+var nextWorkerID = 0;
+/** @public */
+var ThreadManager = /* @__PURE__ */ function() {
+	function ThreadManager$1(options$1) {
+		var _a;
+		this.unusedWorkers = [];
+		this.runningWorkers = [];
+		this.pthreads = Object.create(null);
+		this.wasmModule = null;
+		this.wasmMemory = null;
+		this.messageEvents = /* @__PURE__ */ new WeakMap();
+		if (!options$1) throw new TypeError("ThreadManager(): options is not provided");
+		if ("childThread" in options$1) this._childThread = Boolean(options$1.childThread);
+		else this._childThread = false;
+		if (this._childThread) {
+			this._onCreateWorker = void 0;
+			this._reuseWorker = false;
+			this._beforeLoad = void 0;
+		} else {
+			this._onCreateWorker = options$1.onCreateWorker;
+			this._reuseWorker = getReuseWorker(options$1.reuseWorker);
+			this._beforeLoad = options$1.beforeLoad;
+		}
+		this.printErr = (_a = options$1.printErr) !== null && _a !== void 0 ? _a : console.error.bind(console);
+	}
+	Object.defineProperty(ThreadManager$1.prototype, "nextWorkerID", {
+		get: function() {
+			return nextWorkerID;
+		},
+		enumerable: false,
+		configurable: true
+	});
+	ThreadManager$1.prototype.init = function() {
+		if (!this._childThread) this.initMainThread();
+	};
+	ThreadManager$1.prototype.initMainThread = function() {
+		this.preparePool();
+	};
+	ThreadManager$1.prototype.preparePool = function() {
+		if (this._reuseWorker) {
+			if (this._reuseWorker.size) {
+				var pthreadPoolSize = this._reuseWorker.size;
+				while (pthreadPoolSize--) {
+					var worker = this.allocateUnusedWorker();
+					if (ENVIRONMENT_IS_NODE) {
+						worker.once("message", function() {});
+						worker.unref();
+					}
+				}
+			}
+		}
+	};
+	ThreadManager$1.prototype.shouldPreloadWorkers = function() {
+		return !this._childThread && this._reuseWorker && this._reuseWorker.size > 0;
+	};
+	ThreadManager$1.prototype.loadWasmModuleToAllWorkers = function() {
+		var _this_1 = this;
+		var promises$1 = Array(this.unusedWorkers.length);
+		var _loop_1 = function(i$1) {
+			var worker = this_1.unusedWorkers[i$1];
+			if (ENVIRONMENT_IS_NODE) worker.ref();
+			promises$1[i$1] = this_1.loadWasmModuleToWorker(worker).then(function(w) {
+				if (ENVIRONMENT_IS_NODE) worker.unref();
+				return w;
+			}, function(e$1) {
+				if (ENVIRONMENT_IS_NODE) worker.unref();
+				throw e$1;
+			});
+		};
+		var this_1 = this;
+		for (var i = 0; i < this.unusedWorkers.length; ++i) _loop_1(i);
+		return Promise.all(promises$1).catch(function(err) {
+			_this_1.terminateAllThreads();
+			throw err;
+		});
+	};
+	ThreadManager$1.prototype.preloadWorkers = function() {
+		if (this.shouldPreloadWorkers()) return this.loadWasmModuleToAllWorkers();
+		return Promise.resolve([]);
+	};
+	ThreadManager$1.prototype.setup = function(wasmModule, wasmMemory) {
+		this.wasmModule = wasmModule;
+		this.wasmMemory = wasmMemory;
+	};
+	ThreadManager$1.prototype.markId = function(worker) {
+		if (worker.__emnapi_tid) return worker.__emnapi_tid;
+		var tid = nextWorkerID + 43;
+		nextWorkerID = (nextWorkerID + 1) % (WASI_THREADS_MAX_TID - 42);
+		this.pthreads[tid] = worker;
+		worker.__emnapi_tid = tid;
+		return tid;
+	};
+	ThreadManager$1.prototype.returnWorkerToPool = function(worker) {
+		var tid = worker.__emnapi_tid;
+		if (tid !== void 0) delete this.pthreads[tid];
+		this.unusedWorkers.push(worker);
+		this.runningWorkers.splice(this.runningWorkers.indexOf(worker), 1);
+		delete worker.__emnapi_tid;
+		if (ENVIRONMENT_IS_NODE) worker.unref();
+	};
+	ThreadManager$1.prototype.loadWasmModuleToWorker = function(worker, sab) {
+		var _this_1 = this;
+		if (worker.whenLoaded) return worker.whenLoaded;
+		var err = this.printErr;
+		var beforeLoad = this._beforeLoad;
+		var _this = this;
+		worker.whenLoaded = new Promise(function(resolve$2, reject) {
+			var handleError$1 = function(e$1) {
+				var message = "worker sent an error!";
+				if (worker.__emnapi_tid !== void 0) message = "worker (tid = " + worker.__emnapi_tid + ") sent an error!";
+				if ("message" in e$1) {
+					err(message + " " + e$1.message);
+					if (e$1.message.indexOf("RuntimeError") !== -1 || e$1.message.indexOf("unreachable") !== -1) try {
+						_this.terminateAllThreads();
+					} catch (_) {}
+				} else err(message);
+				reject(e$1);
+				throw e$1;
+			};
+			var handleMessage$1 = function(data) {
+				if (data.__emnapi__) {
+					var type$1 = data.__emnapi__.type;
+					var payload = data.__emnapi__.payload;
+					if (type$1 === "loaded") {
+						worker.loaded = true;
+						if (ENVIRONMENT_IS_NODE && !worker.__emnapi_tid) worker.unref();
+						resolve$2(worker);
+					} else if (type$1 === "cleanup-thread") {
+						if (payload.tid in _this_1.pthreads) _this_1.cleanThread(worker, payload.tid);
+					}
+				}
+			};
+			worker.onmessage = function(e$1) {
+				handleMessage$1(e$1.data);
+				_this_1.fireMessageEvent(worker, e$1);
+			};
+			worker.onerror = handleError$1;
+			if (ENVIRONMENT_IS_NODE) {
+				worker.on("message", function(data) {
+					var _a, _b;
+					(_b = (_a = worker).onmessage) === null || _b === void 0 || _b.call(_a, { data });
 				});
+				worker.on("error", function(e$1) {
+					var _a, _b;
+					(_b = (_a = worker).onerror) === null || _b === void 0 || _b.call(_a, e$1);
+				});
+				worker.on("detachedExit", function() {});
+			}
+			if (typeof beforeLoad === "function") beforeLoad(worker);
+			try {
+				worker.postMessage(createMessage("load", {
+					wasmModule: _this_1.wasmModule,
+					wasmMemory: _this_1.wasmMemory,
+					sab
+				}));
+			} catch (err$1) {
+				checkSharedWasmMemory(_this_1.wasmMemory);
+				throw err$1;
 			}
+		});
+		return worker.whenLoaded;
+	};
+	ThreadManager$1.prototype.allocateUnusedWorker = function() {
+		var _onCreateWorker = this._onCreateWorker;
+		if (typeof _onCreateWorker !== "function") throw new TypeError("`options.onCreateWorker` is not provided");
+		var worker = _onCreateWorker({
+			type: "thread",
+			name: "emnapi-pthread"
+		});
+		this.unusedWorkers.push(worker);
+		return worker;
+	};
+	ThreadManager$1.prototype.getNewWorker = function(sab) {
+		if (this._reuseWorker) {
+			if (this.unusedWorkers.length === 0) {
+				if (this._reuseWorker.strict) {
+					if (!ENVIRONMENT_IS_NODE) {
+						var err = this.printErr;
+						err("Tried to spawn a new thread, but the thread pool is exhausted.\nThis might result in a deadlock unless some threads eventually exit or the code explicitly breaks out to the event loop.");
+						return;
+					}
+				}
+				var worker_1 = this.allocateUnusedWorker();
+				this.loadWasmModuleToWorker(worker_1, sab);
+			}
+			return this.unusedWorkers.pop();
 		}
+		var worker = this.allocateUnusedWorker();
+		this.loadWasmModuleToWorker(worker, sab);
+		return this.unusedWorkers.pop();
+	};
+	ThreadManager$1.prototype.cleanThread = function(worker, tid, force) {
+		if (!force && this._reuseWorker) this.returnWorkerToPool(worker);
+		else {
+			delete this.pthreads[tid];
+			var index = this.runningWorkers.indexOf(worker);
+			if (index !== -1) this.runningWorkers.splice(index, 1);
+			this.terminateWorker(worker);
+			delete worker.__emnapi_tid;
+		}
+	};
+	ThreadManager$1.prototype.terminateWorker = function(worker) {
+		var _this_1 = this;
+		var _a;
+		var tid = worker.__emnapi_tid;
+		worker.terminate();
+		(_a = this.messageEvents.get(worker)) === null || _a === void 0 || _a.clear();
+		this.messageEvents.delete(worker);
+		worker.onmessage = function(e$1) {
+			if (e$1.data.__emnapi__) {
+				var err = _this_1.printErr;
+				err("received \"" + e$1.data.__emnapi__.type + "\" command from terminated worker: " + tid);
+			}
+		};
+	};
+	ThreadManager$1.prototype.terminateAllThreads = function() {
+		for (var i = 0; i < this.runningWorkers.length; ++i) this.terminateWorker(this.runningWorkers[i]);
+		for (var i = 0; i < this.unusedWorkers.length; ++i) this.terminateWorker(this.unusedWorkers[i]);
+		this.unusedWorkers = [];
+		this.runningWorkers = [];
+		this.pthreads = Object.create(null);
+		this.preparePool();
+	};
+	ThreadManager$1.prototype.addMessageEventListener = function(worker, onMessage) {
+		var listeners = this.messageEvents.get(worker);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.messageEvents.set(worker, listeners);
+		}
+		listeners.add(onMessage);
+		return function() {
+			listeners === null || listeners === void 0 || listeners.delete(onMessage);
+		};
+	};
+	ThreadManager$1.prototype.fireMessageEvent = function(worker, e$1) {
+		var listeners = this.messageEvents.get(worker);
+		if (!listeners) return;
+		var err = this.printErr;
+		listeners.forEach(function(listener) {
+			try {
+				listener(e$1);
+			} catch (e$2) {
+				err(e$2.stack);
+			}
+		});
+	};
+	return ThreadManager$1;
+}();
+var kIsProxy = Symbol("kIsProxy");
+/** @public */
+function createInstanceProxy(instance$1, memory) {
+	if (instance$1[kIsProxy]) return instance$1;
+	var originalExports = instance$1.exports;
+	var createHandler = function(target) {
+		var handlers = [
+			"apply",
+			"construct",
+			"defineProperty",
+			"deleteProperty",
+			"get",
+			"getOwnPropertyDescriptor",
+			"getPrototypeOf",
+			"has",
+			"isExtensible",
+			"ownKeys",
+			"preventExtensions",
+			"set",
+			"setPrototypeOf"
+		];
+		var handler$1 = {};
+		var _loop_1 = function(i$1) {
+			var name_1 = handlers[i$1];
+			handler$1[name_1] = function() {
+				var args$1 = Array.prototype.slice.call(arguments, 1);
+				args$1.unshift(target);
+				return Reflect[name_1].apply(Reflect, args$1);
+			};
+		};
+		for (var i = 0; i < handlers.length; i++) _loop_1(i);
+		return handler$1;
+	};
+	var handler = createHandler(originalExports);
+	var _initialize = function() {};
+	var _start = function() {
+		return 0;
+	};
+	handler.get = function(_target, p, receiver) {
+		var _a;
+		if (p === "memory") return (_a = typeof memory === "function" ? memory() : memory) !== null && _a !== void 0 ? _a : Reflect.get(originalExports, p, receiver);
+		if (p === "_initialize") return p in originalExports ? _initialize : void 0;
+		if (p === "_start") return p in originalExports ? _start : void 0;
+		return Reflect.get(originalExports, p, receiver);
+	};
+	handler.has = function(_target, p) {
+		if (p === "memory") return true;
+		return Reflect.has(originalExports, p);
+	};
+	var exportsProxy = new Proxy(Object.create(null), handler);
+	return new Proxy(instance$1, { get: function(target, p, receiver) {
+		if (p === "exports") return exportsProxy;
+		if (p === kIsProxy) return true;
+		return Reflect.get(target, p, receiver);
+	} });
+}
+var patchedWasiInstances = /* @__PURE__ */ new WeakMap();
+/** @public */
+var WASIThreads = /* @__PURE__ */ function() {
+	function WASIThreads$1(options$1) {
+		var _this_1 = this;
+		if (!options$1) throw new TypeError("WASIThreads(): options is not provided");
+		if (!options$1.wasi) throw new TypeError("WASIThreads(): options.wasi is not provided");
+		patchedWasiInstances.set(this, /* @__PURE__ */ new WeakSet());
+		var wasi = options$1.wasi;
+		patchWasiInstance(this, wasi);
+		this.wasi = wasi;
+		if ("childThread" in options$1) this.childThread = Boolean(options$1.childThread);
+		else this.childThread = false;
+		this.PThread = void 0;
+		if ("threadManager" in options$1) if (typeof options$1.threadManager === "function") this.PThread = options$1.threadManager();
+		else this.PThread = options$1.threadManager;
+		else if (!this.childThread) {
+			this.PThread = new ThreadManager(options$1);
+			this.PThread.init();
+		}
+		var waitThreadStart = false;
+		if ("waitThreadStart" in options$1) waitThreadStart = typeof options$1.waitThreadStart === "number" ? options$1.waitThreadStart : Boolean(options$1.waitThreadStart);
+		var postMessage$2 = getPostMessage(options$1);
+		if (this.childThread && typeof postMessage$2 !== "function") throw new TypeError("options.postMessage is not a function");
+		this.postMessage = postMessage$2;
+		var wasm64 = Boolean(options$1.wasm64);
+		var onMessage = function(e$1) {
+			if (e$1.data.__emnapi__) {
+				var type$1 = e$1.data.__emnapi__.type;
+				var payload = e$1.data.__emnapi__.payload;
+				if (type$1 === "spawn-thread") threadSpawn(payload.startArg, payload.errorOrTid);
+				else if (type$1 === "terminate-all-threads") _this_1.terminateAllThreads();
+			}
+		};
+		var threadSpawn = function(startArg, errorOrTid) {
+			var _a;
+			var EAGAIN = 6;
+			var isNewABI = errorOrTid !== void 0;
+			try {
+				checkSharedWasmMemory(_this_1.wasmMemory);
+			} catch (err) {
+				(_a = _this_1.PThread) === null || _a === void 0 || _a.printErr(err.stack);
+				if (isNewABI) {
+					var struct_1 = new Int32Array(_this_1.wasmMemory.buffer, errorOrTid, 2);
+					Atomics.store(struct_1, 0, 1);
+					Atomics.store(struct_1, 1, EAGAIN);
+					Atomics.notify(struct_1, 1);
+					return 1;
+				} else return -EAGAIN;
+			}
+			if (!isNewABI) {
+				var malloc = _this_1.wasmInstance.exports.malloc;
+				errorOrTid = wasm64 ? Number(malloc(BigInt(8))) : malloc(8);
+				if (!errorOrTid) return -48;
+			}
+			var _free = _this_1.wasmInstance.exports.free;
+			var free = wasm64 ? function(ptr) {
+				_free(BigInt(ptr));
+			} : _free;
+			var struct = new Int32Array(_this_1.wasmMemory.buffer, errorOrTid, 2);
+			Atomics.store(struct, 0, 0);
+			Atomics.store(struct, 1, 0);
+			if (_this_1.childThread) {
+				postMessage$2(createMessage("spawn-thread", {
+					startArg,
+					errorOrTid
+				}));
+				Atomics.wait(struct, 1, 0);
+				var isError = Atomics.load(struct, 0);
+				var result = Atomics.load(struct, 1);
+				if (isNewABI) return isError;
+				free(errorOrTid);
+				return isError ? -result : result;
+			}
+			var shouldWait = waitThreadStart || waitThreadStart === 0;
+			var sab;
+			if (shouldWait) {
+				sab = new Int32Array(new SharedArrayBuffer(8208));
+				Atomics.store(sab, 0, 0);
+			}
+			var worker;
+			var tid;
+			var PThread = _this_1.PThread;
+			try {
+				worker = PThread.getNewWorker(sab);
+				if (!worker) throw new Error("failed to get new worker");
+				PThread.addMessageEventListener(worker, onMessage);
+				tid = PThread.markId(worker);
+				if (ENVIRONMENT_IS_NODE) worker.ref();
+				worker.postMessage(createMessage("start", {
+					tid,
+					arg: startArg,
+					sab
+				}));
+				if (shouldWait) {
+					if (typeof waitThreadStart === "number") {
+						if (Atomics.wait(sab, 0, 0, waitThreadStart) === "timed-out") {
+							try {
+								PThread.cleanThread(worker, tid, true);
+							} catch (_) {}
+							throw new Error("Spawning thread timed out. Please check if the worker is created successfully and if message is handled properly in the worker.");
+						}
+					} else Atomics.wait(sab, 0, 0);
+					if (Atomics.load(sab, 0) > 1) {
+						try {
+							PThread.cleanThread(worker, tid, true);
+						} catch (_) {}
+						throw deserizeErrorFromBuffer(sab.buffer);
+					}
+				}
+			} catch (e$1) {
+				Atomics.store(struct, 0, 1);
+				Atomics.store(struct, 1, EAGAIN);
+				Atomics.notify(struct, 1);
+				PThread === null || PThread === void 0 || PThread.printErr(e$1.stack);
+				if (isNewABI) return 1;
+				free(errorOrTid);
+				return -EAGAIN;
+			}
+			Atomics.store(struct, 0, 0);
+			Atomics.store(struct, 1, tid);
+			Atomics.notify(struct, 1);
+			PThread.runningWorkers.push(worker);
+			if (!shouldWait) worker.whenLoaded.catch(function(err) {
+				delete worker.whenLoaded;
+				PThread.cleanThread(worker, tid, true);
+				throw err;
+			});
+			if (isNewABI) return 0;
+			free(errorOrTid);
+			return tid;
+		};
+		this.threadSpawn = threadSpawn;
 	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
-	if (typeof require !== "undefined") return require.apply(this, arguments);
-	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
-});
+	WASIThreads$1.prototype.getImportObject = function() {
+		return { wasi: { "thread-spawn": this.threadSpawn } };
+	};
+	WASIThreads$1.prototype.setup = function(wasmInstance, wasmModule, wasmMemory) {
+		wasmMemory !== null && wasmMemory !== void 0 || (wasmMemory = wasmInstance.exports.memory);
+		this.wasmInstance = wasmInstance;
+		this.wasmMemory = wasmMemory;
+		if (this.PThread) this.PThread.setup(wasmModule, wasmMemory);
+	};
+	WASIThreads$1.prototype.preloadWorkers = function() {
+		if (this.PThread) return this.PThread.preloadWorkers();
+		return Promise.resolve([]);
+	};
+	/**
+	* It's ok to call this method to a WASI command module.
+	*
+	* in child thread, must call this method instead of {@link WASIThreads.start} even if it's a WASI command module
+	*
+	* @returns A proxied WebAssembly instance if in child thread, other wise the original instance
+	*/
+	WASIThreads$1.prototype.initialize = function(instance$1, module, memory) {
+		var exports = instance$1.exports;
+		memory !== null && memory !== void 0 || (memory = exports.memory);
+		if (this.childThread) instance$1 = createInstanceProxy(instance$1, memory);
+		this.setup(instance$1, module, memory);
+		var wasi = this.wasi;
+		if ("_start" in exports && typeof exports._start === "function") if (this.childThread) {
+			wasi.start(instance$1);
+			try {
+				var kStarted$1 = getWasiSymbol(wasi, "kStarted");
+				wasi[kStarted$1] = false;
+			} catch (_) {}
+		} else setupInstance(wasi, instance$1);
+		else wasi.initialize(instance$1);
+		return instance$1;
+	};
+	/**
+	* Equivalent to calling {@link WASIThreads.initialize} and then calling {@link WASIInstance.start}
+	* ```js
+	* this.initialize(instance, module, memory)
+	* this.wasi.start(instance)
+	* ```
+	*/
+	WASIThreads$1.prototype.start = function(instance$1, module, memory) {
+		var exports = instance$1.exports;
+		memory !== null && memory !== void 0 || (memory = exports.memory);
+		if (this.childThread) instance$1 = createInstanceProxy(instance$1, memory);
+		this.setup(instance$1, module, memory);
+		return {
+			exitCode: this.wasi.start(instance$1),
+			instance: instance$1
+		};
+	};
+	WASIThreads$1.prototype.terminateAllThreads = function() {
+		var _a;
+		if (!this.childThread) (_a = this.PThread) === null || _a === void 0 || _a.terminateAllThreads();
+		else this.postMessage(createMessage("terminate-all-threads", {}));
+	};
+	return WASIThreads$1;
+}();
+function patchWasiInstance(wasiThreads, wasi) {
+	var patched = patchedWasiInstances.get(wasiThreads);
+	if (patched.has(wasi)) return;
+	var _this = wasiThreads;
+	var wasiImport = wasi.wasiImport;
+	if (wasiImport) {
+		var proc_exit_1 = wasiImport.proc_exit;
+		wasiImport.proc_exit = function(code$1) {
+			_this.terminateAllThreads();
+			return proc_exit_1.call(this, code$1);
+		};
+	}
+	if (!_this.childThread) {
+		var start_1 = wasi.start;
+		if (typeof start_1 === "function") wasi.start = function(instance$1) {
+			try {
+				return start_1.call(this, instance$1);
+			} catch (err) {
+				if (isTrapError(err)) _this.terminateAllThreads();
+				throw err;
+			}
+		};
+	}
+	patched.add(wasi);
+}
+function getWasiSymbol(wasi, description$1) {
+	var symbols = Object.getOwnPropertySymbols(wasi);
+	var selectDescription = function(description$2) {
+		return function(s) {
+			if (s.description) return s.description === description$2;
+			return s.toString() === "Symbol(".concat(description$2, ")");
+		};
+	};
+	if (Array.isArray(description$1)) return description$1.map(function(d) {
+		return symbols.filter(selectDescription(d))[0];
+	});
+	return symbols.filter(selectDescription(description$1))[0];
+}
+function setupInstance(wasi, instance$1) {
+	var _a = getWasiSymbol(wasi, ["kInstance", "kSetMemory"]), kInstance$1 = _a[0], kSetMemory$1 = _a[1];
+	wasi[kInstance$1] = instance$1;
+	wasi[kSetMemory$1](instance$1.exports.memory);
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
@@ -70,20 +654,10 @@ function __extends$1(d, b) {
 	}
 	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
-var __assign$1 = function() {
-	__assign$1 = Object.assign || function __assign$2(t$2) {
-		for (var s, i = 1, n$1 = arguments.length; i < n$1; i++) {
-			s = arguments[i];
-			for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t$2[p] = s[p];
-		}
-		return t$2;
-	};
-	return __assign$1.apply(this, arguments);
-};
 
 //#endregion
 //#region ../../node_modules/.pnpm/@emnapi+core@1.8.1/node_modules/@emnapi/core/dist/emnapi-core.esm-bundler.js
-var _WebAssembly = typeof WebAssembly !== "undefined" ? WebAssembly : typeof WXWebAssembly !== "undefined" ? WXWebAssembly : void 0;
+var _WebAssembly$1 = typeof WebAssembly !== "undefined" ? WebAssembly : typeof WXWebAssembly !== "undefined" ? WXWebAssembly : void 0;
 function validateImports(imports) {
 	if (imports && typeof imports !== "object") throw new TypeError("imports must be an object or undefined");
 	return true;
@@ -98,22 +672,22 @@ function load(wasmInput, imports) {
 			return load(input, imports);
 		});
 	} catch (_) {}
-	if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) return _WebAssembly.instantiate(wasmInput, imports);
-	if (wasmInput instanceof _WebAssembly.Module) return _WebAssembly.instantiate(wasmInput, imports).then(function(instance$1) {
+	if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) return _WebAssembly$1.instantiate(wasmInput, imports);
+	if (wasmInput instanceof _WebAssembly$1.Module) return _WebAssembly$1.instantiate(wasmInput, imports).then(function(instance$1) {
 		return {
 			instance: instance$1,
 			module: wasmInput
 		};
 	});
 	if (typeof Response !== "undefined" && wasmInput instanceof Response) return wasmInput.arrayBuffer().then(function(buffer) {
-		return _WebAssembly.instantiate(buffer, imports);
+		return _WebAssembly$1.instantiate(buffer, imports);
 	});
 	var inputIsString = typeof wasmInput === "string";
 	if (inputIsString || typeof URL !== "undefined" && wasmInput instanceof URL) {
-		if (inputIsString && typeof wx !== "undefined" && typeof __wxConfig !== "undefined") return _WebAssembly.instantiate(wasmInput, imports);
+		if (inputIsString && typeof wx !== "undefined" && typeof __wxConfig !== "undefined") return _WebAssembly$1.instantiate(wasmInput, imports);
 		if (typeof fetch !== "function") throw new TypeError("wasm source can not be a string or URL in this environment");
-		if (typeof _WebAssembly.instantiateStreaming === "function") try {
-			return _WebAssembly.instantiateStreaming(fetch(wasmInput), imports).catch(function() {
+		if (typeof _WebAssembly$1.instantiateStreaming === "function") try {
+			return _WebAssembly$1.instantiateStreaming(fetch(wasmInput), imports).catch(function() {
 				return load(fetch(wasmInput), imports);
 			});
 		} catch (_) {
@@ -123,22 +697,9 @@ function load(wasmInput, imports) {
 	}
 	throw new TypeError("Invalid wasm source");
 }
-function loadSync(wasmInput, imports) {
-	if (!wasmInput) throw new TypeError("Invalid wasm source");
-	validateImports(imports);
-	imports = imports !== null && imports !== void 0 ? imports : {};
-	var module;
-	if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) module = new _WebAssembly.Module(wasmInput);
-	else if (wasmInput instanceof WebAssembly.Module) module = wasmInput;
-	else throw new TypeError("Invalid wasm source");
-	return {
-		instance: new _WebAssembly.Instance(module, imports),
-		module
-	};
-}
 function createNapiModule(options$1) {
 	return (function() {
-		var ENVIRONMENT_IS_NODE = typeof process === "object" && process !== null && typeof process.versions === "object" && process.versions !== null && typeof process.versions.node === "string";
+		var ENVIRONMENT_IS_NODE$1 = typeof process === "object" && process !== null && typeof process.versions === "object" && process.versions !== null && typeof process.versions.node === "string";
 		var ENVIRONMENT_IS_PTHREAD = Boolean(options$1.childThread);
 		var waitThreadStart = typeof options$1.waitThreadStart === "number" ? options$1.waitThreadStart : Boolean(options$1.waitThreadStart);
 		var wasmInstance;
@@ -147,7 +708,7 @@ function createNapiModule(options$1) {
 		var _malloc;
 		var _free;
 		function abort(msg) {
-			if (typeof _WebAssembly.RuntimeError === "function") throw new _WebAssembly.RuntimeError(msg);
+			if (typeof _WebAssembly$1.RuntimeError === "function") throw new _WebAssembly$1.RuntimeError(msg);
 			throw Error(msg);
 		}
 		var napiModule = {
@@ -175,9 +736,9 @@ function createNapiModule(options$1) {
 				var module = options$2.module;
 				var memory = options$2.memory || exports$1.memory;
 				var table = options$2.table || exports$1.__indirect_function_table;
-				if (!(module instanceof _WebAssembly.Module)) throw new TypeError("Invalid wasm module");
-				if (!(memory instanceof _WebAssembly.Memory)) throw new TypeError("Invalid wasm memory");
-				if (!(table instanceof _WebAssembly.Table)) throw new TypeError("Invalid wasm table");
+				if (!(module instanceof _WebAssembly$1.Module)) throw new TypeError("Invalid wasm module");
+				if (!(memory instanceof _WebAssembly$1.Memory)) throw new TypeError("Invalid wasm memory");
+				if (!(table instanceof _WebAssembly$1.Table)) throw new TypeError("Invalid wasm table");
 				wasmMemory = memory;
 				wasmTable = table;
 				if (typeof exports$1.malloc !== "function") throw new TypeError("malloc is not exported");
@@ -254,7 +815,7 @@ function createNapiModule(options$1) {
 			if (!worker) return false;
 			if (worker._emnapiSendListener) return true;
 			var handler = function(e$1) {
-				var __emnapi__ = (ENVIRONMENT_IS_NODE ? e$1 : e$1.data).__emnapi__;
+				var __emnapi__ = (ENVIRONMENT_IS_NODE$1 ? e$1 : e$1.data).__emnapi__;
 				if (__emnapi__ && __emnapi__.type === "async-send") if (ENVIRONMENT_IS_PTHREAD) {
 					var postMessage_1 = napiModule.postMessage;
 					postMessage_1({ __emnapi__ });
@@ -264,7 +825,7 @@ function createNapiModule(options$1) {
 				}
 			};
 			var dispose = function() {
-				if (ENVIRONMENT_IS_NODE) worker.off("message", handler);
+				if (ENVIRONMENT_IS_NODE$1) worker.off("message", handler);
 				else worker.removeEventListener("message", handler, false);
 				delete worker._emnapiSendListener;
 			};
@@ -272,7 +833,7 @@ function createNapiModule(options$1) {
 				handler,
 				dispose
 			};
-			if (ENVIRONMENT_IS_NODE) worker.on("message", handler);
+			if (ENVIRONMENT_IS_NODE$1) worker.on("message", handler);
 			else worker.addEventListener("message", handler, false);
 			return true;
 		}
@@ -388,7 +949,7 @@ function createNapiModule(options$1) {
 		* @__sig i
 		*/
 		function _emnapi_is_main_browser_thread() {
-			return typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE ? 1 : 0;
+			return typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE$1 ? 1 : 0;
 		}
 		/**
 		* @__sig v
@@ -475,10 +1036,10 @@ function createNapiModule(options$1) {
 			}
 		}
 		var uvThreadpoolReadyResolve;
-		var uvThreadpoolReady = new Promise(function(resolve$1) {
+		var uvThreadpoolReady = new Promise(function(resolve$2) {
 			uvThreadpoolReadyResolve = function() {
 				uvThreadpoolReady.ready = true;
-				resolve$1();
+				resolve$2();
 			};
 		});
 		uvThreadpoolReady.ready = false;
@@ -495,17 +1056,17 @@ function createNapiModule(options$1) {
 			var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);
 			var _loop_1 = function(i$1) {
 				var worker = emnapiGetWorkerByPthreadPtr(HEAP_DATA_VIEW.getUint32(threads + i$1 * 4, true));
-				p.push(new Promise(function(resolve$1) {
+				p.push(new Promise(function(resolve$2) {
 					var handler = function(e$1) {
-						var __emnapi__ = (ENVIRONMENT_IS_NODE ? e$1 : e$1.data).__emnapi__;
+						var __emnapi__ = (ENVIRONMENT_IS_NODE$1 ? e$1 : e$1.data).__emnapi__;
 						if (__emnapi__ && __emnapi__.type === "async-thread-ready") {
-							resolve$1();
+							resolve$2();
 							if (worker && typeof worker.unref === "function") worker.unref();
-							if (ENVIRONMENT_IS_NODE) worker.off("message", handler);
+							if (ENVIRONMENT_IS_NODE$1) worker.off("message", handler);
 							else worker.removeEventListener("message", handler);
 						}
 					};
-					if (ENVIRONMENT_IS_NODE) worker.on("message", handler);
+					if (ENVIRONMENT_IS_NODE$1) worker.on("message", handler);
 					else worker.addEventListener("message", handler);
 				}));
 			};
@@ -869,7 +1430,7 @@ function createNapiModule(options$1) {
 				if (!worker) return false;
 				if (worker._emnapiTSFNListener) return true;
 				var handler = function(e$1) {
-					var __emnapi__ = (ENVIRONMENT_IS_NODE ? e$1 : e$1.data).__emnapi__;
+					var __emnapi__ = (ENVIRONMENT_IS_NODE$1 ? e$1 : e$1.data).__emnapi__;
 					if (__emnapi__) {
 						var type$1 = __emnapi__.type;
 						var payload = __emnapi__.payload;
@@ -877,7 +1438,7 @@ function createNapiModule(options$1) {
 					}
 				};
 				var dispose = function() {
-					if (ENVIRONMENT_IS_NODE) worker.off("message", handler);
+					if (ENVIRONMENT_IS_NODE$1) worker.off("message", handler);
 					else worker.removeEventListener("message", handler, false);
 					delete worker._emnapiTSFNListener;
 				};
@@ -885,7 +1446,7 @@ function createNapiModule(options$1) {
 					handler,
 					dispose
 				};
-				if (ENVIRONMENT_IS_NODE) worker.on("message", handler);
+				if (ENVIRONMENT_IS_NODE$1) worker.on("message", handler);
 				else worker.addEventListener("message", handler, false);
 				return true;
 			},
@@ -941,7 +1502,7 @@ function createNapiModule(options$1) {
 					var isClosing = emnapiTSFN.getIsClosing(func);
 					return queueSize >= maxSize && maxSize > 0 && !isClosing;
 				};
-				var isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE;
+				var isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE$1;
 				return mutex.execute(function() {
 					while (waitCondition()) {
 						if (mode === 0) return 15;
@@ -971,7 +1532,7 @@ function createNapiModule(options$1) {
 				var index = func + emnapiTSFN.offset.mutex;
 				var mutex = {
 					lock: function() {
-						var isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE;
+						var isBrowserMain = typeof window !== "undefined" && typeof document !== "undefined" && !ENVIRONMENT_IS_NODE$1;
 						var i32a = new Int32Array(wasmMemory.buffer, index, 1);
 						if (isBrowserMain) while (true) {
 							var oldValue = Atomics.compareExchange(i32a, 0, 0, 1);
@@ -1434,7 +1995,7 @@ function createNapiModule(options$1) {
 				if (!worker) return false;
 				if (worker._emnapiAWMTListener) return true;
 				var handler = function(e$1) {
-					var __emnapi__ = (ENVIRONMENT_IS_NODE ? e$1 : e$1.data).__emnapi__;
+					var __emnapi__ = (ENVIRONMENT_IS_NODE$1 ? e$1 : e$1.data).__emnapi__;
 					if (__emnapi__) {
 						var type$1 = __emnapi__.type;
 						var payload = __emnapi__.payload;
@@ -1449,7 +2010,7 @@ function createNapiModule(options$1) {
 					}
 				};
 				var dispose = function() {
-					if (ENVIRONMENT_IS_NODE) worker.off("message", handler);
+					if (ENVIRONMENT_IS_NODE$1) worker.off("message", handler);
 					else worker.removeEventListener("message", handler, false);
 					delete worker._emnapiAWMTListener;
 				};
@@ -1457,7 +2018,7 @@ function createNapiModule(options$1) {
 					handler,
 					dispose
 				};
-				if (ENVIRONMENT_IS_NODE) worker.on("message", handler);
+				if (ENVIRONMENT_IS_NODE$1) worker.on("message", handler);
 				else worker.addEventListener("message", handler, false);
 				return true;
 			},
@@ -4579,9 +5140,9 @@ function createNapiModule(options$1) {
 				if (!deferred) return envObject.setLastError(1);
 				if (!promise$1) return envObject.setLastError(1);
 				var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);
-				var p = new Promise(function(resolve$1, reject) {
+				var p = new Promise(function(resolve$2, reject) {
 					deferredObjectId = emnapiCtx.createDeferred({
-						resolve: resolve$1,
+						resolve: resolve$2,
 						reject
 					}).id;
 					HEAP_DATA_VIEW.setUint32(deferred, deferredObjectId, true);
@@ -5574,10 +6135,10 @@ function createNapiModule(options$1) {
 }
 function loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options$1) {
 	options$1 = options$1 !== null && options$1 !== void 0 ? options$1 : {};
-	var getMemory = options$1.getMemory;
+	var getMemory$1 = options$1.getMemory;
 	var getTable = options$1.getTable;
 	var beforeInit = options$1.beforeInit;
-	if (getMemory != null && typeof getMemory !== "function") throw new TypeError("options.getMemory is not a function");
+	if (getMemory$1 != null && typeof getMemory$1 !== "function") throw new TypeError("options.getMemory is not a function");
 	if (getTable != null && typeof getTable !== "function") throw new TypeError("options.getTable is not a function");
 	if (beforeInit != null && typeof beforeInit !== "function") throw new TypeError("options.beforeInit is not a function");
 	var napiModule;
@@ -5618,7 +6179,7 @@ function loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options$1) {
 		var originalExports = originalInstance.exports;
 		var exportMemory = "memory" in originalExports;
 		var importMemory = "memory" in importObject.env;
-		var memory = getMemory ? getMemory(originalExports) : exportMemory ? originalExports.memory : importMemory ? importObject.env.memory : void 0;
+		var memory = getMemory$1 ? getMemory$1(originalExports) : exportMemory ? originalExports.memory : importMemory ? importObject.env.memory : void 0;
 		if (!memory) throw new Error("memory is neither exported nor imported");
 		var table = getTable ? getTable(originalExports) : originalExports.__indirect_function_table;
 		if (wasi && !exportMemory) {
@@ -5663,71 +6224,10 @@ function loadCallback(wasmInput, importObject, callback) {
 		return callback(err);
 	});
 }
-function loadSyncCallback(wasmInput, importObject, callback) {
-	var source;
-	try {
-		source = loadSync(wasmInput, importObject);
-	} catch (err) {
-		return callback(err);
-	}
-	return callback(null, source);
-}
 /** @public */
 function instantiateNapiModule(wasmInput, options$1) {
 	return loadNapiModuleImpl(loadCallback, void 0, wasmInput, options$1);
 }
-/** @public */
-function instantiateNapiModuleSync(wasmInput, options$1) {
-	return loadNapiModuleImpl(loadSyncCallback, void 0, wasmInput, options$1);
-}
-/** @public */
-var MessageHandler = /* @__PURE__ */ function(_super) {
-	__extends$1(MessageHandler$1, _super);
-	function MessageHandler$1(options$1) {
-		var _this = this;
-		if (typeof options$1.onLoad !== "function") throw new TypeError("options.onLoad is not a function");
-		var userOnError = options$1.onError;
-		_this = _super.call(this, __assign$1(__assign$1({}, options$1), { onError: function(err, type$1) {
-			var _a;
-			var emnapi_thread_crashed = (_a = _this.instance) === null || _a === void 0 ? void 0 : _a.exports.emnapi_thread_crashed;
-			if (typeof emnapi_thread_crashed === "function") emnapi_thread_crashed();
-			if (typeof userOnError === "function") userOnError(err, type$1);
-			else throw err;
-		} })) || this;
-		_this.napiModule = void 0;
-		return _this;
-	}
-	MessageHandler$1.prototype.instantiate = function(data) {
-		var _this = this;
-		var source = this.onLoad(data);
-		if (typeof source.then === "function") return source.then(function(result) {
-			_this.napiModule = result.napiModule;
-			return result;
-		});
-		this.napiModule = source.napiModule;
-		return source;
-	};
-	MessageHandler$1.prototype.handle = function(e$1) {
-		var _this = this;
-		var _a;
-		_super.prototype.handle.call(this, e$1);
-		if ((_a = e$1 === null || e$1 === void 0 ? void 0 : e$1.data) === null || _a === void 0 ? void 0 : _a.__emnapi__) {
-			var type$1 = e$1.data.__emnapi__.type;
-			var payload_1 = e$1.data.__emnapi__.payload;
-			try {
-				if (type$1 === "async-worker-init") this.handleAfterLoad(e$1, function() {
-					_this.napiModule.initWorker(payload_1.arg);
-				});
-				else if (type$1 === "async-work-execute") this.handleAfterLoad(e$1, function() {
-					_this.napiModule.executeAsyncWork(payload_1.work);
-				});
-			} catch (err) {
-				this.onError(err, type$1);
-			}
-		}
-	};
-	return MessageHandler$1;
-}(ThreadMessageHandler);
 
 //#endregion
 //#region ../../node_modules/.pnpm/@emnapi+runtime@1.8.1/node_modules/@emnapi/runtime/dist/emnapi.esm-bundler.js
@@ -6951,24 +7451,1991 @@ function getDefaultContext() {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.1/node_modules/@napi-rs/wasm-runtime/fs-proxy.js
-/**
-* @param {unknown} value
-*/
-const getType = (value) => {
-	if (value === void 0) return 0;
-	if (value === null) return 1;
-	const t$2 = typeof value;
-	if (t$2 === "boolean") return 2;
-	if (t$2 === "number") return 3;
-	if (t$2 === "string") return 4;
-	if (t$2 === "object") return 6;
-	if (t$2 === "bigint") return 9;
-	return -1;
+//#region ../../node_modules/.pnpm/@tybys+wasm-util@0.10.1/node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js
+const _WebAssembly = typeof WebAssembly !== "undefined" ? WebAssembly : typeof WXWebAssembly !== "undefined" ? WXWebAssembly : void 0;
+if (!_WebAssembly) throw new Error("WebAssembly is not supported in this environment");
+function validateObject(value, name) {
+	if (value === null || typeof value !== "object") throw new TypeError(`${name} must be an object. Received ${value === null ? "null" : typeof value}`);
+}
+function validateArray(value, name) {
+	if (!Array.isArray(value)) throw new TypeError(`${name} must be an array. Received ${value === null ? "null" : typeof value}`);
+}
+function validateBoolean(value, name) {
+	if (typeof value !== "boolean") throw new TypeError(`${name} must be a boolean. Received ${value === null ? "null" : typeof value}`);
+}
+function validateString(value, name) {
+	if (typeof value !== "string") throw new TypeError(`${name} must be a string. Received ${value === null ? "null" : typeof value}`);
+}
+function validateFunction(value, name) {
+	if (typeof value !== "function") throw new TypeError(`${name} must be a function. Received ${value === null ? "null" : typeof value}`);
+}
+function validateUndefined(value, name) {
+	if (value !== void 0) throw new TypeError(`${name} must be undefined. Received ${value === null ? "null" : typeof value}`);
+}
+function isPromiseLike(obj) {
+	return !!(obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function");
+}
+function sleepBreakIf(delay, breakIf) {
+	const end = Date.now() + delay;
+	let ret = false;
+	while (Date.now() < end) if (breakIf()) {
+		ret = true;
+		break;
+	}
+	return ret;
+}
+function unsharedSlice(view, start, end) {
+	return typeof SharedArrayBuffer === "function" && view.buffer instanceof SharedArrayBuffer || Object.prototype.toString.call(view.buffer.constructor) === "[object SharedArrayBuffer]" ? view.slice(start, end) : view.subarray(start, end);
+}
+const CHAR_DOT = 46;
+const CHAR_FORWARD_SLASH = 47;
+function isPosixPathSeparator(code$1) {
+	return code$1 === CHAR_FORWARD_SLASH;
+}
+function normalizeString$1(path$1, allowAboveRoot, separator, isPathSeparator) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let code$1 = 0;
+	for (let i = 0; i <= path$1.length; ++i) {
+		if (i < path$1.length) code$1 = path$1.charCodeAt(i);
+		else if (isPathSeparator(code$1)) break;
+		else code$1 = CHAR_FORWARD_SLASH;
+		if (isPathSeparator(code$1)) {
+			if (lastSlash === i - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+					if (res.length > 2) {
+						const lastSlashIndex = res.indexOf(separator);
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.indexOf(separator);
+						}
+						lastSlash = i;
+						dots = 0;
+						continue;
+					} else if (res.length !== 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = i;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? `${separator}..` : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `${separator}${path$1.slice(lastSlash + 1, i)}`;
+				else res = path$1.slice(lastSlash + 1, i);
+				lastSegmentLength = i - lastSlash - 1;
+			}
+			lastSlash = i;
+			dots = 0;
+		} else if (code$1 === CHAR_DOT && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+function resolve$1(...args$1) {
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let i = args$1.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+		const path$1 = i >= 0 ? args$1[i] : "/";
+		validateString(path$1, "path");
+		if (path$1.length === 0) continue;
+		resolvedPath = `${path$1}/${resolvedPath}`;
+		resolvedAbsolute = path$1.charCodeAt(0) === CHAR_FORWARD_SLASH;
+	}
+	resolvedPath = normalizeString$1(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
+	if (resolvedAbsolute) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+}
+const WasiRights = {
+	FD_DATASYNC: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(0),
+	FD_READ: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(1),
+	FD_SEEK: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(2),
+	FD_FDSTAT_SET_FLAGS: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(3),
+	FD_SYNC: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(4),
+	FD_TELL: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(5),
+	FD_WRITE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(6),
+	FD_ADVISE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(7),
+	FD_ALLOCATE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(8),
+	PATH_CREATE_DIRECTORY: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(9),
+	PATH_CREATE_FILE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(10),
+	PATH_LINK_SOURCE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(11),
+	PATH_LINK_TARGET: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(12),
+	PATH_OPEN: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(13),
+	FD_READDIR: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(14),
+	PATH_READLINK: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(15),
+	PATH_RENAME_SOURCE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(16),
+	PATH_RENAME_TARGET: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(17),
+	PATH_FILESTAT_GET: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(18),
+	PATH_FILESTAT_SET_SIZE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(19),
+	PATH_FILESTAT_SET_TIMES: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(20),
+	FD_FILESTAT_GET: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(21),
+	FD_FILESTAT_SET_SIZE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(22),
+	FD_FILESTAT_SET_TIMES: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(23),
+	PATH_SYMLINK: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(24),
+	PATH_REMOVE_DIRECTORY: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(25),
+	PATH_UNLINK_FILE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(26),
+	POLL_FD_READWRITE: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(27),
+	SOCK_SHUTDOWN: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(28),
+	SOCK_ACCEPT: /* @__PURE__ */ BigInt(1) << /* @__PURE__ */ BigInt(29)
 };
-/**
-* @param {import('memfs').IFs} memfs
-* @param {any} value
+function strerror(errno) {
+	switch (errno) {
+		case 0: return "Success";
+		case 1: return "Argument list too long";
+		case 2: return "Permission denied";
+		case 3: return "Address in use";
+		case 4: return "Address not available";
+		case 5: return "Address family not supported by protocol";
+		case 6: return "Resource temporarily unavailable";
+		case 7: return "Operation already in progress";
+		case 8: return "Bad file descriptor";
+		case 9: return "Bad message";
+		case 10: return "Resource busy";
+		case 11: return "Operation canceled";
+		case 12: return "No child process";
+		case 13: return "Connection aborted";
+		case 14: return "Connection refused";
+		case 15: return "Connection reset by peer";
+		case 16: return "Resource deadlock would occur";
+		case 17: return "Destination address required";
+		case 18: return "Domain error";
+		case 19: return "Quota exceeded";
+		case 20: return "File exists";
+		case 21: return "Bad address";
+		case 22: return "File too large";
+		case 23: return "Host is unreachable";
+		case 24: return "Identifier removed";
+		case 25: return "Illegal byte sequence";
+		case 26: return "Operation in progress";
+		case 27: return "Interrupted system call";
+		case 28: return "Invalid argument";
+		case 29: return "I/O error";
+		case 30: return "Socket is connected";
+		case 31: return "Is a directory";
+		case 32: return "Symbolic link loop";
+		case 33: return "No file descriptors available";
+		case 34: return "Too many links";
+		case 35: return "Message too large";
+		case 36: return "Multihop attempted";
+		case 37: return "Filename too long";
+		case 38: return "Network is down";
+		case 39: return "Connection reset by network";
+		case 40: return "Network unreachable";
+		case 41: return "Too many files open in system";
+		case 42: return "No buffer space available";
+		case 43: return "No such device";
+		case 44: return "No such file or directory";
+		case 45: return "Exec format error";
+		case 46: return "No locks available";
+		case 47: return "Link has been severed";
+		case 48: return "Out of memory";
+		case 49: return "No message of the desired type";
+		case 50: return "Protocol not available";
+		case 51: return "No space left on device";
+		case 52: return "Function not implemented";
+		case 53: return "Socket not connected";
+		case 54: return "Not a directory";
+		case 55: return "Directory not empty";
+		case 56: return "State not recoverable";
+		case 57: return "Not a socket";
+		case 58: return "Not supported";
+		case 59: return "Not a tty";
+		case 60: return "No such device or address";
+		case 61: return "Value too large for data type";
+		case 62: return "Previous owner died";
+		case 63: return "Operation not permitted";
+		case 64: return "Broken pipe";
+		case 65: return "Protocol error";
+		case 66: return "Protocol not supported";
+		case 67: return "Protocol wrong type for socket";
+		case 68: return "Result not representable";
+		case 69: return "Read-only file system";
+		case 70: return "Invalid seek";
+		case 71: return "No such process";
+		case 72: return "Stale file handle";
+		case 73: return "Operation timed out";
+		case 74: return "Text file busy";
+		case 75: return "Cross-device link";
+		case 76: return "Capabilities insufficient";
+		default: return "Unknown error";
+	}
+}
+var WasiError = class extends Error {
+	constructor(message, errno) {
+		super(message);
+		this.errno = errno;
+	}
+	getErrorMessage() {
+		return strerror(this.errno);
+	}
+};
+Object.defineProperty(WasiError.prototype, "name", {
+	configurable: true,
+	writable: true,
+	value: "WasiError"
+});
+const RIGHTS_ALL = WasiRights.FD_DATASYNC | WasiRights.FD_READ | WasiRights.FD_SEEK | WasiRights.FD_FDSTAT_SET_FLAGS | WasiRights.FD_SYNC | WasiRights.FD_TELL | WasiRights.FD_WRITE | WasiRights.FD_ADVISE | WasiRights.FD_ALLOCATE | WasiRights.PATH_CREATE_DIRECTORY | WasiRights.PATH_CREATE_FILE | WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET | WasiRights.PATH_OPEN | WasiRights.FD_READDIR | WasiRights.PATH_READLINK | WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET | WasiRights.PATH_FILESTAT_GET | WasiRights.PATH_FILESTAT_SET_SIZE | WasiRights.PATH_FILESTAT_SET_TIMES | WasiRights.FD_FILESTAT_GET | WasiRights.FD_FILESTAT_SET_TIMES | WasiRights.FD_FILESTAT_SET_SIZE | WasiRights.PATH_SYMLINK | WasiRights.PATH_UNLINK_FILE | WasiRights.PATH_REMOVE_DIRECTORY | WasiRights.POLL_FD_READWRITE | WasiRights.SOCK_SHUTDOWN | WasiRights.SOCK_ACCEPT;
+const BLOCK_DEVICE_BASE = RIGHTS_ALL;
+const BLOCK_DEVICE_INHERITING = RIGHTS_ALL;
+const CHARACTER_DEVICE_BASE = RIGHTS_ALL;
+const CHARACTER_DEVICE_INHERITING = RIGHTS_ALL;
+const REGULAR_FILE_BASE = WasiRights.FD_DATASYNC | WasiRights.FD_READ | WasiRights.FD_SEEK | WasiRights.FD_FDSTAT_SET_FLAGS | WasiRights.FD_SYNC | WasiRights.FD_TELL | WasiRights.FD_WRITE | WasiRights.FD_ADVISE | WasiRights.FD_ALLOCATE | WasiRights.FD_FILESTAT_GET | WasiRights.FD_FILESTAT_SET_SIZE | WasiRights.FD_FILESTAT_SET_TIMES | WasiRights.POLL_FD_READWRITE;
+const REGULAR_FILE_INHERITING = /* @__PURE__ */ BigInt(0);
+const DIRECTORY_BASE = WasiRights.FD_FDSTAT_SET_FLAGS | WasiRights.FD_SYNC | WasiRights.FD_ADVISE | WasiRights.PATH_CREATE_DIRECTORY | WasiRights.PATH_CREATE_FILE | WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET | WasiRights.PATH_OPEN | WasiRights.FD_READDIR | WasiRights.PATH_READLINK | WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET | WasiRights.PATH_FILESTAT_GET | WasiRights.PATH_FILESTAT_SET_SIZE | WasiRights.PATH_FILESTAT_SET_TIMES | WasiRights.FD_FILESTAT_GET | WasiRights.FD_FILESTAT_SET_TIMES | WasiRights.PATH_SYMLINK | WasiRights.PATH_UNLINK_FILE | WasiRights.PATH_REMOVE_DIRECTORY | WasiRights.POLL_FD_READWRITE;
+const DIRECTORY_INHERITING = DIRECTORY_BASE | REGULAR_FILE_BASE;
+const SOCKET_BASE = WasiRights.FD_READ | WasiRights.FD_FDSTAT_SET_FLAGS | WasiRights.FD_WRITE | WasiRights.FD_FILESTAT_GET | WasiRights.POLL_FD_READWRITE | WasiRights.SOCK_SHUTDOWN;
+const SOCKET_INHERITING = RIGHTS_ALL;
+const TTY_BASE = WasiRights.FD_READ | WasiRights.FD_FDSTAT_SET_FLAGS | WasiRights.FD_WRITE | WasiRights.FD_FILESTAT_GET | WasiRights.POLL_FD_READWRITE;
+const TTY_INHERITING = /* @__PURE__ */ BigInt(0);
+function getRights(stdio, fd, flags, type$1) {
+	const ret = {
+		base: BigInt(0),
+		inheriting: BigInt(0)
+	};
+	if (type$1 === 0) throw new WasiError("Unknown file type", 28);
+	switch (type$1) {
+		case 4:
+			ret.base = REGULAR_FILE_BASE;
+			ret.inheriting = REGULAR_FILE_INHERITING;
+			break;
+		case 3:
+			ret.base = DIRECTORY_BASE;
+			ret.inheriting = DIRECTORY_INHERITING;
+			break;
+		case 6:
+		case 5:
+			ret.base = SOCKET_BASE;
+			ret.inheriting = SOCKET_INHERITING;
+			break;
+		case 2:
+			if (stdio.indexOf(fd) !== -1) {
+				ret.base = TTY_BASE;
+				ret.inheriting = TTY_INHERITING;
+			} else {
+				ret.base = CHARACTER_DEVICE_BASE;
+				ret.inheriting = CHARACTER_DEVICE_INHERITING;
+			}
+			break;
+		case 1:
+			ret.base = BLOCK_DEVICE_BASE;
+			ret.inheriting = BLOCK_DEVICE_INHERITING;
+			break;
+		default:
+			ret.base = BigInt(0);
+			ret.inheriting = BigInt(0);
+	}
+	const read_or_write_only = flags & 3;
+	if (read_or_write_only === 0) ret.base &= ~WasiRights.FD_WRITE;
+	else if (read_or_write_only === 1) ret.base &= ~WasiRights.FD_READ;
+	return ret;
+}
+function concatBuffer(buffers, size) {
+	let total = 0;
+	if (typeof size === "number" && size >= 0) total = size;
+	else for (let i = 0; i < buffers.length; i++) {
+		const buffer = buffers[i];
+		total += buffer.length;
+	}
+	let pos = 0;
+	const ret = new Uint8Array(total);
+	for (let i = 0; i < buffers.length; i++) {
+		const buffer = buffers[i];
+		ret.set(buffer, pos);
+		pos += buffer.length;
+	}
+	return ret;
+}
+var FileDescriptor = class {
+	constructor(id$1, fd, path$1, realPath, type$1, rightsBase, rightsInheriting, preopen) {
+		this.id = id$1;
+		this.fd = fd;
+		this.path = path$1;
+		this.realPath = realPath;
+		this.type = type$1;
+		this.rightsBase = rightsBase;
+		this.rightsInheriting = rightsInheriting;
+		this.preopen = preopen;
+		this.pos = BigInt(0);
+		this.size = BigInt(0);
+	}
+	seek(offset, whence) {
+		if (whence === 0) this.pos = BigInt(offset);
+		else if (whence === 1) this.pos += BigInt(offset);
+		else if (whence === 2) this.pos = BigInt(this.size) - BigInt(offset);
+		else throw new WasiError("Unknown whence", 29);
+		return this.pos;
+	}
+};
+var StandardOutput = class extends FileDescriptor {
+	constructor(log, id$1, fd, path$1, realPath, type$1, rightsBase, rightsInheriting, preopen) {
+		super(id$1, fd, path$1, realPath, type$1, rightsBase, rightsInheriting, preopen);
+		this._log = log;
+		this._buf = null;
+	}
+	write(buffer) {
+		const originalBuffer = buffer;
+		if (this._buf) {
+			buffer = concatBuffer([this._buf, buffer]);
+			this._buf = null;
+		}
+		if (buffer.indexOf(10) === -1) {
+			this._buf = buffer;
+			return originalBuffer.byteLength;
+		}
+		let written = 0;
+		let lastBegin = 0;
+		let index;
+		while ((index = buffer.indexOf(10, written)) !== -1) {
+			const str = new TextDecoder().decode(buffer.subarray(lastBegin, index));
+			this._log(str);
+			written += index - lastBegin + 1;
+			lastBegin = index + 1;
+		}
+		if (written < buffer.length) this._buf = buffer.slice(written);
+		return originalBuffer.byteLength;
+	}
+};
+function toFileType(stat) {
+	if (stat.isBlockDevice()) return 1;
+	if (stat.isCharacterDevice()) return 2;
+	if (stat.isDirectory()) return 3;
+	if (stat.isSocket()) return 6;
+	if (stat.isFile()) return 4;
+	if (stat.isSymbolicLink()) return 7;
+	return 0;
+}
+function toFileStat(view, buf, stat) {
+	view.setBigUint64(buf, stat.dev, true);
+	view.setBigUint64(buf + 8, stat.ino, true);
+	view.setBigUint64(buf + 16, BigInt(toFileType(stat)), true);
+	view.setBigUint64(buf + 24, stat.nlink, true);
+	view.setBigUint64(buf + 32, stat.size, true);
+	view.setBigUint64(buf + 40, stat.atimeMs * BigInt(1e6), true);
+	view.setBigUint64(buf + 48, stat.mtimeMs * BigInt(1e6), true);
+	view.setBigUint64(buf + 56, stat.ctimeMs * BigInt(1e6), true);
+}
+var FileDescriptorTable = class {
+	constructor(options$1) {
+		this.used = 0;
+		this.size = options$1.size;
+		this.fds = Array(options$1.size);
+		this.stdio = [
+			options$1.in,
+			options$1.out,
+			options$1.err
+		];
+		this.print = options$1.print;
+		this.printErr = options$1.printErr;
+		this.insertStdio(options$1.in, 0, "<stdin>");
+		this.insertStdio(options$1.out, 1, "<stdout>");
+		this.insertStdio(options$1.err, 2, "<stderr>");
+	}
+	insertStdio(fd, expected, name) {
+		const type$1 = 2;
+		const { base, inheriting } = getRights(this.stdio, fd, 2, type$1);
+		const wrap$3 = this.insert(fd, name, name, type$1, base, inheriting, 0);
+		if (wrap$3.id !== expected) throw new WasiError(`id: ${wrap$3.id} !== expected: ${expected}`, 8);
+		return wrap$3;
+	}
+	insert(fd, mappedPath, realPath, type$1, rightsBase, rightsInheriting, preopen) {
+		var _a, _b;
+		let index = -1;
+		if (this.used >= this.size) {
+			const newSize = this.size * 2;
+			this.fds.length = newSize;
+			index = this.size;
+			this.size = newSize;
+		} else for (let i = 0; i < this.size; ++i) if (this.fds[i] == null) {
+			index = i;
+			break;
+		}
+		let entry;
+		if (mappedPath === "<stdout>") entry = new StandardOutput((_a = this.print) !== null && _a !== void 0 ? _a : console.log, index, fd, mappedPath, realPath, type$1, rightsBase, rightsInheriting, preopen);
+		else if (mappedPath === "<stderr>") entry = new StandardOutput((_b = this.printErr) !== null && _b !== void 0 ? _b : console.error, index, fd, mappedPath, realPath, type$1, rightsBase, rightsInheriting, preopen);
+		else entry = new FileDescriptor(index, fd, mappedPath, realPath, type$1, rightsBase, rightsInheriting, preopen);
+		this.fds[index] = entry;
+		this.used++;
+		return entry;
+	}
+	get(id$1, base, inheriting) {
+		if (id$1 >= this.size) throw new WasiError("Invalid fd", 8);
+		const entry = this.fds[id$1];
+		if (!entry || entry.id !== id$1) throw new WasiError("Bad file descriptor", 8);
+		if ((~entry.rightsBase & base) !== BigInt(0) || (~entry.rightsInheriting & inheriting) !== BigInt(0)) throw new WasiError("Capabilities insufficient", 76);
+		return entry;
+	}
+	remove(id$1) {
+		if (id$1 >= this.size) throw new WasiError("Invalid fd", 8);
+		const entry = this.fds[id$1];
+		if (!entry || entry.id !== id$1) throw new WasiError("Bad file descriptor", 8);
+		this.fds[id$1] = void 0;
+		this.used--;
+	}
+};
+var SyncTable = class extends FileDescriptorTable {
+	constructor(options$1) {
+		super(options$1);
+		this.fs = options$1.fs;
+	}
+	getFileTypeByFd(fd) {
+		return toFileType(this.fs.fstatSync(fd, { bigint: true }));
+	}
+	insertPreopen(fd, mappedPath, realPath) {
+		const type$1 = this.getFileTypeByFd(fd);
+		if (type$1 !== 3) throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54);
+		const result = getRights(this.stdio, fd, 0, type$1);
+		return this.insert(fd, mappedPath, realPath, type$1, result.base, result.inheriting, 1);
+	}
+	renumber(dst, src) {
+		if (dst === src) return;
+		if (dst >= this.size || src >= this.size) throw new WasiError("Invalid fd", 8);
+		const dstEntry = this.fds[dst];
+		const srcEntry = this.fds[src];
+		if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) throw new WasiError("Invalid fd", 8);
+		this.fs.closeSync(dstEntry.fd);
+		this.fds[dst] = this.fds[src];
+		this.fds[dst].id = dst;
+		this.fds[src] = void 0;
+		this.used--;
+	}
+};
+var AsyncTable = class extends FileDescriptorTable {
+	constructor(options$1) {
+		super(options$1);
+	}
+	async getFileTypeByFd(fd) {
+		return toFileType(await fd.stat({ bigint: true }));
+	}
+	async insertPreopen(fd, mappedPath, realPath) {
+		const type$1 = await this.getFileTypeByFd(fd);
+		if (type$1 !== 3) throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54);
+		const result = getRights(this.stdio, fd.fd, 0, type$1);
+		return this.insert(fd, mappedPath, realPath, type$1, result.base, result.inheriting, 1);
+	}
+	async renumber(dst, src) {
+		if (dst === src) return;
+		if (dst >= this.size || src >= this.size) throw new WasiError("Invalid fd", 8);
+		const dstEntry = this.fds[dst];
+		const srcEntry = this.fds[src];
+		if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) throw new WasiError("Invalid fd", 8);
+		await dstEntry.fd.close();
+		this.fds[dst] = this.fds[src];
+		this.fds[dst].id = dst;
+		this.fds[src] = void 0;
+		this.used--;
+	}
+};
+/** @public */
+const WebAssemblyMemory = /* @__PURE__ */ (function() {
+	return _WebAssembly.Memory;
+})();
+/** @public */
+var Memory = class extends WebAssemblyMemory {
+	constructor(descriptor) {
+		super(descriptor);
+	}
+	get HEAP8() {
+		return new Int8Array(super.buffer);
+	}
+	get HEAPU8() {
+		return new Uint8Array(super.buffer);
+	}
+	get HEAP16() {
+		return new Int16Array(super.buffer);
+	}
+	get HEAPU16() {
+		return new Uint16Array(super.buffer);
+	}
+	get HEAP32() {
+		return new Int32Array(super.buffer);
+	}
+	get HEAPU32() {
+		return new Uint32Array(super.buffer);
+	}
+	get HEAP64() {
+		return new BigInt64Array(super.buffer);
+	}
+	get HEAPU64() {
+		return new BigUint64Array(super.buffer);
+	}
+	get HEAPF32() {
+		return new Float32Array(super.buffer);
+	}
+	get HEAPF64() {
+		return new Float64Array(super.buffer);
+	}
+	get view() {
+		return new DataView(super.buffer);
+	}
+};
+/** @public */
+function extendMemory(memory) {
+	if (Object.getPrototypeOf(memory) === _WebAssembly.Memory.prototype) Object.setPrototypeOf(memory, Memory.prototype);
+	return memory;
+}
+function checkWebAssemblyFunction() {
+	const WebAssemblyFunction = _WebAssembly.Function;
+	if (typeof WebAssemblyFunction !== "function") throw new Error("WebAssembly.Function is not supported in this environment. If you are using V8 based browser like Chrome, try to specify --js-flags=\"--wasm-staging --experimental-wasm-stack-switching\"");
+	return WebAssemblyFunction;
+}
+/** @public */
+function wrapAsyncImport(f, parameterType, returnType) {
+	const WebAssemblyFunction = checkWebAssemblyFunction();
+	if (typeof f !== "function") throw new TypeError("Function required");
+	const parameters = parameterType.slice(0);
+	parameters.unshift("externref");
+	return new WebAssemblyFunction({
+		parameters,
+		results: returnType
+	}, f, { suspending: "first" });
+}
+function copyMemory(targets, src) {
+	if (targets.length === 0 || src.length === 0) return 0;
+	let copied = 0;
+	let left = src.length - copied;
+	for (let i = 0; i < targets.length; ++i) {
+		const target = targets[i];
+		if (left < target.length) {
+			target.set(src.subarray(copied, copied + left), 0);
+			copied += left;
+			left = 0;
+			return copied;
+		}
+		target.set(src.subarray(copied, copied + target.length), 0);
+		copied += target.length;
+		left -= target.length;
+	}
+	return copied;
+}
+const _memory = /* @__PURE__ */ new WeakMap();
+const _wasi = /* @__PURE__ */ new WeakMap();
+const _fs = /* @__PURE__ */ new WeakMap();
+function getMemory(wasi) {
+	return _memory.get(wasi);
+}
+function getFs(wasi) {
+	const fs$1 = _fs.get(wasi);
+	if (!fs$1) throw new Error("filesystem is unavailable");
+	return fs$1;
+}
+function handleError(err) {
+	if (err instanceof WasiError) {
+		console.warn(err);
+		return err.errno;
+	}
+	switch (err.code) {
+		case "ENOENT": return 44;
+		case "EBADF": return 8;
+		case "EINVAL": return 28;
+		case "EPERM": return 63;
+		case "EPROTO": return 65;
+		case "EEXIST": return 20;
+		case "ENOTDIR": return 54;
+		case "EMFILE": return 33;
+		case "EACCES": return 2;
+		case "EISDIR": return 31;
+		case "ENOTEMPTY": return 55;
+		case "ENOSYS": return 52;
+	}
+	throw err;
+}
+function defineName(name, f) {
+	Object.defineProperty(f, "name", { value: name });
+	return f;
+}
+function tryCall(f, wasi, args$1) {
+	let r;
+	try {
+		r = f.apply(wasi, args$1);
+	} catch (err) {
+		return handleError(err);
+	}
+	if (isPromiseLike(r)) return r.then((_) => _, handleError);
+	return r;
+}
+function syscallWrap(self$1, name, f) {
+	let debug$1 = false;
+	const NODE_DEBUG_NATIVE = (() => {
+		try {
+			return process.env.NODE_DEBUG_NATIVE;
+		} catch (_) {
+			return;
+		}
+	})();
+	if (typeof NODE_DEBUG_NATIVE === "string" && NODE_DEBUG_NATIVE.split(",").includes("wasi")) debug$1 = true;
+	return debug$1 ? defineName(name, function() {
+		const args$1 = Array.prototype.slice.call(arguments);
+		let debugArgs = [`${name}(${Array.from({ length: arguments.length }).map(() => "%d").join(", ")})`];
+		debugArgs = debugArgs.concat(args$1);
+		console.debug.apply(console, debugArgs);
+		return tryCall(f, self$1, args$1);
+	}) : defineName(name, function() {
+		return tryCall(f, self$1, arguments);
+	});
+}
+function resolvePathSync(fs$1, fileDescriptor, path$1, flags) {
+	let resolvedPath = resolve$1(fileDescriptor.realPath, path$1);
+	if ((flags & 1) === 1) try {
+		resolvedPath = fs$1.readlinkSync(resolvedPath);
+	} catch (err) {
+		if (err.code !== "EINVAL" && err.code !== "ENOENT") throw err;
+	}
+	return resolvedPath;
+}
+async function resolvePathAsync(fs$1, fileDescriptor, path$1, flags) {
+	let resolvedPath = resolve$1(fileDescriptor.realPath, path$1);
+	if ((flags & 1) === 1) try {
+		resolvedPath = await fs$1.promises.readlink(resolvedPath);
+	} catch (err) {
+		if (err.code !== "EINVAL" && err.code !== "ENOENT") throw err;
+	}
+	return resolvedPath;
+}
+const encoder = /* @__PURE__ */ new TextEncoder();
+const decoder = /* @__PURE__ */ new TextDecoder();
+const INT64_MAX = (BigInt(1) << BigInt(63)) - BigInt(1);
+function readStdin() {
+	const value = window.prompt();
+	if (value === null) return new Uint8Array();
+	return new TextEncoder().encode(value + "\n");
+}
+function validateFstFlagsOrReturn(flags) {
+	return Boolean(flags & -16) || (flags & 3) === 3 || (flags & 12) === 12;
+}
+var WASI$1 = class WASI$1 {
+	constructor(args$1, env, fds, asyncFs, fs$1, asyncify) {
+		this.args_get = syscallWrap(this, "args_get", function(argv, argv_buf) {
+			argv = Number(argv);
+			argv_buf = Number(argv_buf);
+			if (argv === 0 || argv_buf === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const args$2 = _wasi.get(this).args;
+			for (let i = 0; i < args$2.length; ++i) {
+				const arg = args$2[i];
+				view.setInt32(argv, argv_buf, true);
+				argv += 4;
+				const data = encoder.encode(arg + "\0");
+				HEAPU8.set(data, argv_buf);
+				argv_buf += data.length;
+			}
+			return 0;
+		});
+		this.args_sizes_get = syscallWrap(this, "args_sizes_get", function(argc, argv_buf_size) {
+			argc = Number(argc);
+			argv_buf_size = Number(argv_buf_size);
+			if (argc === 0 || argv_buf_size === 0) return 28;
+			const { view } = getMemory(this);
+			const args$2 = _wasi.get(this).args;
+			view.setUint32(argc, args$2.length, true);
+			view.setUint32(argv_buf_size, encoder.encode(args$2.join("\0") + "\0").length, true);
+			return 0;
+		});
+		this.environ_get = syscallWrap(this, "environ_get", function(environ, environ_buf) {
+			environ = Number(environ);
+			environ_buf = Number(environ_buf);
+			if (environ === 0 || environ_buf === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const env$1 = _wasi.get(this).env;
+			for (let i = 0; i < env$1.length; ++i) {
+				const pair = env$1[i];
+				view.setInt32(environ, environ_buf, true);
+				environ += 4;
+				const data = encoder.encode(pair + "\0");
+				HEAPU8.set(data, environ_buf);
+				environ_buf += data.length;
+			}
+			return 0;
+		});
+		this.environ_sizes_get = syscallWrap(this, "environ_sizes_get", function(len, buflen) {
+			len = Number(len);
+			buflen = Number(buflen);
+			if (len === 0 || buflen === 0) return 28;
+			const { view } = getMemory(this);
+			const wasi = _wasi.get(this);
+			view.setUint32(len, wasi.env.length, true);
+			view.setUint32(buflen, encoder.encode(wasi.env.join("\0") + "\0").length, true);
+			return 0;
+		});
+		this.clock_res_get = syscallWrap(this, "clock_res_get", function(id$1, resolution) {
+			resolution = Number(resolution);
+			if (resolution === 0) return 28;
+			const { view } = getMemory(this);
+			switch (id$1) {
+				case 0:
+					view.setBigUint64(resolution, BigInt(1e6), true);
+					return 0;
+				case 1:
+				case 2:
+				case 3:
+					view.setBigUint64(resolution, BigInt(1e3), true);
+					return 0;
+				default: return 28;
+			}
+		});
+		this.clock_time_get = syscallWrap(this, "clock_time_get", function(id$1, _percision, time) {
+			time = Number(time);
+			if (time === 0) return 28;
+			const { view } = getMemory(this);
+			switch (id$1) {
+				case 0:
+					view.setBigUint64(time, BigInt(Date.now()) * BigInt(1e6), true);
+					return 0;
+				case 1:
+				case 2:
+				case 3: {
+					const t$2 = performance.now() / 1e3;
+					const s = Math.trunc(t$2);
+					const ms = Math.floor((t$2 - s) * 1e3);
+					const result = BigInt(s) * BigInt(1e9) + BigInt(ms) * BigInt(1e6);
+					view.setBigUint64(time, result, true);
+					return 0;
+				}
+				default: return 28;
+			}
+		});
+		this.fd_advise = syscallWrap(this, "fd_advise", function(_fd, _offset, _len, _advice) {
+			return 52;
+		});
+		this.fd_fdstat_get = syscallWrap(this, "fd_fdstat_get", function(fd, fdstat) {
+			fdstat = Number(fdstat);
+			if (fdstat === 0) return 28;
+			const fileDescriptor = _wasi.get(this).fds.get(fd, BigInt(0), BigInt(0));
+			const { view } = getMemory(this);
+			view.setUint16(fdstat, fileDescriptor.type, true);
+			view.setUint16(fdstat + 2, 0, true);
+			view.setBigUint64(fdstat + 8, fileDescriptor.rightsBase, true);
+			view.setBigUint64(fdstat + 16, fileDescriptor.rightsInheriting, true);
+			return 0;
+		});
+		this.fd_fdstat_set_flags = syscallWrap(this, "fd_fdstat_set_flags", function(_fd, _flags) {
+			return 52;
+		});
+		this.fd_fdstat_set_rights = syscallWrap(this, "fd_fdstat_set_rights", function(fd, rightsBase, rightsInheriting) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, BigInt(0), BigInt(0));
+			if ((rightsBase | fileDescriptor.rightsBase) > fileDescriptor.rightsBase) return 76;
+			if ((rightsInheriting | fileDescriptor.rightsInheriting) > fileDescriptor.rightsInheriting) return 76;
+			fileDescriptor.rightsBase = rightsBase;
+			fileDescriptor.rightsInheriting = rightsInheriting;
+			return 0;
+		});
+		this.fd_prestat_get = syscallWrap(this, "fd_prestat_get", function(fd, prestat) {
+			prestat = Number(prestat);
+			if (prestat === 0) return 28;
+			const wasi = _wasi.get(this);
+			let fileDescriptor;
+			try {
+				fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
+			} catch (err) {
+				if (err instanceof WasiError) return err.errno;
+				throw err;
+			}
+			if (fileDescriptor.preopen !== 1) return 28;
+			const { view } = getMemory(this);
+			view.setUint32(prestat, 0, true);
+			view.setUint32(prestat + 4, encoder.encode(fileDescriptor.path).length, true);
+			return 0;
+		});
+		this.fd_prestat_dir_name = syscallWrap(this, "fd_prestat_dir_name", function(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const fileDescriptor = _wasi.get(this).fds.get(fd, BigInt(0), BigInt(0));
+			if (fileDescriptor.preopen !== 1) return 8;
+			const buffer = encoder.encode(fileDescriptor.path);
+			if (buffer.length > path_len) return 42;
+			const { HEAPU8 } = getMemory(this);
+			HEAPU8.set(buffer, path$1);
+			return 0;
+		});
+		this.fd_seek = syscallWrap(this, "fd_seek", function(fd, offset, whence, newOffset) {
+			newOffset = Number(newOffset);
+			if (newOffset === 0) return 28;
+			if (fd === 0 || fd === 1 || fd === 2) return 0;
+			const r = _wasi.get(this).fds.get(fd, WasiRights.FD_SEEK, BigInt(0)).seek(offset, whence);
+			const { view } = getMemory(this);
+			view.setBigUint64(newOffset, r, true);
+			return 0;
+		});
+		this.fd_tell = syscallWrap(this, "fd_tell", function(fd, offset) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_TELL, BigInt(0));
+			const pos = BigInt(fileDescriptor.pos);
+			const { view } = getMemory(this);
+			view.setBigUint64(Number(offset), pos, true);
+			return 0;
+		});
+		this.poll_oneoff = syscallWrap(this, "poll_oneoff", function(in_ptr, out_ptr, nsubscriptions, nevents) {
+			in_ptr = Number(in_ptr);
+			out_ptr = Number(out_ptr);
+			nevents = Number(nevents);
+			nsubscriptions = Number(nsubscriptions);
+			nsubscriptions = nsubscriptions >>> 0;
+			if (in_ptr === 0 || out_ptr === 0 || nsubscriptions === 0 || nevents === 0) return 28;
+			const { view } = getMemory(this);
+			view.setUint32(nevents, 0, true);
+			let i = 0;
+			let timer_userdata = BigInt(0);
+			let cur_timeout = BigInt(0);
+			let has_timeout = 0;
+			let min_timeout = BigInt(0);
+			let sub;
+			const subscriptions = Array(nsubscriptions);
+			for (i = 0; i < nsubscriptions; i++) {
+				sub = in_ptr + i * 48;
+				const userdata = view.getBigUint64(sub, true);
+				const type$1 = view.getUint8(sub + 8);
+				const clockIdOrFd = view.getUint32(sub + 16, true);
+				subscriptions[i] = {
+					userdata,
+					type: type$1,
+					u: {
+						clock: {
+							clock_id: clockIdOrFd,
+							timeout: view.getBigUint64(sub + 24, true),
+							precision: view.getBigUint64(sub + 32, true),
+							flags: view.getUint16(sub + 40, true)
+						},
+						fd_readwrite: { fd: clockIdOrFd }
+					}
+				};
+			}
+			const fdevents = [];
+			for (i = 0; i < nsubscriptions; i++) {
+				sub = subscriptions[i];
+				switch (sub.type) {
+					case 0:
+						if (sub.u.clock.flags === 1) {
+							const now = BigInt(Date.now()) * BigInt(1e6);
+							cur_timeout = sub.u.clock.timeout - now;
+						} else cur_timeout = sub.u.clock.timeout;
+						if (has_timeout === 0 || cur_timeout < min_timeout) {
+							min_timeout = cur_timeout;
+							timer_userdata = sub.userdata;
+							has_timeout = 1;
+						}
+						break;
+					case 1:
+					case 2:
+						fdevents.push(sub);
+						break;
+					default: return 28;
+				}
+			}
+			if (fdevents.length > 0) {
+				for (i = 0; i < fdevents.length; i++) {
+					const fdevent = fdevents[i];
+					const event = out_ptr + 32 * i;
+					view.setBigUint64(event, fdevent.userdata, true);
+					view.setUint32(event + 8, 52, true);
+					view.setUint32(event + 12, fdevent.type, true);
+					view.setBigUint64(event + 16, BigInt(0), true);
+					view.setUint16(event + 24, 0, true);
+					view.setUint32(nevents, 1, true);
+				}
+				view.setUint32(nevents, fdevents.length, true);
+				return 0;
+			}
+			if (has_timeout) {
+				sleepBreakIf(Number(min_timeout / BigInt(1e6)), () => false);
+				const event = out_ptr;
+				view.setBigUint64(event, timer_userdata, true);
+				view.setUint32(event + 8, 0, true);
+				view.setUint32(event + 12, 0, true);
+				view.setUint32(nevents, 1, true);
+			}
+			return 0;
+		});
+		this.proc_exit = syscallWrap(this, "proc_exit", function(rval) {
+			if (typeof process === "object" && process !== null && typeof process.exit === "function") process.exit(rval);
+			return 0;
+		});
+		this.proc_raise = syscallWrap(this, "proc_raise", function(_sig) {
+			return 52;
+		});
+		this.sched_yield = syscallWrap(this, "sched_yield", function() {
+			return 0;
+		});
+		this.random_get = typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function" ? syscallWrap(this, "random_get", function(buf, buf_len) {
+			buf = Number(buf);
+			if (buf === 0) return 28;
+			buf_len = Number(buf_len);
+			const { HEAPU8, view } = getMemory(this);
+			if (typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer || Object.prototype.toString.call(HEAPU8.buffer) === "[object SharedArrayBuffer]") {
+				for (let i = buf; i < buf + buf_len; ++i) view.setUint8(i, Math.floor(Math.random() * 256));
+				return 0;
+			}
+			let pos;
+			const stride = 65536;
+			for (pos = 0; pos + stride < buf_len; pos += stride) crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + pos + stride));
+			crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + buf_len));
+			return 0;
+		}) : syscallWrap(this, "random_get", function(buf, buf_len) {
+			buf = Number(buf);
+			if (buf === 0) return 28;
+			buf_len = Number(buf_len);
+			const { view } = getMemory(this);
+			for (let i = buf; i < buf + buf_len; ++i) view.setUint8(i, Math.floor(Math.random() * 256));
+			return 0;
+		});
+		this.sock_recv = syscallWrap(this, "sock_recv", function() {
+			return 58;
+		});
+		this.sock_send = syscallWrap(this, "sock_send", function() {
+			return 58;
+		});
+		this.sock_shutdown = syscallWrap(this, "sock_shutdown", function() {
+			return 58;
+		});
+		this.sock_accept = syscallWrap(this, "sock_accept", function() {
+			return 58;
+		});
+		_wasi.set(this, {
+			fds,
+			args: args$1,
+			env
+		});
+		if (fs$1) _fs.set(this, fs$1);
+		const _this = this;
+		function defineImport(name, syncVersion, asyncVersion, parameterType, returnType) {
+			if (asyncFs) if (asyncify) _this[name] = asyncify.wrapImportFunction(syscallWrap(_this, name, asyncVersion));
+			else _this[name] = wrapAsyncImport(syscallWrap(_this, name, asyncVersion), parameterType, returnType);
+			else _this[name] = syscallWrap(_this, name, syncVersion);
+		}
+		defineImport("fd_allocate", function fd_allocate(fd, offset, len) {
+			const wasi = _wasi.get(this);
+			const fs$2 = getFs(this);
+			const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));
+			if (fs$2.fstatSync(fileDescriptor.fd, { bigint: true }).size < offset + len) fs$2.ftruncateSync(fileDescriptor.fd, Number(offset + len));
+			return 0;
+		}, async function fd_allocate(fd, offset, len) {
+			const h = _wasi.get(this).fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0)).fd;
+			if ((await h.stat({ bigint: true })).size < offset + len) await h.truncate(Number(offset + len));
+			return 0;
+		}, [
+			"i32",
+			"i64",
+			"f64"
+		], ["i32"]);
+		defineImport("fd_close", function fd_close(fd) {
+			const wasi = _wasi.get(this);
+			const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));
+			getFs(this).closeSync(fileDescriptor.fd);
+			wasi.fds.remove(fd);
+			return 0;
+		}, async function fd_close(fd) {
+			const wasi = _wasi.get(this);
+			await wasi.fds.get(fd, BigInt(0), BigInt(0)).fd.close();
+			wasi.fds.remove(fd);
+			return 0;
+		}, ["i32"], ["i32"]);
+		defineImport("fd_datasync", function fd_datasync(fd) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));
+			getFs(this).fdatasyncSync(fileDescriptor.fd);
+			return 0;
+		}, async function fd_datasync(fd) {
+			await _wasi.get(this).fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0)).fd.datasync();
+			return 0;
+		}, ["i32"], ["i32"]);
+		defineImport("fd_filestat_get", function fd_filestat_get(fd, buf) {
+			buf = Number(buf);
+			if (buf === 0) return 28;
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));
+			const stat = getFs(this).fstatSync(fileDescriptor.fd, { bigint: true });
+			const { view } = getMemory(this);
+			toFileStat(view, buf, stat);
+			return 0;
+		}, async function fd_filestat_get(fd, buf) {
+			buf = Number(buf);
+			if (buf === 0) return 28;
+			const stat = await _wasi.get(this).fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0)).fd.stat({ bigint: true });
+			const { view } = getMemory(this);
+			toFileStat(view, buf, stat);
+			return 0;
+		}, ["i32", "i32"], ["i32"]);
+		defineImport("fd_filestat_set_size", function fd_filestat_set_size(fd, size) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));
+			getFs(this).ftruncateSync(fileDescriptor.fd, Number(size));
+			return 0;
+		}, async function fd_filestat_set_size(fd, size) {
+			await _wasi.get(this).fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0)).fd.truncate(Number(size));
+			return 0;
+		}, ["i32", "i64"], ["i32"]);
+		function fdFilestatGetTimes(fd, atim, mtim, flags) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_FILESTAT_SET_TIMES, BigInt(0));
+			if ((flags & 2) === 2) atim = BigInt(Date.now() * 1e6);
+			if ((flags & 8) === 8) mtim = BigInt(Date.now() * 1e6);
+			return {
+				fileDescriptor,
+				atim,
+				mtim
+			};
+		}
+		defineImport("fd_filestat_set_times", function fd_filestat_set_times(fd, atim, mtim, flags) {
+			if (validateFstFlagsOrReturn(flags)) return 28;
+			const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);
+			getFs(this).futimesSync(fileDescriptor.fd, Number(atimRes), Number(mtimRes));
+			return 0;
+		}, async function fd_filestat_set_times(fd, atim, mtim, flags) {
+			if (validateFstFlagsOrReturn(flags)) return 28;
+			const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);
+			await fileDescriptor.fd.utimes(Number(atimRes), Number(mtimRes));
+			return 0;
+		}, [
+			"i32",
+			"i64",
+			"i64",
+			"i32"
+		], ["i32"]);
+		defineImport("fd_pread", function fd_pread(fd, iovs, iovslen, offset, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0 || offset > INT64_MAX) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			let totalSize = 0;
+			const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset$1 = iovs + i * 8;
+				const buf = view.getInt32(offset$1, true);
+				const bufLen = view.getUint32(offset$1 + 4, true);
+				totalSize += bufLen;
+				return HEAPU8.subarray(buf, buf + bufLen);
+			});
+			let nread = 0;
+			const buffer = (() => {
+				try {
+					return new Uint8Array(new SharedArrayBuffer(totalSize));
+				} catch (_) {
+					return new Uint8Array(totalSize);
+				}
+			})();
+			buffer._isBuffer = true;
+			const bytesRead = getFs(this).readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
+			nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+			view.setUint32(size, nread, true);
+			return 0;
+		}, async function(fd, iovs, iovslen, offset, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0 || offset > INT64_MAX) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			let totalSize = 0;
+			const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset$1 = iovs + i * 8;
+				const buf = view.getInt32(offset$1, true);
+				const bufLen = view.getUint32(offset$1 + 4, true);
+				totalSize += bufLen;
+				return HEAPU8.subarray(buf, buf + bufLen);
+			});
+			let nread = 0;
+			const buffer = new Uint8Array(totalSize);
+			buffer._isBuffer = true;
+			const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(offset));
+			nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+			view.setUint32(size, nread, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i64",
+			"i32"
+		], ["i32"]);
+		defineImport("fd_pwrite", function fd_pwrite(fd, iovs, iovslen, offset, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0 || offset > INT64_MAX) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset$1 = iovs + i * 8;
+				const buf = view.getInt32(offset$1, true);
+				const bufLen = view.getUint32(offset$1 + 4, true);
+				return HEAPU8.subarray(buf, buf + bufLen);
+			}));
+			const nwritten = getFs(this).writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));
+			view.setUint32(size, nwritten, true);
+			return 0;
+		}, async function fd_pwrite(fd, iovs, iovslen, offset, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0 || offset > INT64_MAX) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset$1 = iovs + i * 8;
+				const buf = view.getInt32(offset$1, true);
+				const bufLen = view.getUint32(offset$1 + 4, true);
+				return HEAPU8.subarray(buf, buf + bufLen);
+			}));
+			const { bytesWritten } = await fileDescriptor.fd.write(buffer, 0, buffer.length, Number(offset));
+			view.setUint32(size, bytesWritten, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i64",
+			"i32"
+		], ["i32"]);
+		defineImport("fd_read", function fd_read(fd, iovs, iovslen, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READ, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			let totalSize = 0;
+			const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset = iovs + i * 8;
+				const buf = view.getInt32(offset, true);
+				const bufLen = view.getUint32(offset + 4, true);
+				totalSize += bufLen;
+				return HEAPU8.subarray(buf, buf + bufLen);
+			});
+			let buffer;
+			let nread = 0;
+			if (fd === 0) {
+				if (typeof window === "undefined" || typeof window.prompt !== "function") return 58;
+				buffer = readStdin();
+				nread = buffer ? copyMemory(ioVecs, buffer) : 0;
+			} else {
+				buffer = (() => {
+					try {
+						return new Uint8Array(new SharedArrayBuffer(totalSize));
+					} catch (_) {
+						return new Uint8Array(totalSize);
+					}
+				})();
+				buffer._isBuffer = true;
+				const bytesRead = getFs(this).readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));
+				nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+				fileDescriptor.pos += BigInt(nread);
+			}
+			view.setUint32(size, nread, true);
+			return 0;
+		}, async function fd_read(fd, iovs, iovslen, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READ, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			let totalSize = 0;
+			const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset = iovs + i * 8;
+				const buf = view.getInt32(offset, true);
+				const bufLen = view.getUint32(offset + 4, true);
+				totalSize += bufLen;
+				return HEAPU8.subarray(buf, buf + bufLen);
+			});
+			let buffer;
+			let nread = 0;
+			if (fd === 0) {
+				if (typeof window === "undefined" || typeof window.prompt !== "function") return 58;
+				buffer = readStdin();
+				nread = buffer ? copyMemory(ioVecs, buffer) : 0;
+			} else {
+				buffer = new Uint8Array(totalSize);
+				buffer._isBuffer = true;
+				const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(fileDescriptor.pos));
+				nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;
+				fileDescriptor.pos += BigInt(nread);
+			}
+			view.setUint32(size, nread, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("fd_readdir", function fd_readdir(fd, buf, buf_len, cookie, bufused) {
+			buf = Number(buf);
+			buf_len = Number(buf_len);
+			bufused = Number(bufused);
+			if (buf === 0 || bufused === 0) return 0;
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READDIR, BigInt(0));
+			const fs$2 = getFs(this);
+			const entries = fs$2.readdirSync(fileDescriptor.realPath, { withFileTypes: true });
+			const { HEAPU8, view } = getMemory(this);
+			let bufferUsed = 0;
+			for (let i = Number(cookie); i < entries.length; i++) {
+				const nameData = encoder.encode(entries[i].name);
+				const entryInfo = fs$2.statSync(resolve$1(fileDescriptor.realPath, entries[i].name), { bigint: true });
+				const entryData = new Uint8Array(24 + nameData.byteLength);
+				const entryView = new DataView(entryData.buffer);
+				entryView.setBigUint64(0, BigInt(i + 1), true);
+				entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true);
+				entryView.setUint32(16, nameData.byteLength, true);
+				let type$1;
+				if (entries[i].isFile()) type$1 = 4;
+				else if (entries[i].isDirectory()) type$1 = 3;
+				else if (entries[i].isSymbolicLink()) type$1 = 7;
+				else if (entries[i].isCharacterDevice()) type$1 = 2;
+				else if (entries[i].isBlockDevice()) type$1 = 1;
+				else if (entries[i].isSocket()) type$1 = 6;
+				else type$1 = 0;
+				entryView.setUint8(20, type$1);
+				entryData.set(nameData, 24);
+				const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed));
+				HEAPU8.set(data, buf + bufferUsed);
+				bufferUsed += data.byteLength;
+			}
+			view.setUint32(bufused, bufferUsed, true);
+			return 0;
+		}, async function fd_readdir(fd, buf, buf_len, cookie, bufused) {
+			buf = Number(buf);
+			buf_len = Number(buf_len);
+			bufused = Number(bufused);
+			if (buf === 0 || bufused === 0) return 0;
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_READDIR, BigInt(0));
+			const fs$2 = getFs(this);
+			const entries = await fs$2.promises.readdir(fileDescriptor.realPath, { withFileTypes: true });
+			const { HEAPU8, view } = getMemory(this);
+			let bufferUsed = 0;
+			for (let i = Number(cookie); i < entries.length; i++) {
+				const nameData = encoder.encode(entries[i].name);
+				const entryInfo = await fs$2.promises.stat(resolve$1(fileDescriptor.realPath, entries[i].name), { bigint: true });
+				const entryData = new Uint8Array(24 + nameData.byteLength);
+				const entryView = new DataView(entryData.buffer);
+				entryView.setBigUint64(0, BigInt(i + 1), true);
+				entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true);
+				entryView.setUint32(16, nameData.byteLength, true);
+				let type$1;
+				if (entries[i].isFile()) type$1 = 4;
+				else if (entries[i].isDirectory()) type$1 = 3;
+				else if (entries[i].isSymbolicLink()) type$1 = 7;
+				else if (entries[i].isCharacterDevice()) type$1 = 2;
+				else if (entries[i].isBlockDevice()) type$1 = 1;
+				else if (entries[i].isSocket()) type$1 = 6;
+				else type$1 = 0;
+				entryView.setUint8(20, type$1);
+				entryData.set(nameData, 24);
+				const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed));
+				HEAPU8.set(data, buf + bufferUsed);
+				bufferUsed += data.byteLength;
+			}
+			view.setUint32(bufused, bufferUsed, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i64",
+			"i32"
+		], ["i32"]);
+		defineImport("fd_renumber", function fd_renumber(from$1, to) {
+			_wasi.get(this).fds.renumber(to, from$1);
+			return 0;
+		}, async function fd_renumber(from$1, to) {
+			await _wasi.get(this).fds.renumber(to, from$1);
+			return 0;
+		}, ["i32", "i32"], ["i32"]);
+		defineImport("fd_sync", function fd_sync(fd) {
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_SYNC, BigInt(0));
+			getFs(this).fsyncSync(fileDescriptor.fd);
+			return 0;
+		}, async function fd_sync(fd) {
+			await _wasi.get(this).fds.get(fd, WasiRights.FD_SYNC, BigInt(0)).fd.sync();
+			return 0;
+		}, ["i32"], ["i32"]);
+		defineImport("fd_write", function fd_write(fd, iovs, iovslen, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_WRITE, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset = iovs + i * 8;
+				const buf = view.getInt32(offset, true);
+				const bufLen = view.getUint32(offset + 4, true);
+				return HEAPU8.subarray(buf, buf + bufLen);
+			}));
+			let nwritten;
+			if (fd === 1 || fd === 2) nwritten = fileDescriptor.write(buffer);
+			else {
+				nwritten = getFs(this).writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));
+				fileDescriptor.pos += BigInt(nwritten);
+			}
+			view.setUint32(size, nwritten, true);
+			return 0;
+		}, async function fd_write(fd, iovs, iovslen, size) {
+			iovs = Number(iovs);
+			size = Number(size);
+			if (iovs === 0 && iovslen || size === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.FD_WRITE, BigInt(0));
+			if (!iovslen) {
+				view.setUint32(size, 0, true);
+				return 0;
+			}
+			const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {
+				const offset = iovs + i * 8;
+				const buf = view.getInt32(offset, true);
+				const bufLen = view.getUint32(offset + 4, true);
+				return HEAPU8.subarray(buf, buf + bufLen);
+			}));
+			let nwritten;
+			if (fd === 1 || fd === 2) nwritten = fileDescriptor.write(buffer);
+			else {
+				nwritten = await (await fileDescriptor.fd.write(buffer, 0, buffer.length, Number(fileDescriptor.pos))).bytesWritten;
+				fileDescriptor.pos += BigInt(nwritten);
+			}
+			view.setUint32(size, nwritten, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_create_directory", function path_create_directory(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			getFs(this).mkdirSync(pathString);
+			return 0;
+		}, async function path_create_directory(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			await getFs(this).promises.mkdir(pathString);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_filestat_get", function path_filestat_get(fd, flags, path$1, path_len, filestat) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			filestat = Number(filestat);
+			if (path$1 === 0 || filestat === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			const fs$2 = getFs(this);
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			let stat;
+			if ((flags & 1) === 1) stat = fs$2.statSync(pathString, { bigint: true });
+			else stat = fs$2.lstatSync(pathString, { bigint: true });
+			toFileStat(view, filestat, stat);
+			return 0;
+		}, async function path_filestat_get(fd, flags, path$1, path_len, filestat) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			filestat = Number(filestat);
+			if (path$1 === 0 || filestat === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			const fs$2 = getFs(this);
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			let stat;
+			if ((flags & 1) === 1) stat = await fs$2.promises.stat(pathString, { bigint: true });
+			else stat = await fs$2.promises.lstat(pathString, { bigint: true });
+			toFileStat(view, filestat, stat);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_filestat_set_times", function path_filestat_set_times(fd, flags, path$1, path_len, atim, mtim, fst_flags) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));
+			if (validateFstFlagsOrReturn(fst_flags)) return 28;
+			const fs$2 = getFs(this);
+			const resolvedPath = resolvePathSync(fs$2, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len)), flags);
+			if ((fst_flags & 2) === 2) atim = BigInt(Date.now() * 1e6);
+			if ((fst_flags & 8) === 8) mtim = BigInt(Date.now() * 1e6);
+			fs$2.utimesSync(resolvedPath, Number(atim), Number(mtim));
+			return 0;
+		}, async function path_filestat_set_times(fd, flags, path$1, path_len, atim, mtim, fst_flags) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));
+			if (validateFstFlagsOrReturn(fst_flags)) return 28;
+			const fs$2 = getFs(this);
+			const resolvedPath = await resolvePathAsync(fs$2, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len)), flags);
+			if ((fst_flags & 2) === 2) atim = BigInt(Date.now() * 1e6);
+			if ((fst_flags & 8) === 8) mtim = BigInt(Date.now() * 1e6);
+			await fs$2.promises.utimes(resolvedPath, Number(atim), Number(mtim));
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i64",
+			"i64",
+			"i32"
+		], ["i32"]);
+		defineImport("path_link", function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const wasi = _wasi.get(this);
+			let oldWrap;
+			let newWrap;
+			if (old_fd === new_fd) oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0));
+			else {
+				oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0));
+				newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0));
+			}
+			const { HEAPU8 } = getMemory(this);
+			const fs$2 = getFs(this);
+			const resolvedOldPath = resolvePathSync(fs$2, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags);
+			const resolvedNewPath = resolve$1(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));
+			fs$2.linkSync(resolvedOldPath, resolvedNewPath);
+			return 0;
+		}, async function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const wasi = _wasi.get(this);
+			let oldWrap;
+			let newWrap;
+			if (old_fd === new_fd) oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0));
+			else {
+				oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0));
+				newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0));
+			}
+			const { HEAPU8 } = getMemory(this);
+			const fs$2 = getFs(this);
+			const resolvedOldPath = await resolvePathAsync(fs$2, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags);
+			const resolvedNewPath = resolve$1(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));
+			await fs$2.promises.link(resolvedOldPath, resolvedNewPath);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		function pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags) {
+			const read = (fs_rights_base & (WasiRights.FD_READ | WasiRights.FD_READDIR)) !== BigInt(0);
+			const write = (fs_rights_base & (WasiRights.FD_DATASYNC | WasiRights.FD_WRITE | WasiRights.FD_ALLOCATE | WasiRights.FD_FILESTAT_SET_SIZE)) !== BigInt(0);
+			let flags = write ? read ? 2 : 1 : 0;
+			let needed_base = WasiRights.PATH_OPEN;
+			let needed_inheriting = fs_rights_base | fs_rights_inheriting;
+			if ((o_flags & 1) !== 0) {
+				flags |= 64;
+				needed_base |= WasiRights.PATH_CREATE_FILE;
+			}
+			if ((o_flags & 2) !== 0) flags |= 65536;
+			if ((o_flags & 4) !== 0) flags |= 128;
+			if ((o_flags & 8) !== 0) {
+				flags |= 512;
+				needed_base |= WasiRights.PATH_FILESTAT_SET_SIZE;
+			}
+			if ((fs_flags & 1) !== 0) flags |= 1024;
+			if ((fs_flags & 2) !== 0) needed_inheriting |= WasiRights.FD_DATASYNC;
+			if ((fs_flags & 4) !== 0) flags |= 2048;
+			if ((fs_flags & 8) !== 0) {
+				flags |= 1052672;
+				needed_inheriting |= WasiRights.FD_SYNC;
+			}
+			if ((fs_flags & 16) !== 0) {
+				flags |= 1052672;
+				needed_inheriting |= WasiRights.FD_SYNC;
+			}
+			if (write && (flags & 1536) === 0) needed_inheriting |= WasiRights.FD_SEEK;
+			return {
+				flags,
+				needed_base,
+				needed_inheriting
+			};
+		}
+		defineImport("path_open", function path_open(dirfd, dirflags, path$1, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {
+			path$1 = Number(path$1);
+			fd = Number(fd);
+			if (path$1 === 0 || fd === 0) return 28;
+			path_len = Number(path_len);
+			fs_rights_base = BigInt(fs_rights_base);
+			fs_rights_inheriting = BigInt(fs_rights_inheriting);
+			const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);
+			const wasi = _wasi.get(this);
+			const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);
+			const memory = getMemory(this);
+			const HEAPU8 = memory.HEAPU8;
+			const pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			const fs$2 = getFs(this);
+			const resolved_path = resolvePathSync(fs$2, fileDescriptor, pathString, dirflags);
+			const r = fs$2.openSync(resolved_path, flagsRes, 438);
+			const filetype = wasi.fds.getFileTypeByFd(r);
+			if (filetype !== 3 && ((o_flags & 2) !== 0 || resolved_path.endsWith("/"))) return 54;
+			const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r, flagsRes, filetype);
+			const wrap$3 = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);
+			const stat = fs$2.fstatSync(r, { bigint: true });
+			if (stat.isFile()) {
+				wrap$3.size = stat.size;
+				if ((flagsRes & 1024) !== 0) wrap$3.pos = stat.size;
+			}
+			memory.view.setInt32(fd, wrap$3.id, true);
+			return 0;
+		}, async function path_open(dirfd, dirflags, path$1, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {
+			path$1 = Number(path$1);
+			fd = Number(fd);
+			if (path$1 === 0 || fd === 0) return 28;
+			path_len = Number(path_len);
+			fs_rights_base = BigInt(fs_rights_base);
+			fs_rights_inheriting = BigInt(fs_rights_inheriting);
+			const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);
+			const wasi = _wasi.get(this);
+			const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);
+			const memory = getMemory(this);
+			const HEAPU8 = memory.HEAPU8;
+			const pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			const fs$2 = getFs(this);
+			const resolved_path = await resolvePathAsync(fs$2, fileDescriptor, pathString, dirflags);
+			const r = await fs$2.promises.open(resolved_path, flagsRes, 438);
+			const filetype = await wasi.fds.getFileTypeByFd(r);
+			if ((o_flags & 2) !== 0 && filetype !== 3) return 54;
+			const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r.fd, flagsRes, filetype);
+			const wrap$3 = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);
+			const stat = await r.stat({ bigint: true });
+			if (stat.isFile()) {
+				wrap$3.size = stat.size;
+				if ((flagsRes & 1024) !== 0) wrap$3.pos = stat.size;
+			}
+			memory.view.setInt32(fd, wrap$3.id, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i64",
+			"i64",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_readlink", function path_readlink(fd, path$1, path_len, buf, buf_len, bufused) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			buf = Number(buf);
+			buf_len = Number(buf_len);
+			bufused = Number(bufused);
+			if (path$1 === 0 || buf === 0 || bufused === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_READLINK, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			const link = getFs(this).readlinkSync(pathString);
+			const linkData = encoder.encode(link);
+			const len = Math.min(linkData.length, buf_len);
+			if (len >= buf_len) return 42;
+			HEAPU8.set(linkData.subarray(0, len), buf);
+			HEAPU8[buf + len] = 0;
+			view.setUint32(bufused, len, true);
+			return 0;
+		}, async function path_readlink(fd, path$1, path_len, buf, buf_len, bufused) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			buf = Number(buf);
+			buf_len = Number(buf_len);
+			bufused = Number(bufused);
+			if (path$1 === 0 || buf === 0 || bufused === 0) return 28;
+			const { HEAPU8, view } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_READLINK, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			const link = await getFs(this).promises.readlink(pathString);
+			const linkData = encoder.encode(link);
+			const len = Math.min(linkData.length, buf_len);
+			if (len >= buf_len) return 42;
+			HEAPU8.set(linkData.subarray(0, len), buf);
+			HEAPU8[buf + len] = 0;
+			view.setUint32(bufused, len, true);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_remove_directory", function path_remove_directory(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			getFs(this).rmdirSync(pathString);
+			return 0;
+		}, async function path_remove_directory(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			await getFs(this).promises.rmdir(pathString);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_rename", function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const wasi = _wasi.get(this);
+			let oldWrap;
+			let newWrap;
+			if (old_fd === new_fd) oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0));
+			else {
+				oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0));
+				newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0));
+			}
+			const { HEAPU8 } = getMemory(this);
+			const resolvedOldPath = resolve$1(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)));
+			const resolvedNewPath = resolve$1(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));
+			getFs(this).renameSync(resolvedOldPath, resolvedNewPath);
+			return 0;
+		}, async function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const wasi = _wasi.get(this);
+			let oldWrap;
+			let newWrap;
+			if (old_fd === new_fd) oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0));
+			else {
+				oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0));
+				newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0));
+			}
+			const { HEAPU8 } = getMemory(this);
+			const resolvedOldPath = resolve$1(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)));
+			const resolvedNewPath = resolve$1(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));
+			await getFs(this).promises.rename(resolvedOldPath, resolvedNewPath);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_symlink", function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0));
+			const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len));
+			if (oldPath.length > 0 && oldPath[0] === "/") return 63;
+			let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len));
+			newPath = resolve$1(fileDescriptor.realPath, newPath);
+			getFs(this).symlinkSync(oldPath, newPath);
+			return 0;
+		}, async function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {
+			old_path = Number(old_path);
+			old_path_len = Number(old_path_len);
+			new_path = Number(new_path);
+			new_path_len = Number(new_path_len);
+			if (old_path === 0 || new_path === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0));
+			const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len));
+			let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len));
+			newPath = resolve$1(fileDescriptor.realPath, newPath);
+			await getFs(this).promises.symlink(oldPath, newPath);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		defineImport("path_unlink_file", function path_unlink_file(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			getFs(this).unlinkSync(pathString);
+			return 0;
+		}, async function path_unlink_file(fd, path$1, path_len) {
+			path$1 = Number(path$1);
+			path_len = Number(path_len);
+			if (path$1 === 0) return 28;
+			const { HEAPU8 } = getMemory(this);
+			const fileDescriptor = _wasi.get(this).fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0));
+			let pathString = decoder.decode(unsharedSlice(HEAPU8, path$1, path$1 + path_len));
+			pathString = resolve$1(fileDescriptor.realPath, pathString);
+			await getFs(this).promises.unlink(pathString);
+			return 0;
+		}, [
+			"i32",
+			"i32",
+			"i32"
+		], ["i32"]);
+		this._setMemory = function setMemory(m) {
+			if (!(m instanceof _WebAssembly.Memory)) throw new TypeError("\"instance.exports.memory\" property must be a WebAssembly.Memory");
+			_memory.set(_this, extendMemory(m));
+		};
+	}
+	static createSync(args$1, env, preopens, stdio, fs$1, print$1, printErr) {
+		const fds = new SyncTable({
+			size: 3,
+			in: stdio[0],
+			out: stdio[1],
+			err: stdio[2],
+			fs: fs$1,
+			print: print$1,
+			printErr
+		});
+		const _this = new WASI$1(args$1, env, fds, false, fs$1);
+		if (preopens.length > 0) for (let i = 0; i < preopens.length; ++i) {
+			const realPath = fs$1.realpathSync(preopens[i].realPath, "utf8");
+			const fd = fs$1.openSync(realPath, "r", 438);
+			fds.insertPreopen(fd, preopens[i].mappedPath, realPath);
+		}
+		return _this;
+	}
+	static async createAsync(args$1, env, preopens, stdio, fs$1, print$1, printErr, asyncify) {
+		const fds = new AsyncTable({
+			size: 3,
+			in: stdio[0],
+			out: stdio[1],
+			err: stdio[2],
+			print: print$1,
+			printErr
+		});
+		const _this = new WASI$1(args$1, env, fds, true, fs$1, asyncify);
+		if (preopens.length > 0) for (let i = 0; i < preopens.length; ++i) {
+			const entry = preopens[i];
+			const realPath = await fs$1.promises.realpath(entry.realPath);
+			const fd = await fs$1.promises.open(realPath, "r", 438);
+			await fds.insertPreopen(fd, entry.mappedPath, realPath);
+		}
+		return _this;
+	}
+};
+const kEmptyObject = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+const kExitCode = Symbol("kExitCode");
+const kSetMemory = Symbol("kSetMemory");
+const kStarted = Symbol("kStarted");
+const kInstance = Symbol("kInstance");
+const kBindingName = Symbol("kBindingName");
+function validateOptions(options$1) {
+	var _a;
+	validateObject(options$1, "options");
+	let _WASI;
+	if (options$1.version !== void 0) {
+		validateString(options$1.version, "options.version");
+		switch (options$1.version) {
+			case "unstable":
+				_WASI = WASI$1;
+				this[kBindingName] = "wasi_unstable";
+				break;
+			case "preview1":
+				_WASI = WASI$1;
+				this[kBindingName] = "wasi_snapshot_preview1";
+				break;
+			default: throw new TypeError(`unsupported WASI version "${options$1.version}"`);
+		}
+	} else {
+		_WASI = WASI$1;
+		this[kBindingName] = "wasi_snapshot_preview1";
+	}
+	if (options$1.args !== void 0) validateArray(options$1.args, "options.args");
+	const args$1 = ((_a = options$1.args) !== null && _a !== void 0 ? _a : []).map(String);
+	const env = [];
+	if (options$1.env !== void 0) {
+		validateObject(options$1.env, "options.env");
+		Object.entries(options$1.env).forEach(({ 0: key, 1: value }) => {
+			if (value !== void 0) env.push(`${key}=${value}`);
+		});
+	}
+	const preopens = [];
+	if (options$1.preopens !== void 0) {
+		validateObject(options$1.preopens, "options.preopens");
+		Object.entries(options$1.preopens).forEach(({ 0: key, 1: value }) => preopens.push({
+			mappedPath: String(key),
+			realPath: String(value)
+		}));
+	}
+	if (preopens.length > 0) {
+		if (options$1.fs === void 0) throw new Error("filesystem is disabled, can not preopen directory");
+		try {
+			validateObject(options$1.fs, "options.fs");
+		} catch (_) {
+			throw new TypeError("Node.js fs like implementation is not provided");
+		}
+	}
+	if (options$1.print !== void 0) validateFunction(options$1.print, "options.print");
+	if (options$1.printErr !== void 0) validateFunction(options$1.printErr, "options.printErr");
+	if (options$1.returnOnExit !== void 0) validateBoolean(options$1.returnOnExit, "options.returnOnExit");
+	return {
+		args: args$1,
+		env,
+		preopens,
+		stdio: [
+			0,
+			1,
+			2
+		],
+		_WASI
+	};
+}
+function initWASI(setMemory, wrap$3) {
+	this[kSetMemory] = setMemory;
+	this.wasiImport = wrap$3;
+	this[kStarted] = false;
+	this[kExitCode] = 0;
+	this[kInstance] = void 0;
+}
+/** @public */
+var WASI = class {
+	constructor(options$1 = kEmptyObject) {
+		const { args: args$1, env, preopens, stdio, _WASI } = validateOptions.call(this, options$1);
+		const wrap$3 = _WASI.createSync(args$1, env, preopens, stdio, options$1.fs, options$1.print, options$1.printErr);
+		const setMemory = wrap$3._setMemory;
+		delete wrap$3._setMemory;
+		initWASI.call(this, setMemory, wrap$3);
+		if (options$1.returnOnExit) wrap$3.proc_exit = wasiReturnOnProcExit.bind(this);
+	}
+	finalizeBindings(instance$1, _a) {
+		var _b;
+		var { memory = (_b = instance$1 === null || instance$1 === void 0 ? void 0 : instance$1.exports) === null || _b === void 0 ? void 0 : _b.memory } = _a === void 0 ? {} : _a;
+		if (this[kStarted]) throw new Error("WASI instance has already started");
+		validateObject(instance$1, "instance");
+		validateObject(instance$1.exports, "instance.exports");
+		this[kSetMemory](memory);
+		this[kInstance] = instance$1;
+		this[kStarted] = true;
+	}
+	start(instance$1) {
+		this.finalizeBindings(instance$1);
+		const { _start, _initialize } = this[kInstance].exports;
+		validateFunction(_start, "instance.exports._start");
+		validateUndefined(_initialize, "instance.exports._initialize");
+		let ret;
+		try {
+			ret = _start();
+		} catch (err) {
+			if (err !== kExitCode) throw err;
+		}
+		if (ret instanceof Promise) return ret.then(() => this[kExitCode], (err) => {
+			if (err !== kExitCode) throw err;
+			return this[kExitCode];
+		});
+		return this[kExitCode];
+	}
+	initialize(instance$1) {
+		this.finalizeBindings(instance$1);
+		const { _start, _initialize } = this[kInstance].exports;
+		validateUndefined(_start, "instance.exports._start");
+		if (_initialize !== void 0) {
+			validateFunction(_initialize, "instance.exports._initialize");
+			return _initialize();
+		}
+	}
+	getImportObject() {
+		return { [this[kBindingName]]: this.wasiImport };
+	}
+};
+function wasiReturnOnProcExit(rval) {
+	this[kExitCode] = rval;
+	throw kExitCode;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.1/node_modules/@napi-rs/wasm-runtime/fs-proxy.js
+/**
+* @param {unknown} value
+*/
+const getType = (value) => {
+	if (value === void 0) return 0;
+	if (value === null) return 1;
+	const t$2 = typeof value;
+	if (t$2 === "boolean") return 2;
+	if (t$2 === "number") return 3;
+	if (t$2 === "string") return 4;
+	if (t$2 === "object") return 6;
+	if (t$2 === "bigint") return 9;
+	return -1;
+};
+/**
+* @param {import('memfs').IFs} memfs
+* @param {any} value
 * @param {ReturnType<typeof getType>} type
 * @returns {Uint8Array}
 */
@@ -7024,66 +9491,6 @@ const encodeValue = (memfs$1, value, type$1) => {
 	}
 };
 /**
-* @param {typeof import('memfs')} memfs
-* @param {Uint8Array} payload
-* @param {number} type
-* @returns {any}
-*/
-const decodeValue = (memfs$1, payload, type$1) => {
-	if (type$1 === 0) return void 0;
-	if (type$1 === 1) return null;
-	if (type$1 === 2) return Boolean(new Int32Array(payload.buffer, payload.byteOffset, 1)[0]);
-	if (type$1 === 3) return new Float64Array(payload.buffer, payload.byteOffset, 1)[0];
-	if (type$1 === 4) return new TextDecoder().decode(payload.slice());
-	if (type$1 === 6) {
-		const obj = JSON.parse(new TextDecoder().decode(payload.slice()), (_key, value) => {
-			if (typeof value === "string") {
-				const matched = value.match(/^BigInt\((-?\d+)\)$/);
-				if (matched && matched[1]) return BigInt(matched[1]);
-			}
-			return value;
-		});
-		function loadConstructor(obj$1, memfs$2, processed = /* @__PURE__ */ new WeakSet()) {
-			if (!obj$1 || typeof obj$1 !== "object") return;
-			if (processed.has(obj$1)) return;
-			processed.add(obj$1);
-			if (obj$1.__constructor__) {
-				const ctor = obj$1.__constructor__;
-				delete obj$1.__constructor__;
-				Object.setPrototypeOf(obj$1, memfs$2[ctor].prototype);
-			}
-			for (const value of Object.values(obj$1)) loadConstructor(value, memfs$2, processed);
-		}
-		loadConstructor(obj, memfs$1);
-		if (obj.__error__) {
-			const name = obj.__error__;
-			const ErrorConstructor = globalThis[name] || Error;
-			delete obj.__error__;
-			const err = new ErrorConstructor(obj.message);
-			Object.defineProperty(err, "stack", {
-				configurable: true,
-				enumerable: false,
-				writable: true,
-				value: err.stack
-			});
-			Object.defineProperty(err, Symbol.toStringTag, {
-				configurable: true,
-				enumerable: false,
-				writable: true,
-				value: name
-			});
-			for (const [k, v] of Object.entries(obj)) {
-				if (k === "message" || k === "stack") continue;
-				err[k] = v;
-			}
-			return err;
-		}
-		return obj;
-	}
-	if (type$1 === 9) return new BigInt64Array(payload.buffer, payload.byteOffset, 1)[0];
-	throw new Error("unsupported data");
-};
-/**
 * @param {import('memfs').IFs} fs
 * @returns {(e: { data: { __fs__: { sab: Int32Array, type: keyof import('memfs').IFs, payload: any[] } } }) => void}
 */
@@ -7117,44 +9524,6 @@ const createOnMessage = (fs$1) => function onMessage(e$1) {
 		}
 	}
 };
-/**
-* @param {typeof import('memfs')} memfs
-*/
-const createFsProxy = (memfs$1) => new Proxy({}, { get(_target, p, _receiver) {
-	/**
-	* @param {any[]} args
-	*/
-	return function(...args$1) {
-		const sab = new SharedArrayBuffer(10256);
-		const i32arr = new Int32Array(sab);
-		Atomics.store(i32arr, 0, 21);
-		postMessage({ __fs__: {
-			sab: i32arr,
-			type: p,
-			payload: args$1
-		} });
-		Atomics.wait(i32arr, 0, 21);
-		const status = Atomics.load(i32arr, 0);
-		const type$1 = Atomics.load(i32arr, 1);
-		const size = Atomics.load(i32arr, 2);
-		const value = decodeValue(memfs$1, new Uint8Array(sab, 16, size), type$1);
-		if (status === 1) throw value;
-		return value;
-	};
-} });
-
-//#endregion
-//#region ../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.1/node_modules/@napi-rs/wasm-runtime/runtime.js
-var runtime_exports = /* @__PURE__ */ __exportAll({
-	MessageHandler: () => MessageHandler,
-	createFsProxy: () => createFsProxy,
-	createOnMessage: () => createOnMessage,
-	getDefaultContext: () => getDefaultContext,
-	instantiateNapiModule: () => instantiateNapiModule,
-	instantiateNapiModuleSync: () => instantiateNapiModuleSync
-});
-import * as import__tybys_wasm_util from "@tybys/wasm-util";
-__reExport(runtime_exports, import__tybys_wasm_util);
 
 //#endregion
 //#region ../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.1/node_modules/@napi-rs/wasm-runtime/dist/fs.js
@@ -8867,10 +11236,10 @@ function requireUtil$4() {
 	function promisify(fn) {
 		if (typeof fn !== "function") throw new TypeError("The \"original\" argument must be of type function");
 		return function(...args$1) {
-			return new Promise((resolve$1, reject) => {
+			return new Promise((resolve$2, reject) => {
 				fn.call(this, ...args$1, (err, result) => {
 					if (err) reject(err);
-					else resolve$1(result);
+					else resolve$2(result);
 				});
 			});
 		};
@@ -9270,7 +11639,7 @@ function requirePathBrowserify() {
 		return dir + sep$1 + base;
 	}
 	var posix$1 = {
-		resolve: function resolve$1() {
+		resolve: function resolve$2() {
 			var resolvedPath = "";
 			var resolvedAbsolute = false;
 			var cwd$1;
@@ -9628,7 +11997,7 @@ function __extends(d, b) {
 	d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 var __assign = function() {
-	__assign = Object.assign || function __assign$2(t$2) {
+	__assign = Object.assign || function __assign$1(t$2) {
 		for (var s, i = 1, n$1 = arguments.length; i < n$1; i++) {
 			s = arguments[i];
 			for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t$2[p] = s[p];
@@ -9709,11 +12078,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
 	function adopt(value) {
-		return value instanceof P ? value : new P(function(resolve$1) {
-			resolve$1(value);
+		return value instanceof P ? value : new P(function(resolve$2) {
+			resolve$2(value);
 		});
 	}
-	return new (P || (P = Promise))(function(resolve$1, reject) {
+	return new (P || (P = Promise))(function(resolve$2, reject) {
 		function fulfilled(value) {
 			try {
 				step(generator.next(value));
@@ -9729,7 +12098,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
 			}
 		}
 		function step(result) {
-			result.done ? resolve$1(result.value) : adopt(result.value).then(fulfilled, rejected);
+			result.done ? resolve$2(result.value) : adopt(result.value).then(fulfilled, rejected);
 		}
 		step((generator = generator.apply(thisArg, _arguments || [])).next());
 	});
@@ -9953,14 +12322,14 @@ function __asyncValues(o) {
 	}, i);
 	function verb(n$1) {
 		i[n$1] = o[n$1] && function(v) {
-			return new Promise(function(resolve$1, reject) {
-				v = o[n$1](v), settle(resolve$1, reject, v.done, v.value);
+			return new Promise(function(resolve$2, reject) {
+				v = o[n$1](v), settle(resolve$2, reject, v.done, v.value);
 			});
 		};
 	}
-	function settle(resolve$1, reject, d, v) {
+	function settle(resolve$2, reject, d, v) {
 		Promise.resolve(v).then(function(v$1) {
-			resolve$1({
+			resolve$2({
 				value: v$1,
 				done: d
 			});
@@ -10769,14 +13138,14 @@ function requireUtil$3() {
 			return filepath;
 		};
 		exports$1.unixify = unixify;
-		let resolve$1 = (filename, base = process_1.default.cwd()) => resolveCrossPlatform(base, filename);
-		exports$1.resolve = resolve$1;
+		let resolve$2 = (filename, base = process_1.default.cwd()) => resolveCrossPlatform(base, filename);
+		exports$1.resolve = resolve$2;
 		if (exports$1.isWin) {
-			const _resolve = resolve$1;
-			exports$1.resolve = resolve$1 = (filename, base) => (0, exports$1.unixify)(_resolve(filename, base));
+			const _resolve = resolve$2;
+			exports$1.resolve = resolve$2 = (filename, base) => (0, exports$1.unixify)(_resolve(filename, base));
 		}
 		const filenameToSteps = (filename, base) => {
-			const fullPathSansSlash = resolve$1(filename, base).substring(1);
+			const fullPathSansSlash = resolve$2(filename, base).substring(1);
 			if (!fullPathSansSlash) return [];
 			return fullPathSansSlash.split(pathSep);
 		};
@@ -12762,7 +15131,7 @@ function requireStringify() {
 		return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
 	};
 	var sentinel = {};
-	var stringify = function stringify$1(object$1, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format$1, formatter, encodeValuesOnly, charset, sideChannel$1) {
+	var stringify = function stringify$1(object$1, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder$1, filter, sort, allowDots, serializeDate, format$1, formatter, encodeValuesOnly, charset, sideChannel$1) {
 		var obj = object$1;
 		var tmpSc = sideChannel$1;
 		var step = 0;
@@ -12781,18 +15150,18 @@ function requireStringify() {
 			return value$1;
 		});
 		if (obj === null) {
-			if (strictNullHandling) return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format$1) : prefix;
+			if (strictNullHandling) return encoder$1 && !encodeValuesOnly ? encoder$1(prefix, defaults.encoder, charset, "key", format$1) : prefix;
 			obj = "";
 		}
 		if (isNonNullishPrimitive(obj) || utils$2.isBuffer(obj)) {
-			if (encoder) return [formatter(encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format$1)) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format$1))];
+			if (encoder$1) return [formatter(encodeValuesOnly ? prefix : encoder$1(prefix, defaults.encoder, charset, "key", format$1)) + "=" + formatter(encoder$1(obj, defaults.encoder, charset, "value", format$1))];
 			return [formatter(prefix) + "=" + formatter(String(obj))];
 		}
 		var values = [];
 		if (typeof obj === "undefined") return values;
 		var objKeys;
 		if (generateArrayPrefix === "comma" && isArray(obj)) {
-			if (encodeValuesOnly && encoder) obj = utils$2.maybeMap(obj, encoder);
+			if (encodeValuesOnly && encoder$1) obj = utils$2.maybeMap(obj, encoder$1);
 			objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
 		} else if (isArray(filter)) objKeys = filter;
 		else {
@@ -12811,7 +15180,7 @@ function requireStringify() {
 			sideChannel$1.set(object$1, step);
 			var valueSideChannel = getSideChannel();
 			valueSideChannel.set(sentinel, sideChannel$1);
-			pushToArray(values, stringify$1(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format$1, formatter, encodeValuesOnly, charset, valueSideChannel));
+			pushToArray(values, stringify$1(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder$1, filter, sort, allowDots, serializeDate, format$1, formatter, encodeValuesOnly, charset, valueSideChannel));
 		}
 		return values;
 	};
@@ -13530,10 +15899,10 @@ function requireUtil$2() {
 	const queueMicrotask_1 = requireQueueMicrotask();
 	const util_1 = requireUtil$3();
 	function promisify(fs$1, fn, getResult = (input) => input) {
-		return (...args$1) => new Promise((resolve$1, reject) => {
+		return (...args$1) => new Promise((resolve$2, reject) => {
 			fs$1[fn].bind(fs$1)(...args$1, (error$1, result) => {
 				if (error$1) return reject(error$1);
-				return resolve$1(getResult(result));
+				return resolve$2(getResult(result));
 			});
 		});
 	}
@@ -13641,9 +16010,9 @@ function requireUtil$2() {
 	}
 	function streamToBuffer(stream$2) {
 		const chunks = [];
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, reject) => {
 			stream$2.on("data", (chunk) => chunks.push(chunk));
-			stream$2.on("end", () => resolve$1(buffer_1.Buffer.concat(chunks)));
+			stream$2.on("end", () => resolve$2(buffer_1.Buffer.concat(chunks)));
 			stream$2.on("error", reject);
 		});
 	}
@@ -14992,14 +17361,14 @@ function requireEvents$1() {
 		return ret;
 	}
 	function once(emitter, name) {
-		return new Promise(function(resolve$1, reject) {
+		return new Promise(function(resolve$2, reject) {
 			function errorListener(err) {
 				emitter.removeListener(name, resolver);
 				reject(err);
 			}
 			function resolver() {
 				if (typeof emitter.removeListener === "function") emitter.removeListener("error", errorListener);
-				resolve$1([].slice.call(arguments));
+				resolve$2([].slice.call(arguments));
 			}
 			eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
 			if (name !== "error") addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
@@ -15040,7 +17409,7 @@ function requireUtil$1() {
 		const validateAbortSignal = (signal, name) => {
 			if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
 		};
-		const validateFunction = (value, name) => {
+		const validateFunction$1 = (value, name) => {
 			if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
 		};
 		module.exports = {
@@ -15055,22 +17424,22 @@ function requireUtil$1() {
 				};
 			},
 			createDeferredPromise: function() {
-				let resolve$1;
+				let resolve$2;
 				let reject;
 				return {
 					promise: new Promise((res, rej) => {
-						resolve$1 = res;
+						resolve$2 = res;
 						reject = rej;
 					}),
-					resolve: resolve$1,
+					resolve: resolve$2,
 					reject
 				};
 			},
 			promisify(fn) {
-				return new Promise((resolve$1, reject) => {
+				return new Promise((resolve$2, reject) => {
 					fn((err, ...args$1) => {
 						if (err) return reject(err);
-						return resolve$1(...args$1);
+						return resolve$2(...args$1);
 					});
 				});
 			},
@@ -15094,7 +17463,7 @@ function requireUtil$1() {
 			addAbortListener: requireEvents$1().addAbortListener || function addAbortListener(signal, listener) {
 				if (signal === void 0) throw new ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal);
 				validateAbortSignal(signal, "signal");
-				validateFunction(listener, "listener");
+				validateFunction$1(listener, "listener");
 				let removeEventListener;
 				if (signal.aborted) queueMicrotask(() => listener());
 				else {
@@ -15230,7 +17599,7 @@ function requireValidators() {
 	* @returns {asserts value is string}
 	*/
 	/** @type {validateString} */
-	function validateString(value, name) {
+	function validateString$1(value, name) {
 		if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE(name, "string", value);
 	}
 	/**
@@ -15264,7 +17633,7 @@ function requireValidators() {
 	* @returns {asserts value is boolean}
 	*/
 	/** @type {validateBoolean} */
-	function validateBoolean(value, name) {
+	function validateBoolean$1(value, name) {
 		if (typeof value !== "boolean") throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
 	}
 	/**
@@ -15287,7 +17656,7 @@ function requireValidators() {
 	* }} [options]
 	*/
 	/** @type {validateObject} */
-	const validateObject = hideStackFrames((value, name, options$1 = null) => {
+	const validateObject$1 = hideStackFrames((value, name, options$1 = null) => {
 		const allowArray = getOwnPropertyValueOrDefault(options$1, "allowArray", false);
 		const allowFunction = getOwnPropertyValueOrDefault(options$1, "allowFunction", false);
 		if (!getOwnPropertyValueOrDefault(options$1, "nullable", false) && value === null || !allowArray && ArrayIsArray(value) || typeof value !== "object" && (!allowFunction || typeof value !== "function")) throw new ERR_INVALID_ARG_TYPE(name, "Object", value);
@@ -15314,7 +17683,7 @@ function requireValidators() {
 	* @returns {asserts value is any[]}
 	*/
 	/** @type {validateArray} */
-	const validateArray = hideStackFrames((value, name, minLength = 0) => {
+	const validateArray$1 = hideStackFrames((value, name, minLength = 0) => {
 		if (!ArrayIsArray(value)) throw new ERR_INVALID_ARG_TYPE(name, "Array", value);
 		if (value.length < minLength) throw new ERR_INVALID_ARG_VALUE(name, value, `must be longer than ${minLength}`);
 	});
@@ -15326,8 +17695,8 @@ function requireValidators() {
 	*/
 	/** @type {validateStringArray} */
 	function validateStringArray(value, name) {
-		validateArray(value, name);
-		for (let i = 0; i < value.length; i++) validateString(value[i], `${name}[${i}]`);
+		validateArray$1(value, name);
+		for (let i = 0; i < value.length; i++) validateString$1(value[i], `${name}[${i}]`);
 	}
 	/**
 	* @callback validateBooleanArray
@@ -15337,8 +17706,8 @@ function requireValidators() {
 	*/
 	/** @type {validateBooleanArray} */
 	function validateBooleanArray(value, name) {
-		validateArray(value, name);
-		for (let i = 0; i < value.length; i++) validateBoolean(value[i], `${name}[${i}]`);
+		validateArray$1(value, name);
+		for (let i = 0; i < value.length; i++) validateBoolean$1(value[i], `${name}[${i}]`);
 	}
 	/**
 	* @callback validateAbortSignalArray
@@ -15348,7 +17717,7 @@ function requireValidators() {
 	*/
 	/** @type {validateAbortSignalArray} */
 	function validateAbortSignalArray(value, name) {
-		validateArray(value, name);
+		validateArray$1(value, name);
 		for (let i = 0; i < value.length; i++) {
 			const signal = value[i];
 			const indexedName = `${name}[${i}]`;
@@ -15362,7 +17731,7 @@ function requireValidators() {
 	* @returns {asserts signal is keyof signals}
 	*/
 	function validateSignalName(signal, name = "signal") {
-		validateString(signal, name);
+		validateString$1(signal, name);
 		if (signals[signal] === void 0) {
 			if (signals[StringPrototypeToUpperCase(signal)] !== void 0) throw new ERR_UNKNOWN_SIGNAL(signal + " (signals must use all capital letters)");
 			throw new ERR_UNKNOWN_SIGNAL(signal);
@@ -15419,7 +17788,7 @@ function requireValidators() {
 	* @returns {asserts value is Function}
 	*/
 	/** @type {validateFunction} */
-	const validateFunction = hideStackFrames((value, name) => {
+	const validateFunction$1 = hideStackFrames((value, name) => {
 		if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
 	});
 	/**
@@ -15439,7 +17808,7 @@ function requireValidators() {
 	* @returns {asserts value is undefined}
 	*/
 	/** @type {validateUndefined} */
-	const validateUndefined = hideStackFrames((value, name) => {
+	const validateUndefined$1 = hideStackFrames((value, name) => {
 		if (value !== void 0) throw new ERR_INVALID_ARG_TYPE(name, "undefined", value);
 	});
 	/**
@@ -15485,26 +17854,26 @@ function requireValidators() {
 		isInt32,
 		isUint32,
 		parseFileMode,
-		validateArray,
+		validateArray: validateArray$1,
 		validateStringArray,
 		validateBooleanArray,
 		validateAbortSignalArray,
-		validateBoolean,
+		validateBoolean: validateBoolean$1,
 		validateBuffer,
 		validateDictionary,
 		validateEncoding,
-		validateFunction,
+		validateFunction: validateFunction$1,
 		validateInt32,
 		validateInteger,
 		validateNumber: validateNumber$1,
-		validateObject,
+		validateObject: validateObject$1,
 		validateOneOf,
 		validatePlainFunction,
 		validatePort,
 		validateSignalName,
-		validateString,
+		validateString: validateString$1,
 		validateUint32,
-		validateUndefined,
+		validateUndefined: validateUndefined$1,
 		validateUnion,
 		validateAbortSignal,
 		validateLinkHeaderValue
@@ -15703,8 +18072,8 @@ function requireEndOfStream() {
 	const process$3 = requireBrowser$2();
 	const { AbortError, codes } = requireErrors();
 	const { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;
-	const { kEmptyObject, once } = requireUtil$1();
-	const { validateAbortSignal, validateFunction, validateObject, validateBoolean } = requireValidators();
+	const { kEmptyObject: kEmptyObject$1, once } = requireUtil$1();
+	const { validateAbortSignal, validateFunction: validateFunction$1, validateObject: validateObject$1, validateBoolean: validateBoolean$1 } = requireValidators();
 	const { Promise: Promise$1, PromisePrototypeThen, SymbolDispose } = requirePrimordials();
 	const { isClosed, isReadable, isReadableNodeStream, isReadableStream, isReadableFinished, isReadableErrored, isWritable, isWritableNodeStream, isWritableStream, isWritableFinished, isWritableErrored, isNodeStream, willEmitClose: _willEmitClose, kIsClosedPromise } = requireUtils();
 	let addAbortListener;
@@ -15716,10 +18085,10 @@ function requireEndOfStream() {
 		var _options$readable, _options$writable;
 		if (arguments.length === 2) {
 			callback = options$1;
-			options$1 = kEmptyObject;
-		} else if (options$1 == null) options$1 = kEmptyObject;
-		else validateObject(options$1, "options");
-		validateFunction(callback, "callback");
+			options$1 = kEmptyObject$1;
+		} else if (options$1 == null) options$1 = kEmptyObject$1;
+		else validateObject$1(options$1, "options");
+		validateFunction$1(callback, "callback");
 		validateAbortSignal(options$1.signal, "options.signal");
 		callback = once(callback);
 		if (isReadableStream(stream$2) || isWritableStream(stream$2)) return eosWeb(stream$2, options$1, callback);
@@ -15856,16 +18225,16 @@ function requireEndOfStream() {
 	function finished(stream$2, opts) {
 		var _opts;
 		let autoCleanup = false;
-		if (opts === null) opts = kEmptyObject;
+		if (opts === null) opts = kEmptyObject$1;
 		if ((_opts = opts) !== null && _opts !== void 0 && _opts.cleanup) {
-			validateBoolean(opts.cleanup, "cleanup");
+			validateBoolean$1(opts.cleanup, "cleanup");
 			autoCleanup = opts.cleanup;
 		}
-		return new Promise$1((resolve$1, reject) => {
+		return new Promise$1((resolve$2, reject) => {
 			const cleanup = eos(stream$2, opts, (err) => {
 				if (autoCleanup) cleanup();
 				if (err) reject(err);
-				else resolve$1();
+				else resolve$2();
 			});
 		});
 	}
@@ -16723,7 +19092,7 @@ function requireReadable() {
 	const destroyImpl = requireDestroy();
 	const { getHighWaterMark, getDefaultHighWaterMark } = requireState();
 	const { aggregateTwoErrors, codes: { ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED, ERR_OUT_OF_RANGE, ERR_STREAM_PUSH_AFTER_EOF, ERR_STREAM_UNSHIFT_AFTER_END_EVENT }, AbortError } = requireErrors();
-	const { validateObject } = requireValidators();
+	const { validateObject: validateObject$1 } = requireValidators();
 	const kPaused = Symbol$1("kPaused");
 	const { StringDecoder } = requireString_decoder();
 	const from$1 = requireFrom();
@@ -16835,7 +19204,7 @@ function requireReadable() {
 			error$1 = this.readableEnded ? null : new AbortError();
 			this.destroy(error$1);
 		}
-		return new Promise$1((resolve$1, reject) => eos(this, (err) => err && err !== error$1 ? reject(err) : resolve$1(null)));
+		return new Promise$1((resolve$2, reject) => eos(this, (err) => err && err !== error$1 ? reject(err) : resolve$2(null)));
 	};
 	Readable.prototype.push = function(chunk, encoding$1) {
 		return readableAddChunk(this, chunk, encoding$1, false);
@@ -16907,12 +19276,12 @@ function requireReadable() {
 		return state$1[kPaused] === true || state$1.flowing === false;
 	};
 	Readable.prototype.setEncoding = function(enc) {
-		const decoder = new StringDecoder(enc);
-		this._readableState.decoder = decoder;
+		const decoder$1 = new StringDecoder(enc);
+		this._readableState.decoder = decoder$1;
 		this._readableState.encoding = this._readableState.decoder.encoding;
 		const buffer = this._readableState.buffer;
 		let content = "";
-		for (const data of buffer) content += decoder.write(data);
+		for (const data of buffer) content += decoder$1.write(data);
 		buffer.clear();
 		if (content !== "") buffer.push(content);
 		this._readableState.length = content.length;
@@ -17308,7 +19677,7 @@ function requireReadable() {
 		return streamToAsyncIterator(this);
 	};
 	Readable.prototype.iterator = function(options$1) {
-		if (options$1 !== void 0) validateObject(options$1, "options");
+		if (options$1 !== void 0) validateObject$1(options$1, "options");
 		return streamToAsyncIterator(this, options$1);
 	};
 	function streamToAsyncIterator(stream$2, options$1) {
@@ -17319,11 +19688,11 @@ function requireReadable() {
 	}
 	async function* createAsyncIterator(stream$2, options$1) {
 		let callback = nop;
-		function next(resolve$1) {
+		function next(resolve$2) {
 			if (this === stream$2) {
 				callback();
 				callback = nop;
-			} else callback = resolve$1;
+			} else callback = resolve$2;
 		}
 		stream$2.on("readable", next);
 		let error$1;
@@ -18170,7 +20539,7 @@ function requireDuplexify() {
 		], body);
 	};
 	function fromAsyncGen(fn) {
-		let { promise: promise$1, resolve: resolve$1 } = createDeferredPromise();
+		let { promise: promise$1, resolve: resolve$2 } = createDeferredPromise();
 		const ac = new AbortController();
 		const signal = ac.signal;
 		return {
@@ -18182,13 +20551,13 @@ function requireDuplexify() {
 					process$3.nextTick(cb);
 					if (done) return;
 					if (signal.aborted) throw new AbortError(void 0, { cause: signal.reason });
-					({promise: promise$1, resolve: resolve$1} = createDeferredPromise());
+					({promise: promise$1, resolve: resolve$2} = createDeferredPromise());
 					yield chunk;
 				}
 			})(), { signal }),
 			write(chunk, encoding$1, cb) {
-				const _resolve = resolve$1;
-				resolve$1 = null;
+				const _resolve = resolve$2;
+				resolve$2 = null;
 				_resolve({
 					chunk,
 					done: false,
@@ -18196,8 +20565,8 @@ function requireDuplexify() {
 				});
 			},
 			final(cb) {
-				const _resolve = resolve$1;
-				resolve$1 = null;
+				const _resolve = resolve$2;
+				resolve$2 = null;
 				_resolve({
 					done: true,
 					cb
@@ -18517,7 +20886,7 @@ function requirePipeline() {
 	const destroyImpl = requireDestroy();
 	const Duplex = requireDuplex();
 	const { aggregateTwoErrors, codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE, ERR_MISSING_ARGS, ERR_STREAM_DESTROYED, ERR_STREAM_PREMATURE_CLOSE }, AbortError } = requireErrors();
-	const { validateFunction, validateAbortSignal } = requireValidators();
+	const { validateFunction: validateFunction$1, validateAbortSignal } = requireValidators();
 	const { isIterable, isReadable, isReadableNodeStream, isNodeStream, isTransformStream, isWebStream, isReadableStream, isReadableFinished } = requireUtils();
 	const AbortController = globalThis.AbortController || requireBrowser$1().AbortController;
 	let PassThrough;
@@ -18543,7 +20912,7 @@ function requirePipeline() {
 		};
 	}
 	function popCallback(streams) {
-		validateFunction(streams[streams.length - 1], "streams[stream.length - 1]");
+		validateFunction$1(streams[streams.length - 1], "streams[stream.length - 1]");
 		return streams.pop();
 	}
 	function makeAsyncIterable(val) {
@@ -18570,11 +20939,11 @@ function requirePipeline() {
 				callback();
 			}
 		};
-		const wait = () => new Promise$1((resolve$1, reject) => {
+		const wait = () => new Promise$1((resolve$2, reject) => {
 			if (error$1) reject(error$1);
 			else onresolve = () => {
 				if (error$1) reject(error$1);
-				else resolve$1();
+				else resolve$2();
 			};
 		});
 		writable$1.on("drain", resume);
@@ -18941,7 +21310,7 @@ function requireOperators() {
 	hasRequiredOperators = 1;
 	const AbortController = globalThis.AbortController || requireBrowser$1().AbortController;
 	const { codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE }, AbortError } = requireErrors();
-	const { validateAbortSignal, validateInteger, validateObject } = requireValidators();
+	const { validateAbortSignal, validateInteger, validateObject: validateObject$1 } = requireValidators();
 	const kWeakHandler = requirePrimordials().Symbol("kWeak");
 	const kResistStopPropagation = requirePrimordials().Symbol("kResistStopPropagation");
 	const { finished } = requireEndOfStream();
@@ -18953,7 +21322,7 @@ function requireOperators() {
 	const kEmpty = Symbol$1("kEmpty");
 	const kEof = Symbol$1("kEof");
 	function compose$1(stream$2, options$1) {
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		if (isNodeStream(stream$2) && !isWritable(stream$2)) throw new ERR_INVALID_ARG_VALUE("stream", stream$2, "must be writable");
 		const composedStream = staticCompose(this, stream$2);
@@ -18962,7 +21331,7 @@ function requireOperators() {
 	}
 	function map(fn, options$1) {
 		if (typeof fn !== "function") throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		let concurrency = 1;
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.concurrency) != null) concurrency = MathFloor(options$1.concurrency);
@@ -19013,8 +21382,8 @@ function requireOperators() {
 							next();
 							next = null;
 						}
-						if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) await new Promise$1((resolve$1) => {
-							resume = resolve$1;
+						if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) await new Promise$1((resolve$2) => {
+							resume = resolve$2;
 						});
 					}
 					queue.push(kEof);
@@ -19041,8 +21410,8 @@ function requireOperators() {
 						queue.shift();
 						maybeResume();
 					}
-					await new Promise$1((resolve$1) => {
-						next = resolve$1;
+					await new Promise$1((resolve$2) => {
+						next = resolve$2;
 					});
 				}
 			} finally {
@@ -19055,7 +21424,7 @@ function requireOperators() {
 		}.call(this);
 	}
 	function asIndexedPairs(options$1 = void 0) {
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		return async function* asIndexedPairs$1() {
 			let index = 0;
@@ -19104,7 +21473,7 @@ function requireOperators() {
 	async function reduce(reducer, initialValue, options$1) {
 		var _options$signal2;
 		if (typeof reducer !== "function") throw new ERR_INVALID_ARG_TYPE("reducer", ["Function", "AsyncFunction"], reducer);
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		let hasInitialValue = arguments.length > 1;
 		if (options$1 !== null && options$1 !== void 0 && (_options$signal2 = options$1.signal) !== null && _options$signal2 !== void 0 && _options$signal2.aborted) {
@@ -19141,7 +21510,7 @@ function requireOperators() {
 		return initialValue;
 	}
 	async function toArray(options$1) {
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		const result = [];
 		for await (const val of this) {
@@ -19164,7 +21533,7 @@ function requireOperators() {
 		return number$1;
 	}
 	function drop(number$1, options$1 = void 0) {
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		number$1 = toIntegerOrInfinity(number$1);
 		return async function* drop$1() {
@@ -19178,7 +21547,7 @@ function requireOperators() {
 		}.call(this);
 	}
 	function take(number$1, options$1 = void 0) {
-		if (options$1 != null) validateObject(options$1, "options");
+		if (options$1 != null) validateObject$1(options$1, "options");
 		if ((options$1 === null || options$1 === void 0 ? void 0 : options$1.signal) != null) validateAbortSignal(options$1.signal, "options.signal");
 		number$1 = toIntegerOrInfinity(number$1);
 		return async function* take$1() {
@@ -19222,7 +21591,7 @@ function requirePromises() {
 	const { finished } = requireEndOfStream();
 	requireStream$1();
 	function pipeline(...streams) {
-		return new Promise$1((resolve$1, reject) => {
+		return new Promise$1((resolve$2, reject) => {
 			let signal;
 			let end;
 			const lastArg = streams[streams.length - 1];
@@ -19233,7 +21602,7 @@ function requirePromises() {
 			}
 			pl(streams, (err, value) => {
 				if (err) reject(err);
-				else resolve$1(value);
+				else resolve$2(value);
 			}, {
 				signal,
 				end
@@ -19475,8 +21844,8 @@ function requireFileHandle() {
 				this.closePromise = (0, util_1.promisify)(this.fs, "close")(currentFd).finally(() => {
 					this.closePromise = null;
 				});
-			} else this.closePromise = new Promise((resolve$1, reject) => {
-				this.closeResolve = resolve$1;
+			} else this.closePromise = new Promise((resolve$2, reject) => {
+				this.closeResolve = resolve$2;
 				this.closeReject = reject;
 			}).finally(() => {
 				this.closePromise = null;
@@ -19670,8 +22039,8 @@ function requireFsPromises() {
 			}
 			this.eventQueue.push(event);
 			if (this.resolveQueue.length > 0) {
-				const { resolve: resolve$1 } = this.resolveQueue.shift();
-				resolve$1({
+				const { resolve: resolve$2 } = this.resolveQueue.shift();
+				resolve$2({
 					value: this.eventQueue.shift(),
 					done: false
 				});
@@ -19685,9 +22054,9 @@ function requireFsPromises() {
 				this.watcher = null;
 			}
 			while (this.resolveQueue.length > 0) {
-				const { resolve: resolve$1, reject } = this.resolveQueue.shift();
+				const { resolve: resolve$2, reject } = this.resolveQueue.shift();
 				if (error$1) reject(error$1);
-				else resolve$1({
+				else resolve$2({
 					value: void 0,
 					done: true
 				});
@@ -19702,9 +22071,9 @@ function requireFsPromises() {
 				value: this.eventQueue.shift(),
 				done: false
 			};
-			return new Promise((resolve$1, reject) => {
+			return new Promise((resolve$2, reject) => {
 				this.resolveQueue.push({
-					resolve: resolve$1,
+					resolve: resolve$2,
 					reject
 				});
 			});
@@ -20069,10 +22438,10 @@ function requireDir() {
 		close(callback) {
 			if (callback === void 0) {
 				if (this.closed) return Promise.reject(new errors$3.Error("ERR_DIR_CLOSED"));
-				return new Promise((resolve$1, reject) => {
+				return new Promise((resolve$2, reject) => {
 					this.close((err) => {
 						if (err) reject(err);
-						else resolve$1();
+						else resolve$2();
 					});
 				});
 			}
@@ -20102,10 +22471,10 @@ function requireDir() {
 			this.closeBase();
 		}
 		read(callback) {
-			if (callback === void 0) return new Promise((resolve$1, reject) => {
+			if (callback === void 0) return new Promise((resolve$2, reject) => {
 				this.read((err, result) => {
 					if (err) reject(err);
-					else resolve$1(result ?? null);
+					else resolve$2(result ?? null);
 				});
 			});
 			(0, util_1.validateCallback)(callback);
@@ -22012,7 +24381,7 @@ const { createFsFromVolume, Volume, fs, memfs } = memfsExported;
 //#endregion
 //#region ../../node_modules/.pnpm/@rolldown+browser@1.0.0-beta.59/node_modules/@rolldown/browser/dist/rolldown-binding.wasi-browser.js
 const { fs: __fs, vol: __volume } = memfs();
-const __wasi = new runtime_exports.WASI({
+const __wasi = new WASI({
 	version: "preview1",
 	fs: __fs,
 	preopens: { "/": "/" }
@@ -26719,10 +29088,10 @@ function bindingifyExperimental(experimental) {
 		chunkOptimization: experimental?.chunkOptimization
 	};
 }
-function bindingifyResolve(resolve$1) {
+function bindingifyResolve(resolve$1$1) {
 	const yarnPnp = typeof process === "object" && !!process.versions?.pnp;
-	if (resolve$1) {
-		const { alias, extensionAlias, ...rest } = resolve$1;
+	if (resolve$1$1) {
+		const { alias, extensionAlias, ...rest } = resolve$1$1;
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,