@qds.dev/code 0.8.5 → 0.9.7

package/lib/node_modules/.pnpm/@emnapi_wasi-threads@1.1.0/node_modules/@emnapi/wasi-threads/dist/wasi-threads.esm-bundler.qwik.mjs

@@ -1,619 +0,0 @@
-//#region ../../node_modules/.pnpm/@emnapi+wasi-threads@1.1.0/node_modules/@emnapi/wasi-threads/dist/wasi-threads.esm-bundler.js
-var _WebAssembly = 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) {
-	return typeof (options === null || options === void 0 ? void 0 : options.postMessage) === "function" ? options.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 = new ((_a = globalThis[name]) !== null && _a !== void 0 ? _a : name === "RuntimeError" ? (_b = _WebAssembly.RuntimeError) !== null && _b !== void 0 ? _b : Error : Error)(message);
-	Object.defineProperty(error, "stack", {
-		value: stack,
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-	return error;
-}
-/** @public */
-function isSharedArrayBuffer(value) {
-	return typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer || Object.prototype.toString.call(value) === "[object SharedArrayBuffer]";
-}
-/** @public */
-function isTrapError(e) {
-	try {
-		return e instanceof _WebAssembly.RuntimeError;
-	} catch (_) {
-		return false;
-	}
-}
-function createMessage(type, payload) {
-	return { __emnapi__: {
-		type,
-		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
-		};
-	}
-	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) {
-		var _a;
-		this.unusedWorkers = [];
-		this.runningWorkers = [];
-		this.pthreads = Object.create(null);
-		this.wasmModule = null;
-		this.wasmMemory = null;
-		this.messageEvents = /* @__PURE__ */ new WeakMap();
-		if (!options) throw new TypeError("ThreadManager(): options is not provided");
-		if ("childThread" in options) this._childThread = Boolean(options.childThread);
-		else this._childThread = false;
-		if (this._childThread) {
-			this._onCreateWorker = void 0;
-			this._reuseWorker = false;
-			this._beforeLoad = void 0;
-		} else {
-			this._onCreateWorker = options.onCreateWorker;
-			this._reuseWorker = getReuseWorker(options.reuseWorker);
-			this._beforeLoad = options.beforeLoad;
-		}
-		this.printErr = (_a = options.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 = Array(this.unusedWorkers.length);
-		var _loop_1 = function(i$1) {
-			var worker = this_1.unusedWorkers[i$1];
-			if (ENVIRONMENT_IS_NODE) worker.ref();
-			promises[i$1] = this_1.loadWasmModuleToWorker(worker).then(function(w) {
-				if (ENVIRONMENT_IS_NODE) worker.unref();
-				return w;
-			}, function(e) {
-				if (ENVIRONMENT_IS_NODE) worker.unref();
-				throw e;
-			});
-		};
-		var this_1 = this;
-		for (var i = 0; i < this.unusedWorkers.length; ++i) _loop_1(i);
-		return Promise.all(promises).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, reject) {
-			var handleError = function(e) {
-				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) {
-					err(message + " " + e.message);
-					if (e.message.indexOf("RuntimeError") !== -1 || e.message.indexOf("unreachable") !== -1) try {
-						_this.terminateAllThreads();
-					} catch (_) {}
-				} else err(message);
-				reject(e);
-				throw e;
-			};
-			var handleMessage = function(data) {
-				if (data.__emnapi__) {
-					var type = data.__emnapi__.type;
-					var payload = data.__emnapi__.payload;
-					if (type === "loaded") {
-						worker.loaded = true;
-						if (ENVIRONMENT_IS_NODE && !worker.__emnapi_tid) worker.unref();
-						resolve(worker);
-					} else if (type === "cleanup-thread") {
-						if (payload.tid in _this_1.pthreads) _this_1.cleanThread(worker, payload.tid);
-					}
-				}
-			};
-			worker.onmessage = function(e) {
-				handleMessage(e.data);
-				_this_1.fireMessageEvent(worker, e);
-			};
-			worker.onerror = handleError;
-			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) {
-					var _a, _b;
-					(_b = (_a = worker).onerror) === null || _b === void 0 || _b.call(_a, e);
-				});
-				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) {
-			if (e.data.__emnapi__) {
-				var err = _this_1.printErr;
-				err("received \"" + e.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) {
-		var listeners = this.messageEvents.get(worker);
-		if (!listeners) return;
-		var err = this.printErr;
-		listeners.forEach(function(listener) {
-			try {
-				listener(e);
-			} catch (e$1) {
-				err(e$1.stack);
-			}
-		});
-	};
-	return ThreadManager$1;
-}();
-var kIsProxy = Symbol("kIsProxy");
-/** @public */
-function createInstanceProxy(instance, memory) {
-	if (instance[kIsProxy]) return instance;
-	var originalExports = instance.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 = Array.prototype.slice.call(arguments, 1);
-				args.unshift(target);
-				return Reflect[name_1].apply(Reflect, args);
-			};
-		};
-		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, { 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) {
-		var _this_1 = this;
-		if (!options) throw new TypeError("WASIThreads(): options is not provided");
-		if (!options.wasi) throw new TypeError("WASIThreads(): options.wasi is not provided");
-		patchedWasiInstances.set(this, /* @__PURE__ */ new WeakSet());
-		var wasi = options.wasi;
-		patchWasiInstance(this, wasi);
-		this.wasi = wasi;
-		if ("childThread" in options) this.childThread = Boolean(options.childThread);
-		else this.childThread = false;
-		this.PThread = void 0;
-		if ("threadManager" in options) if (typeof options.threadManager === "function") this.PThread = options.threadManager();
-		else this.PThread = options.threadManager;
-		else if (!this.childThread) {
-			this.PThread = new ThreadManager(options);
-			this.PThread.init();
-		}
-		var waitThreadStart = false;
-		if ("waitThreadStart" in options) waitThreadStart = typeof options.waitThreadStart === "number" ? options.waitThreadStart : Boolean(options.waitThreadStart);
-		var postMessage$1 = getPostMessage(options);
-		if (this.childThread && typeof postMessage$1 !== "function") throw new TypeError("options.postMessage is not a function");
-		this.postMessage = postMessage$1;
-		var wasm64 = Boolean(options.wasm64);
-		var onMessage = function(e) {
-			if (e.data.__emnapi__) {
-				var type = e.data.__emnapi__.type;
-				var payload = e.data.__emnapi__.payload;
-				if (type === "spawn-thread") threadSpawn(payload.startArg, payload.errorOrTid);
-				else if (type === "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$1(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) {
-				Atomics.store(struct, 0, 1);
-				Atomics.store(struct, 1, EAGAIN);
-				Atomics.notify(struct, 1);
-				PThread === null || PThread === void 0 || PThread.printErr(e.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;
-	}
-	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, module, memory) {
-		var exports = instance.exports;
-		memory !== null && memory !== void 0 || (memory = exports.memory);
-		if (this.childThread) instance = createInstanceProxy(instance, memory);
-		this.setup(instance, module, memory);
-		var wasi = this.wasi;
-		if ("_start" in exports && typeof exports._start === "function") if (this.childThread) {
-			wasi.start(instance);
-			try {
-				var kStarted = getWasiSymbol(wasi, "kStarted");
-				wasi[kStarted] = false;
-			} catch (_) {}
-		} else setupInstance(wasi, instance);
-		else wasi.initialize(instance);
-		return instance;
-	};
-	/**
-	* 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, module, memory) {
-		var exports = instance.exports;
-		memory !== null && memory !== void 0 || (memory = exports.memory);
-		if (this.childThread) instance = createInstanceProxy(instance, memory);
-		this.setup(instance, module, memory);
-		return {
-			exitCode: this.wasi.start(instance),
-			instance
-		};
-	};
-	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) {
-			_this.terminateAllThreads();
-			return proc_exit_1.call(this, code);
-		};
-	}
-	if (!_this.childThread) {
-		var start_1 = wasi.start;
-		if (typeof start_1 === "function") wasi.start = function(instance) {
-			try {
-				return start_1.call(this, instance);
-			} catch (err) {
-				if (isTrapError(err)) _this.terminateAllThreads();
-				throw err;
-			}
-		};
-	}
-	patched.add(wasi);
-}
-function getWasiSymbol(wasi, description) {
-	var symbols = Object.getOwnPropertySymbols(wasi);
-	var selectDescription = function(description$1) {
-		return function(s) {
-			if (s.description) return s.description === description$1;
-			return s.toString() === "Symbol(".concat(description$1, ")");
-		};
-	};
-	if (Array.isArray(description)) return description.map(function(d) {
-		return symbols.filter(selectDescription(d))[0];
-	});
-	return symbols.filter(selectDescription(description))[0];
-}
-function setupInstance(wasi, instance) {
-	var _a = getWasiSymbol(wasi, ["kInstance", "kSetMemory"]), kInstance = _a[0], kSetMemory = _a[1];
-	wasi[kInstance] = instance;
-	wasi[kSetMemory](instance.exports.memory);
-}
-
-//#endregion
-export { ThreadManager, WASIThreads, createInstanceProxy, isSharedArrayBuffer, isTrapError };