@zh-keyboard/pinyin 1.0.0

package/dist/index.mjs

@@ -0,0 +1,3580 @@
+//#region data/rime-api.js
+async function createRimeModule(moduleArg = {}) {
+	let moduleRtn;
+	const Module = moduleArg;
+	const ENVIRONMENT_IS_WEB = !!globalThis.window;
+	const ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+	const ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+	if (ENVIRONMENT_IS_NODE) {
+		const { createRequire } = await import("node:module");
+		var require = createRequire(import.meta.url);
+	}
+	if (!Module.expectedDataFileDownloads) Module.expectedDataFileDownloads = 0;
+	Module.expectedDataFileDownloads++;
+	(() => {
+		const isPthread = typeof ENVIRONMENT_IS_PTHREAD != "undefined" && ENVIRONMENT_IS_PTHREAD;
+		const isWasmWorker = typeof ENVIRONMENT_IS_WASM_WORKER != "undefined" && ENVIRONMENT_IS_WASM_WORKER;
+		if (isPthread || isWasmWorker) return;
+		const isNode = globalThis.process && globalThis.process.versions && globalThis.process.versions.node && globalThis.process.type != "renderer";
+		async function loadPackage(metadata) {
+			let PACKAGE_PATH = "";
+			if (typeof window === "object") PACKAGE_PATH = window.encodeURIComponent(`${window.location.pathname.substring(0, window.location.pathname.lastIndexOf("/"))}/`);
+			else if (typeof process === "undefined" && typeof location !== "undefined") PACKAGE_PATH = encodeURIComponent(`${location.pathname.substring(0, location.pathname.lastIndexOf("/"))}/`);
+			const PACKAGE_NAME = "/home/zzx/work/librime/wasm/dist/rime-api.data";
+			const REMOTE_PACKAGE_BASE = "rime-api.data";
+			const REMOTE_PACKAGE_NAME = Module.locateFile ? Module.locateFile(REMOTE_PACKAGE_BASE, "") : REMOTE_PACKAGE_BASE;
+			const REMOTE_PACKAGE_SIZE = metadata.remote_package_size;
+			async function fetchRemotePackage(packageName, packageSize) {
+				if (isNode) {
+					const contents = require("node:fs").readFileSync(packageName);
+					return new Uint8Array(contents).buffer;
+				}
+				if (!Module.dataFileDownloads) Module.dataFileDownloads = {};
+				try {
+					var response = await fetch(packageName);
+				} catch (e) {
+					throw new Error(`Network Error: ${packageName}`, { e });
+				}
+				if (!response.ok) throw new Error(`${response.status}: ${response.url}`);
+				const chunks = [];
+				const headers = response.headers;
+				const total = Number(headers.get("Content-Length") || packageSize);
+				let loaded = 0;
+				Module.setStatus && Module.setStatus("Downloading data...");
+				const reader = response.body.getReader();
+				while (1) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					chunks.push(value);
+					loaded += value.length;
+					Module.dataFileDownloads[packageName] = {
+						loaded,
+						total
+					};
+					let totalLoaded = 0;
+					let totalSize = 0;
+					for (const download of Object.values(Module.dataFileDownloads)) {
+						totalLoaded += download.loaded;
+						totalSize += download.total;
+					}
+					Module.setStatus && Module.setStatus(`Downloading data... (${totalLoaded}/${totalSize})`);
+				}
+				const packageData = new Uint8Array(chunks.map((c) => c.length).reduce((a, b) => a + b, 0));
+				let offset = 0;
+				for (const chunk of chunks) {
+					packageData.set(chunk, offset);
+					offset += chunk.length;
+				}
+				return packageData.buffer;
+			}
+			let fetchPromise;
+			let fetched = Module.getPreloadedPackage && Module.getPreloadedPackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE);
+			if (!fetched) fetchPromise = fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE);
+			async function runWithFS(Module$1) {
+				function assert(check, msg) {
+					if (!check) throw new Error(msg);
+				}
+				Module$1.FS_createPath("/", "rime", true, true);
+				Module$1.FS_createPath("/rime", "opencc", true, true);
+				for (const file of metadata.files) {
+					const name = file.filename;
+					Module$1.addRunDependency(`fp ${name}`);
+				}
+				async function processPackageData(arrayBuffer) {
+					assert(arrayBuffer, "Loading data file failed.");
+					assert(arrayBuffer.constructor.name === ArrayBuffer.name, `bad input to processPackageData ${arrayBuffer.constructor.name}`);
+					const byteArray = new Uint8Array(arrayBuffer);
+					for (const file of metadata.files) {
+						const name = file.filename;
+						const data = byteArray.subarray(file.start, file.end);
+						Module$1.FS_createDataFile(name, null, data, true, true, true);
+						Module$1.removeRunDependency(`fp ${name}`);
+					}
+					Module$1.removeRunDependency("datafile_/home/zzx/work/librime/wasm/dist/rime-api.data");
+				}
+				Module$1.addRunDependency("datafile_/home/zzx/work/librime/wasm/dist/rime-api.data");
+				if (!Module$1.preloadResults) Module$1.preloadResults = {};
+				Module$1.preloadResults[PACKAGE_NAME] = { fromCache: false };
+				if (!fetched) fetched = await fetchPromise;
+				processPackageData(fetched);
+			}
+			if (Module.calledRun) runWithFS(Module);
+			else {
+				if (!Module.preRun) Module.preRun = [];
+				Module.preRun.push(runWithFS);
+			}
+		}
+		loadPackage({
+			files: [
+				{
+					filename: "/rime/opencc/STCharacters.ocd2",
+					start: 0,
+					end: 45310
+				},
+				{
+					filename: "/rime/opencc/STPhrases.ocd2",
+					start: 45310,
+					end: 971027
+				},
+				{
+					filename: "/rime/opencc/TSCharacters.ocd2",
+					start: 971027,
+					end: 1017153
+				},
+				{
+					filename: "/rime/opencc/TSPhrases.ocd2",
+					start: 1017153,
+					end: 1026935
+				},
+				{
+					filename: "/rime/opencc/s2t.json",
+					start: 1026935,
+					end: 1027341
+				},
+				{
+					filename: "/rime/opencc/t2s.json",
+					start: 1027341,
+					end: 1027747
+				}
+			],
+			remote_package_size: 1027747
+		});
+	})();
+	let arguments_ = [];
+	let thisProgram = "./this.program";
+	let quit_ = (status, toThrow) => {
+		throw toThrow;
+	};
+	const _scriptName = import.meta.url;
+	let scriptDirectory = "";
+	function locateFile(path) {
+		if (Module.locateFile) return Module.locateFile(path, scriptDirectory);
+		return scriptDirectory + path;
+	}
+	let readAsync, readBinary;
+	if (ENVIRONMENT_IS_NODE) {
+		var fs = require("node:fs");
+		if (_scriptName.startsWith("file:")) scriptDirectory = `${require("node:path").dirname(require("node:url").fileURLToPath(_scriptName))}/`;
+		readBinary = (filename) => {
+			filename = isFileURI(filename) ? new URL(filename) : filename;
+			const ret = fs.readFileSync(filename);
+			return ret;
+		};
+		readAsync = async (filename, binary = true) => {
+			filename = isFileURI(filename) ? new URL(filename) : filename;
+			const ret = fs.readFileSync(filename, binary ? void 0 : "utf8");
+			return ret;
+		};
+		if (process.argv.length > 1) thisProgram = process.argv[1].replace(/\\/g, "/");
+		arguments_ = process.argv.slice(2);
+		quit_ = (status, toThrow) => {
+			process.exitCode = status;
+			throw toThrow;
+		};
+	} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+		try {
+			scriptDirectory = new URL(".", _scriptName).href;
+		} catch {}
+		{
+			if (ENVIRONMENT_IS_WORKER) readBinary = (url) => {
+				const xhr = new XMLHttpRequest();
+				xhr.open("GET", url, false);
+				xhr.responseType = "arraybuffer";
+				xhr.send(null);
+				return new Uint8Array(xhr.response);
+			};
+			readAsync = async (url) => {
+				if (isFileURI(url)) return new Promise((resolve, reject) => {
+					const xhr = new XMLHttpRequest();
+					xhr.open("GET", url, true);
+					xhr.responseType = "arraybuffer";
+					xhr.onload = () => {
+						if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+							resolve(xhr.response);
+							return;
+						}
+						reject(xhr.status);
+					};
+					xhr.onerror = reject;
+					xhr.send(null);
+				});
+				const response = await fetch(url, { credentials: "same-origin" });
+				if (response.ok) return response.arrayBuffer();
+				throw new Error(`${response.status} : ${response.url}`);
+			};
+		}
+	}
+	let out = console.log.bind(console);
+	let err = console.error.bind(console);
+	let wasmBinary;
+	let ABORT = false;
+	let EXITSTATUS;
+	var isFileURI = (filename) => filename.startsWith("file://");
+	let readyPromiseResolve, readyPromiseReject;
+	let HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+	let HEAP64, HEAPU64;
+	let runtimeInitialized = false;
+	function updateMemoryViews() {
+		const b = wasmMemory.buffer;
+		HEAP8 = new Int8Array(b);
+		HEAP16 = new Int16Array(b);
+		HEAPU8 = new Uint8Array(b);
+		HEAPU16 = new Uint16Array(b);
+		HEAP32 = new Int32Array(b);
+		HEAPU32 = new Uint32Array(b);
+		HEAPF32 = new Float32Array(b);
+		HEAPF64 = new Float64Array(b);
+		HEAP64 = new BigInt64Array(b);
+		HEAPU64 = new BigUint64Array(b);
+	}
+	function preRun() {
+		if (Module.preRun) {
+			if (typeof Module.preRun == "function") Module.preRun = [Module.preRun];
+			while (Module.preRun.length) addOnPreRun(Module.preRun.shift());
+		}
+		callRuntimeCallbacks(onPreRuns);
+	}
+	function initRuntime() {
+		runtimeInitialized = true;
+		if (!Module.noFSInit && !FS.initialized) FS.init();
+		TTY.init();
+		wasmExports.Q();
+		FS.ignorePermissions = false;
+	}
+	function postRun() {
+		if (Module.postRun) {
+			if (typeof Module.postRun == "function") Module.postRun = [Module.postRun];
+			while (Module.postRun.length) addOnPostRun(Module.postRun.shift());
+		}
+		callRuntimeCallbacks(onPostRuns);
+	}
+	function abort(what) {
+		Module.onAbort?.(what);
+		what = `Aborted(${what})`;
+		err(what);
+		ABORT = true;
+		what += ". Build with -sASSERTIONS for more info.";
+		if (runtimeInitialized) ___trap();
+		const e = new WebAssembly.RuntimeError(what);
+		readyPromiseReject?.(e);
+		throw e;
+	}
+	let wasmBinaryFile;
+	function findWasmBinary() {
+		if (Module.locateFile) return locateFile("rime-api.wasm");
+		return new URL("rime-api.wasm", import.meta.url).href;
+	}
+	function getBinarySync(file) {
+		if (file == wasmBinaryFile && wasmBinary) return new Uint8Array(wasmBinary);
+		if (readBinary) return readBinary(file);
+		throw "both async and sync fetching of the wasm failed";
+	}
+	async function getWasmBinary(binaryFile) {
+		if (!wasmBinary) try {
+			const response = await readAsync(binaryFile);
+			return new Uint8Array(response);
+		} catch {}
+		return getBinarySync(binaryFile);
+	}
+	async function instantiateArrayBuffer(binaryFile, imports) {
+		try {
+			const binary = await getWasmBinary(binaryFile);
+			const instance = await WebAssembly.instantiate(binary, imports);
+			return instance;
+		} catch (reason) {
+			err(`failed to asynchronously prepare wasm: ${reason}`);
+			abort(reason);
+		}
+	}
+	async function instantiateAsync(binary, binaryFile, imports) {
+		if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) try {
+			const response = fetch(binaryFile, { credentials: "same-origin" });
+			const instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+			return instantiationResult;
+		} catch (reason) {
+			err(`wasm streaming compile failed: ${reason}`);
+			err("falling back to ArrayBuffer instantiation");
+		}
+		return instantiateArrayBuffer(binaryFile, imports);
+	}
+	function getWasmImports() {
+		const imports = { a: wasmImports };
+		return imports;
+	}
+	async function createWasm() {
+		function receiveInstance(instance, module) {
+			wasmExports = instance.exports;
+			wasmExports = applySignatureConversions(wasmExports);
+			assignWasmExports(wasmExports);
+			updateMemoryViews();
+			return wasmExports;
+		}
+		function receiveInstantiationResult(result$1) {
+			return receiveInstance(result$1.instance);
+		}
+		const info = getWasmImports();
+		if (Module.instantiateWasm) return new Promise((resolve, reject) => {
+			Module.instantiateWasm(info, (inst, mod) => {
+				resolve(receiveInstance(inst, mod));
+			});
+		});
+		wasmBinaryFile ??= findWasmBinary();
+		const result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+		const exports = receiveInstantiationResult(result);
+		return exports;
+	}
+	class ExitStatus {
+		name = "ExitStatus";
+		constructor(status) {
+			this.message = `Program terminated with exit(${status})`;
+			this.status = status;
+		}
+	}
+	var callRuntimeCallbacks = (callbacks) => {
+		while (callbacks.length > 0) callbacks.shift()(Module);
+	};
+	var onPostRuns = [];
+	var addOnPostRun = (cb) => onPostRuns.push(cb);
+	var onPreRuns = [];
+	var addOnPreRun = (cb) => onPreRuns.push(cb);
+	let noExitRuntime = true;
+	var PATH = {
+		isAbs: (path) => path.charAt(0) === "/",
+		splitPath: (filename) => {
+			const splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?)?(\.[^./]*|))\/*$/;
+			return splitPathRe.exec(filename).slice(1);
+		},
+		normalizeArray: (parts, allowAboveRoot) => {
+			let up = 0;
+			for (let i = parts.length - 1; i >= 0; i--) {
+				const last = parts[i];
+				if (last === ".") parts.splice(i, 1);
+				else if (last === "..") {
+					parts.splice(i, 1);
+					up++;
+				} else if (up) {
+					parts.splice(i, 1);
+					up--;
+				}
+			}
+			if (allowAboveRoot) for (; up; up--) parts.unshift("..");
+			return parts;
+		},
+		normalize: (path) => {
+			const isAbsolute = PATH.isAbs(path);
+			const trailingSlash = path.slice(-1) === "/";
+			path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
+			if (!path && !isAbsolute) path = ".";
+			if (path && trailingSlash) path += "/";
+			return (isAbsolute ? "/" : "") + path;
+		},
+		dirname: (path) => {
+			const result = PATH.splitPath(path);
+			const root = result[0];
+			let dir = result[1];
+			if (!root && !dir) return ".";
+			if (dir) dir = dir.slice(0, -1);
+			return root + dir;
+		},
+		basename: (path) => path && path.match(/([^/]+|\/)\/*$/)[1],
+		join: (...paths) => PATH.normalize(paths.join("/")),
+		join2: (l, r) => PATH.normalize(`${l}/${r}`)
+	};
+	const initRandomFill = () => {
+		if (ENVIRONMENT_IS_NODE) {
+			const nodeCrypto = require("node:crypto");
+			return (view) => nodeCrypto.randomFillSync(view);
+		}
+		return (view) => crypto.getRandomValues(view);
+	};
+	let randomFill = (view) => {
+		(randomFill = initRandomFill())(view);
+	};
+	var PATH_FS = {
+		resolve: (...args) => {
+			let resolvedPath = "";
+			let resolvedAbsolute = false;
+			for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+				const path = i >= 0 ? args[i] : FS.cwd();
+				if (typeof path != "string") throw new TypeError("Arguments to path.resolve must be strings");
+				else if (!path) return "";
+				resolvedPath = `${path}/${resolvedPath}`;
+				resolvedAbsolute = PATH.isAbs(path);
+			}
+			resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
+			return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+		},
+		relative: (from, to) => {
+			from = PATH_FS.resolve(from).slice(1);
+			to = PATH_FS.resolve(to).slice(1);
+			function trim(arr) {
+				let start = 0;
+				for (; start < arr.length; start++) if (arr[start] !== "") break;
+				let end = arr.length - 1;
+				for (; end >= 0; end--) if (arr[end] !== "") break;
+				if (start > end) return [];
+				return arr.slice(start, end - start + 1);
+			}
+			const fromParts = trim(from.split("/"));
+			const toParts = trim(to.split("/"));
+			const length = Math.min(fromParts.length, toParts.length);
+			let samePartsLength = length;
+			for (var i = 0; i < length; i++) if (fromParts[i] !== toParts[i]) {
+				samePartsLength = i;
+				break;
+			}
+			let outputParts = [];
+			for (var i = samePartsLength; i < fromParts.length; i++) outputParts.push("..");
+			outputParts = outputParts.concat(toParts.slice(samePartsLength));
+			return outputParts.join("/");
+		}
+	};
+	const UTF8Decoder = new TextDecoder();
+	const findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+		const maxIdx = idx + maxBytesToRead;
+		if (ignoreNul) return maxIdx;
+		while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+		return idx;
+	};
+	const UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+		idx >>>= 0;
+		const endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+		return UTF8Decoder.decode(heapOrArray.buffer ? heapOrArray.subarray(idx, endPtr) : new Uint8Array(heapOrArray.slice(idx, endPtr)));
+	};
+	let FS_stdin_getChar_buffer = [];
+	const lengthBytesUTF8 = (str) => {
+		let len = 0;
+		for (let i = 0; i < str.length; ++i) {
+			const c = str.charCodeAt(i);
+			if (c <= 127) len++;
+			else if (c <= 2047) len += 2;
+			else if (c >= 55296 && c <= 57343) {
+				len += 4;
+				++i;
+			} else len += 3;
+		}
+		return len;
+	};
+	const stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+		outIdx >>>= 0;
+		if (!(maxBytesToWrite > 0)) return 0;
+		const startIdx = outIdx;
+		const endIdx = outIdx + maxBytesToWrite - 1;
+		for (let i = 0; i < str.length; ++i) {
+			const u = str.codePointAt(i);
+			if (u <= 127) {
+				if (outIdx >= endIdx) break;
+				heap[outIdx++ >>> 0] = u;
+			} else if (u <= 2047) {
+				if (outIdx + 1 >= endIdx) break;
+				heap[outIdx++ >>> 0] = 192 | u >> 6;
+				heap[outIdx++ >>> 0] = 128 | u & 63;
+			} else if (u <= 65535) {
+				if (outIdx + 2 >= endIdx) break;
+				heap[outIdx++ >>> 0] = 224 | u >> 12;
+				heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+				heap[outIdx++ >>> 0] = 128 | u & 63;
+			} else {
+				if (outIdx + 3 >= endIdx) break;
+				heap[outIdx++ >>> 0] = 240 | u >> 18;
+				heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
+				heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+				heap[outIdx++ >>> 0] = 128 | u & 63;
+				i++;
+			}
+		}
+		heap[outIdx >>> 0] = 0;
+		return outIdx - startIdx;
+	};
+	const intArrayFromString = (stringy, dontAddNull, length) => {
+		const len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+		const u8array = new Array(len);
+		const numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+		if (dontAddNull) u8array.length = numBytesWritten;
+		return u8array;
+	};
+	const FS_stdin_getChar = () => {
+		if (!FS_stdin_getChar_buffer.length) {
+			let result = null;
+			if (ENVIRONMENT_IS_NODE) {
+				const BUFSIZE = 256;
+				const buf = Buffer.alloc(BUFSIZE);
+				let bytesRead = 0;
+				const fd = process.stdin.fd;
+				try {
+					bytesRead = fs.readSync(fd, buf, 0, BUFSIZE);
+				} catch (e) {
+					if (e.toString().includes("EOF")) bytesRead = 0;
+					else throw e;
+				}
+				if (bytesRead > 0) result = buf.slice(0, bytesRead).toString("utf-8");
+			} else if (globalThis.window?.prompt) {
+				result = window.prompt("Input: ");
+				if (result !== null) result += "\n";
+			}
+			if (!result) return null;
+			FS_stdin_getChar_buffer = intArrayFromString(result, true);
+		}
+		return FS_stdin_getChar_buffer.shift();
+	};
+	var TTY = {
+		ttys: [],
+		init() {},
+		shutdown() {},
+		register(dev, ops) {
+			TTY.ttys[dev] = {
+				input: [],
+				output: [],
+				ops
+			};
+			FS.registerDevice(dev, TTY.stream_ops);
+		},
+		stream_ops: {
+			open(stream) {
+				const tty = TTY.ttys[stream.node.rdev];
+				if (!tty) throw new FS.ErrnoError(43);
+				stream.tty = tty;
+				stream.seekable = false;
+			},
+			close(stream) {
+				stream.tty.ops.fsync(stream.tty);
+			},
+			fsync(stream) {
+				stream.tty.ops.fsync(stream.tty);
+			},
+			read(stream, buffer, offset, length, pos) {
+				if (!stream.tty || !stream.tty.ops.get_char) throw new FS.ErrnoError(60);
+				let bytesRead = 0;
+				for (let i = 0; i < length; i++) {
+					var result;
+					try {
+						result = stream.tty.ops.get_char(stream.tty);
+					} catch (e) {
+						throw new FS.ErrnoError(29);
+					}
+					if (result === void 0 && bytesRead === 0) throw new FS.ErrnoError(6);
+					if (result === null || result === void 0) break;
+					bytesRead++;
+					buffer[offset + i] = result;
+				}
+				if (bytesRead) stream.node.atime = Date.now();
+				return bytesRead;
+			},
+			write(stream, buffer, offset, length, pos) {
+				if (!stream.tty || !stream.tty.ops.put_char) throw new FS.ErrnoError(60);
+				try {
+					for (var i = 0; i < length; i++) stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+				} catch (e) {
+					throw new FS.ErrnoError(29);
+				}
+				if (length) stream.node.mtime = stream.node.ctime = Date.now();
+				return i;
+			}
+		},
+		default_tty_ops: {
+			get_char(tty) {
+				return FS_stdin_getChar();
+			},
+			put_char(tty, val) {
+				if (val === null || val === 10) {
+					out(UTF8ArrayToString(tty.output));
+					tty.output = [];
+				} else if (val != 0) tty.output.push(val);
+			},
+			fsync(tty) {
+				if (tty.output?.length > 0) {
+					out(UTF8ArrayToString(tty.output));
+					tty.output = [];
+				}
+			},
+			ioctl_tcgets(tty) {
+				return {
+					c_iflag: 25856,
+					c_oflag: 5,
+					c_cflag: 191,
+					c_lflag: 35387,
+					c_cc: [
+						3,
+						28,
+						127,
+						21,
+						4,
+						0,
+						1,
+						0,
+						17,
+						19,
+						26,
+						0,
+						18,
+						15,
+						23,
+						22,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0
+					]
+				};
+			},
+			ioctl_tcsets(tty, optional_actions, data) {
+				return 0;
+			},
+			ioctl_tiocgwinsz(tty) {
+				return [24, 80];
+			}
+		},
+		default_tty1_ops: {
+			put_char(tty, val) {
+				if (val === null || val === 10) {
+					err(UTF8ArrayToString(tty.output));
+					tty.output = [];
+				} else if (val != 0) tty.output.push(val);
+			},
+			fsync(tty) {
+				if (tty.output?.length > 0) {
+					err(UTF8ArrayToString(tty.output));
+					tty.output = [];
+				}
+			}
+		}
+	};
+	const zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
+	const alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+	const mmapAlloc = (size) => {
+		size = alignMemory(size, 65536);
+		const ptr = _emscripten_builtin_memalign(65536, size);
+		if (ptr) zeroMemory(ptr, size);
+		return ptr;
+	};
+	var MEMFS = {
+		ops_table: null,
+		mount(mount) {
+			return MEMFS.createNode(null, "/", 16895, 0);
+		},
+		createNode(parent, name, mode, dev) {
+			if (FS.isBlkdev(mode) || FS.isFIFO(mode)) throw new FS.ErrnoError(63);
+			MEMFS.ops_table ||= {
+				dir: {
+					node: {
+						getattr: MEMFS.node_ops.getattr,
+						setattr: MEMFS.node_ops.setattr,
+						lookup: MEMFS.node_ops.lookup,
+						mknod: MEMFS.node_ops.mknod,
+						rename: MEMFS.node_ops.rename,
+						unlink: MEMFS.node_ops.unlink,
+						rmdir: MEMFS.node_ops.rmdir,
+						readdir: MEMFS.node_ops.readdir,
+						symlink: MEMFS.node_ops.symlink
+					},
+					stream: { llseek: MEMFS.stream_ops.llseek }
+				},
+				file: {
+					node: {
+						getattr: MEMFS.node_ops.getattr,
+						setattr: MEMFS.node_ops.setattr
+					},
+					stream: {
+						llseek: MEMFS.stream_ops.llseek,
+						read: MEMFS.stream_ops.read,
+						write: MEMFS.stream_ops.write,
+						mmap: MEMFS.stream_ops.mmap,
+						msync: MEMFS.stream_ops.msync
+					}
+				},
+				link: {
+					node: {
+						getattr: MEMFS.node_ops.getattr,
+						setattr: MEMFS.node_ops.setattr,
+						readlink: MEMFS.node_ops.readlink
+					},
+					stream: {}
+				},
+				chrdev: {
+					node: {
+						getattr: MEMFS.node_ops.getattr,
+						setattr: MEMFS.node_ops.setattr
+					},
+					stream: FS.chrdev_stream_ops
+				}
+			};
+			const node = FS.createNode(parent, name, mode, dev);
+			if (FS.isDir(node.mode)) {
+				node.node_ops = MEMFS.ops_table.dir.node;
+				node.stream_ops = MEMFS.ops_table.dir.stream;
+				node.contents = {};
+			} else if (FS.isFile(node.mode)) {
+				node.node_ops = MEMFS.ops_table.file.node;
+				node.stream_ops = MEMFS.ops_table.file.stream;
+				node.usedBytes = 0;
+				node.contents = null;
+			} else if (FS.isLink(node.mode)) {
+				node.node_ops = MEMFS.ops_table.link.node;
+				node.stream_ops = MEMFS.ops_table.link.stream;
+			} else if (FS.isChrdev(node.mode)) {
+				node.node_ops = MEMFS.ops_table.chrdev.node;
+				node.stream_ops = MEMFS.ops_table.chrdev.stream;
+			}
+			node.atime = node.mtime = node.ctime = Date.now();
+			if (parent) {
+				parent.contents[name] = node;
+				parent.atime = parent.mtime = parent.ctime = node.atime;
+			}
+			return node;
+		},
+		getFileDataAsTypedArray(node) {
+			if (!node.contents) return new Uint8Array(0);
+			if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
+			return new Uint8Array(node.contents);
+		},
+		expandFileStorage(node, newCapacity) {
+			const prevCapacity = node.contents ? node.contents.length : 0;
+			if (prevCapacity >= newCapacity) return;
+			const CAPACITY_DOUBLING_MAX = 1024 * 1024;
+			newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
+			if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
+			const oldContents = node.contents;
+			node.contents = new Uint8Array(newCapacity);
+			if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
+		},
+		resizeFileStorage(node, newSize) {
+			if (node.usedBytes == newSize) return;
+			if (newSize == 0) {
+				node.contents = null;
+				node.usedBytes = 0;
+			} else {
+				const oldContents = node.contents;
+				node.contents = new Uint8Array(newSize);
+				if (oldContents) node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
+				node.usedBytes = newSize;
+			}
+		},
+		node_ops: {
+			getattr(node) {
+				const attr = {};
+				attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+				attr.ino = node.id;
+				attr.mode = node.mode;
+				attr.nlink = 1;
+				attr.uid = 0;
+				attr.gid = 0;
+				attr.rdev = node.rdev;
+				if (FS.isDir(node.mode)) attr.size = 4096;
+				else if (FS.isFile(node.mode)) attr.size = node.usedBytes;
+				else if (FS.isLink(node.mode)) attr.size = node.link.length;
+				else attr.size = 0;
+				attr.atime = new Date(node.atime);
+				attr.mtime = new Date(node.mtime);
+				attr.ctime = new Date(node.ctime);
+				attr.blksize = 4096;
+				attr.blocks = Math.ceil(attr.size / attr.blksize);
+				return attr;
+			},
+			setattr(node, attr) {
+				for (const key of [
+					"mode",
+					"atime",
+					"mtime",
+					"ctime"
+				]) if (attr[key] != null) node[key] = attr[key];
+				if (attr.size !== void 0) MEMFS.resizeFileStorage(node, attr.size);
+			},
+			lookup(parent, name) {
+				if (!MEMFS.doesNotExistError) {
+					MEMFS.doesNotExistError = new FS.ErrnoError(44);
+					MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+				}
+				throw MEMFS.doesNotExistError;
+			},
+			mknod(parent, name, mode, dev) {
+				return MEMFS.createNode(parent, name, mode, dev);
+			},
+			rename(old_node, new_dir, new_name) {
+				let new_node;
+				try {
+					new_node = FS.lookupNode(new_dir, new_name);
+				} catch (e) {}
+				if (new_node) {
+					if (FS.isDir(old_node.mode)) for (const i in new_node.contents) throw new FS.ErrnoError(55);
+					FS.hashRemoveNode(new_node);
+				}
+				delete old_node.parent.contents[old_node.name];
+				new_dir.contents[new_name] = old_node;
+				old_node.name = new_name;
+				new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
+			},
+			unlink(parent, name) {
+				delete parent.contents[name];
+				parent.ctime = parent.mtime = Date.now();
+			},
+			rmdir(parent, name) {
+				const node = FS.lookupNode(parent, name);
+				for (const i in node.contents) throw new FS.ErrnoError(55);
+				delete parent.contents[name];
+				parent.ctime = parent.mtime = Date.now();
+			},
+			readdir(node) {
+				return [
+					".",
+					"..",
+					...Object.keys(node.contents)
+				];
+			},
+			symlink(parent, newname, oldpath) {
+				const node = MEMFS.createNode(parent, newname, 41471, 0);
+				node.link = oldpath;
+				return node;
+			},
+			readlink(node) {
+				if (!FS.isLink(node.mode)) throw new FS.ErrnoError(28);
+				return node.link;
+			}
+		},
+		stream_ops: {
+			read(stream, buffer, offset, length, position) {
+				const contents = stream.node.contents;
+				if (position >= stream.node.usedBytes) return 0;
+				const size = Math.min(stream.node.usedBytes - position, length);
+				if (size > 8 && contents.subarray) buffer.set(contents.subarray(position, position + size), offset);
+				else for (let i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
+				return size;
+			},
+			write(stream, buffer, offset, length, position, canOwn) {
+				if (buffer.buffer === HEAP8.buffer) canOwn = false;
+				if (!length) return 0;
+				const node = stream.node;
+				node.mtime = node.ctime = Date.now();
+				if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+					if (canOwn) {
+						node.contents = buffer.subarray(offset, offset + length);
+						node.usedBytes = length;
+						return length;
+					} else if (node.usedBytes === 0 && position === 0) {
+						node.contents = buffer.slice(offset, offset + length);
+						node.usedBytes = length;
+						return length;
+					} else if (position + length <= node.usedBytes) {
+						node.contents.set(buffer.subarray(offset, offset + length), position);
+						return length;
+					}
+				}
+				MEMFS.expandFileStorage(node, position + length);
+				if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position);
+				else for (let i = 0; i < length; i++) node.contents[position + i] = buffer[offset + i];
+				node.usedBytes = Math.max(node.usedBytes, position + length);
+				return length;
+			},
+			llseek(stream, offset, whence) {
+				let position = offset;
+				if (whence === 1) position += stream.position;
+				else if (whence === 2) {
+					if (FS.isFile(stream.node.mode)) position += stream.node.usedBytes;
+				}
+				if (position < 0) throw new FS.ErrnoError(28);
+				return position;
+			},
+			mmap(stream, length, position, prot, flags) {
+				if (!FS.isFile(stream.node.mode)) throw new FS.ErrnoError(43);
+				let ptr;
+				let allocated;
+				let contents = stream.node.contents;
+				if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
+					allocated = false;
+					ptr = contents.byteOffset;
+				} else {
+					allocated = true;
+					ptr = mmapAlloc(length);
+					if (!ptr) throw new FS.ErrnoError(48);
+					if (contents) {
+						if (position > 0 || position + length < contents.length) if (contents.subarray) contents = contents.subarray(position, position + length);
+						else contents = Array.prototype.slice.call(contents, position, position + length);
+						HEAP8.set(contents, ptr >>> 0);
+					}
+				}
+				return {
+					ptr,
+					allocated
+				};
+			},
+			msync(stream, buffer, offset, length, mmapFlags) {
+				MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+				return 0;
+			}
+		}
+	};
+	const FS_modeStringToFlags = (str) => {
+		const flagModes = {
+			"r": 0,
+			"r+": 2,
+			"w": 577,
+			"w+": 578,
+			"a": 1089,
+			"a+": 1090
+		};
+		const flags = flagModes[str];
+		if (typeof flags == "undefined") throw new TypeError(`Unknown file open mode: ${str}`);
+		return flags;
+	};
+	const FS_getMode = (canRead, canWrite) => {
+		let mode = 0;
+		if (canRead) mode |= 365;
+		if (canWrite) mode |= 146;
+		return mode;
+	};
+	var IDBFS = {
+		dbs: {},
+		indexedDB: () => indexedDB,
+		DB_VERSION: 21,
+		DB_STORE_NAME: "FILE_DATA",
+		queuePersist: (mount) => {
+			function onPersistComplete() {
+				if (mount.idbPersistState === "again") startPersist();
+				else mount.idbPersistState = 0;
+			}
+			function startPersist() {
+				mount.idbPersistState = "idb";
+				IDBFS.syncfs(mount, false, onPersistComplete);
+			}
+			if (!mount.idbPersistState) mount.idbPersistState = setTimeout(startPersist, 0);
+			else if (mount.idbPersistState === "idb") mount.idbPersistState = "again";
+		},
+		mount: (mount) => {
+			const mnt = MEMFS.mount(mount);
+			if (mount?.opts?.autoPersist) {
+				mount.idbPersistState = 0;
+				const memfs_node_ops = mnt.node_ops;
+				mnt.node_ops = { ...mnt.node_ops };
+				mnt.node_ops.mknod = (parent, name, mode, dev) => {
+					const node = memfs_node_ops.mknod(parent, name, mode, dev);
+					node.node_ops = mnt.node_ops;
+					node.idbfs_mount = mnt.mount;
+					node.memfs_stream_ops = node.stream_ops;
+					node.stream_ops = { ...node.stream_ops };
+					node.stream_ops.write = (stream, buffer, offset, length, position, canOwn) => {
+						stream.node.isModified = true;
+						return node.memfs_stream_ops.write(stream, buffer, offset, length, position, canOwn);
+					};
+					node.stream_ops.close = (stream) => {
+						const n = stream.node;
+						if (n.isModified) {
+							IDBFS.queuePersist(n.idbfs_mount);
+							n.isModified = false;
+						}
+						if (n.memfs_stream_ops.close) return n.memfs_stream_ops.close(stream);
+					};
+					IDBFS.queuePersist(mnt.mount);
+					return node;
+				};
+				mnt.node_ops.rmdir = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rmdir(...args));
+				mnt.node_ops.symlink = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.symlink(...args));
+				mnt.node_ops.unlink = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.unlink(...args));
+				mnt.node_ops.rename = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rename(...args));
+			}
+			return mnt;
+		},
+		syncfs: (mount, populate, callback) => {
+			IDBFS.getLocalSet(mount, (err$1, local) => {
+				if (err$1) return callback(err$1);
+				IDBFS.getRemoteSet(mount, (err$2, remote) => {
+					if (err$2) return callback(err$2);
+					const src = populate ? remote : local;
+					const dst = populate ? local : remote;
+					IDBFS.reconcile(src, dst, callback);
+				});
+			});
+		},
+		quit: () => {
+			for (const value of Object.values(IDBFS.dbs)) value.close();
+			IDBFS.dbs = {};
+		},
+		getDB: (name, callback) => {
+			let db = IDBFS.dbs[name];
+			if (db) return callback(null, db);
+			let req;
+			try {
+				req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+			} catch (e) {
+				return callback(e);
+			}
+			if (!req) return callback("Unable to connect to IndexedDB");
+			req.onupgradeneeded = (e) => {
+				const db$1 = e.target.result;
+				const transaction = e.target.transaction;
+				let fileStore;
+				if (db$1.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+				else fileStore = db$1.createObjectStore(IDBFS.DB_STORE_NAME);
+				if (!fileStore.indexNames.contains("timestamp")) fileStore.createIndex("timestamp", "timestamp", { unique: false });
+			};
+			req.onsuccess = () => {
+				db = req.result;
+				IDBFS.dbs[name] = db;
+				callback(null, db);
+			};
+			req.onerror = (e) => {
+				callback(e.target.error);
+				e.preventDefault();
+			};
+		},
+		getLocalSet: (mount, callback) => {
+			const entries = {};
+			function isRealDir(p) {
+				return p !== "." && p !== "..";
+			}
+			function toAbsolute(root) {
+				return (p) => PATH.join2(root, p);
+			}
+			const check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+			while (check.length) {
+				const path = check.pop();
+				var stat;
+				try {
+					stat = FS.stat(path);
+				} catch (e) {
+					return callback(e);
+				}
+				if (FS.isDir(stat.mode)) check.push(...FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+				entries[path] = { timestamp: stat.mtime };
+			}
+			return callback(null, {
+				type: "local",
+				entries
+			});
+		},
+		getRemoteSet: (mount, callback) => {
+			const entries = {};
+			IDBFS.getDB(mount.mountpoint, (err$1, db) => {
+				if (err$1) return callback(err$1);
+				try {
+					const transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
+					transaction.onerror = (e) => {
+						callback(e.target.error);
+						e.preventDefault();
+					};
+					const store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+					const index = store.index("timestamp");
+					index.openKeyCursor().onsuccess = (event) => {
+						const cursor = event.target.result;
+						if (!cursor) return callback(null, {
+							type: "remote",
+							db,
+							entries
+						});
+						entries[cursor.primaryKey] = { timestamp: cursor.key };
+						cursor.continue();
+					};
+				} catch (e) {
+					return callback(e);
+				}
+			});
+		},
+		loadLocalEntry: (path, callback) => {
+			let stat, node;
+			try {
+				const lookup = FS.lookupPath(path);
+				node = lookup.node;
+				stat = FS.stat(path);
+			} catch (e) {
+				return callback(e);
+			}
+			if (FS.isDir(stat.mode)) return callback(null, {
+				timestamp: stat.mtime,
+				mode: stat.mode
+			});
+			else if (FS.isFile(stat.mode)) {
+				node.contents = MEMFS.getFileDataAsTypedArray(node);
+				return callback(null, {
+					timestamp: stat.mtime,
+					mode: stat.mode,
+					contents: node.contents
+				});
+			} else return callback(new Error("node type not supported"));
+		},
+		storeLocalEntry: (path, entry, callback) => {
+			try {
+				if (FS.isDir(entry.mode)) FS.mkdirTree(path, entry.mode);
+				else if (FS.isFile(entry.mode)) FS.writeFile(path, entry.contents, { canOwn: true });
+				else return callback(new Error("node type not supported"));
+				FS.chmod(path, entry.mode);
+				FS.utime(path, entry.timestamp, entry.timestamp);
+			} catch (e) {
+				return callback(e);
+			}
+			callback(null);
+		},
+		removeLocalEntry: (path, callback) => {
+			try {
+				const stat = FS.stat(path);
+				if (FS.isDir(stat.mode)) FS.rmdir(path);
+				else if (FS.isFile(stat.mode)) FS.unlink(path);
+			} catch (e) {
+				return callback(e);
+			}
+			callback(null);
+		},
+		loadRemoteEntry: (store, path, callback) => {
+			const req = store.get(path);
+			req.onsuccess = (event) => callback(null, event.target.result);
+			req.onerror = (e) => {
+				callback(e.target.error);
+				e.preventDefault();
+			};
+		},
+		storeRemoteEntry: (store, path, entry, callback) => {
+			try {
+				var req = store.put(entry, path);
+			} catch (e) {
+				callback(e);
+				return;
+			}
+			req.onsuccess = (event) => callback();
+			req.onerror = (e) => {
+				callback(e.target.error);
+				e.preventDefault();
+			};
+		},
+		removeRemoteEntry: (store, path, callback) => {
+			const req = store.delete(path);
+			req.onsuccess = (event) => callback();
+			req.onerror = (e) => {
+				callback(e.target.error);
+				e.preventDefault();
+			};
+		},
+		reconcile: (src, dst, callback) => {
+			let total = 0;
+			const create = [];
+			for (var [key, e] of Object.entries(src.entries)) {
+				const e2 = dst.entries[key];
+				if (!e2 || e.timestamp.getTime() != e2.timestamp.getTime()) {
+					create.push(key);
+					total++;
+				}
+			}
+			const remove = [];
+			for (var key of Object.keys(dst.entries)) if (!src.entries[key]) {
+				remove.push(key);
+				total++;
+			}
+			if (!total) return callback(null);
+			let errored = false;
+			const db = src.type === "remote" ? src.db : dst.db;
+			const transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite");
+			const store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+			function done(err$1) {
+				if (err$1 && !errored) {
+					errored = true;
+					return callback(err$1);
+				}
+			}
+			transaction.onerror = transaction.onabort = (e$1) => {
+				done(e$1.target.error);
+				e$1.preventDefault();
+			};
+			transaction.oncomplete = (e$1) => {
+				if (!errored) callback(null);
+			};
+			for (const path of create.sort()) if (dst.type === "local") IDBFS.loadRemoteEntry(store, path, (err$1, entry) => {
+				if (err$1) return done(err$1);
+				IDBFS.storeLocalEntry(path, entry, done);
+			});
+			else IDBFS.loadLocalEntry(path, (err$1, entry) => {
+				if (err$1) return done(err$1);
+				IDBFS.storeRemoteEntry(store, path, entry, done);
+			});
+			for (const path of remove.sort().reverse()) if (dst.type === "local") IDBFS.removeLocalEntry(path, done);
+			else IDBFS.removeRemoteEntry(store, path, done);
+		}
+	};
+	const asyncLoad = async (url) => {
+		const arrayBuffer = await readAsync(url);
+		return new Uint8Array(arrayBuffer);
+	};
+	const FS_createDataFile = (...args) => FS.createDataFile(...args);
+	const getUniqueRunDependency = (id) => id;
+	let runDependencies = 0;
+	let dependenciesFulfilled = null;
+	const removeRunDependency = (id) => {
+		runDependencies--;
+		Module.monitorRunDependencies?.(runDependencies);
+		if (runDependencies == 0) {
+			if (dependenciesFulfilled) {
+				const callback = dependenciesFulfilled;
+				dependenciesFulfilled = null;
+				callback();
+			}
+		}
+	};
+	const addRunDependency = (id) => {
+		runDependencies++;
+		Module.monitorRunDependencies?.(runDependencies);
+	};
+	let preloadPlugins = [];
+	const FS_handledByPreloadPlugin = async (byteArray, fullname) => {
+		if (typeof Browser != "undefined") Browser.init();
+		for (const plugin of preloadPlugins) if (plugin.canHandle(fullname)) return plugin.handle(byteArray, fullname);
+		return byteArray;
+	};
+	const FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
+		const fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+		const dep = getUniqueRunDependency(`cp ${fullname}`);
+		addRunDependency(dep);
+		try {
+			let byteArray = url;
+			if (typeof url == "string") byteArray = await asyncLoad(url);
+			byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
+			preFinish?.();
+			if (!dontCreateFile) FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+		} finally {
+			removeRunDependency(dep);
+		}
+	};
+	const FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+		FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror);
+	};
+	var FS = {
+		root: null,
+		mounts: [],
+		devices: {},
+		streams: [],
+		nextInode: 1,
+		nameTable: null,
+		currentPath: "/",
+		initialized: false,
+		ignorePermissions: true,
+		filesystems: null,
+		syncFSRequests: 0,
+		ErrnoError: class {
+			name = "ErrnoError";
+			constructor(errno) {
+				this.errno = errno;
+			}
+		},
+		FSStream: class {
+			shared = {};
+			get object() {
+				return this.node;
+			}
+			set object(val) {
+				this.node = val;
+			}
+			get isRead() {
+				return (this.flags & 2097155) !== 1;
+			}
+			get isWrite() {
+				return (this.flags & 2097155) !== 0;
+			}
+			get isAppend() {
+				return this.flags & 1024;
+			}
+			get flags() {
+				return this.shared.flags;
+			}
+			set flags(val) {
+				this.shared.flags = val;
+			}
+			get position() {
+				return this.shared.position;
+			}
+			set position(val) {
+				this.shared.position = val;
+			}
+		},
+		FSNode: class {
+			node_ops = {};
+			stream_ops = {};
+			readMode = 365;
+			writeMode = 146;
+			mounted = null;
+			constructor(parent, name, mode, rdev) {
+				if (!parent) parent = this;
+				this.parent = parent;
+				this.mount = parent.mount;
+				this.id = FS.nextInode++;
+				this.name = name;
+				this.mode = mode;
+				this.rdev = rdev;
+				this.atime = this.mtime = this.ctime = Date.now();
+			}
+			get read() {
+				return (this.mode & this.readMode) === this.readMode;
+			}
+			set read(val) {
+				val ? this.mode |= this.readMode : this.mode &= ~this.readMode;
+			}
+			get write() {
+				return (this.mode & this.writeMode) === this.writeMode;
+			}
+			set write(val) {
+				val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
+			}
+			get isFolder() {
+				return FS.isDir(this.mode);
+			}
+			get isDevice() {
+				return FS.isChrdev(this.mode);
+			}
+		},
+		lookupPath(path, opts = {}) {
+			if (!path) throw new FS.ErrnoError(44);
+			opts.follow_mount ??= true;
+			if (!PATH.isAbs(path)) path = `${FS.cwd()}/${path}`;
+			linkloop: for (let nlinks = 0; nlinks < 40; nlinks++) {
+				const parts = path.split("/").filter((p) => !!p);
+				let current = FS.root;
+				let current_path = "/";
+				for (let i = 0; i < parts.length; i++) {
+					const islast = i === parts.length - 1;
+					if (islast && opts.parent) break;
+					if (parts[i] === ".") continue;
+					if (parts[i] === "..") {
+						current_path = PATH.dirname(current_path);
+						if (FS.isRoot(current)) {
+							path = `${current_path}/${parts.slice(i + 1).join("/")}`;
+							nlinks--;
+							continue linkloop;
+						} else current = current.parent;
+						continue;
+					}
+					current_path = PATH.join2(current_path, parts[i]);
+					try {
+						current = FS.lookupNode(current, parts[i]);
+					} catch (e) {
+						if (e?.errno === 44 && islast && opts.noent_okay) return { path: current_path };
+						throw e;
+					}
+					if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) current = current.mounted.root;
+					if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+						if (!current.node_ops.readlink) throw new FS.ErrnoError(52);
+						let link = current.node_ops.readlink(current);
+						if (!PATH.isAbs(link)) link = `${PATH.dirname(current_path)}/${link}`;
+						path = `${link}/${parts.slice(i + 1).join("/")}`;
+						continue linkloop;
+					}
+				}
+				return {
+					path: current_path,
+					node: current
+				};
+			}
+			throw new FS.ErrnoError(32);
+		},
+		getPath(node) {
+			let path;
+			while (true) {
+				if (FS.isRoot(node)) {
+					const mount = node.mount.mountpoint;
+					if (!path) return mount;
+					return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+				}
+				path = path ? `${node.name}/${path}` : node.name;
+				node = node.parent;
+			}
+		},
+		hashName(parentid, name) {
+			let hash = 0;
+			for (let i = 0; i < name.length; i++) hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+			return (parentid + hash >>> 0) % FS.nameTable.length;
+		},
+		hashAddNode(node) {
+			const hash = FS.hashName(node.parent.id, node.name);
+			node.name_next = FS.nameTable[hash];
+			FS.nameTable[hash] = node;
+		},
+		hashRemoveNode(node) {
+			const hash = FS.hashName(node.parent.id, node.name);
+			if (FS.nameTable[hash] === node) FS.nameTable[hash] = node.name_next;
+			else {
+				let current = FS.nameTable[hash];
+				while (current) {
+					if (current.name_next === node) {
+						current.name_next = node.name_next;
+						break;
+					}
+					current = current.name_next;
+				}
+			}
+		},
+		lookupNode(parent, name) {
+			const errCode = FS.mayLookup(parent);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			const hash = FS.hashName(parent.id, name);
+			for (let node = FS.nameTable[hash]; node; node = node.name_next) {
+				const nodeName = node.name;
+				if (node.parent.id === parent.id && nodeName === name) return node;
+			}
+			return FS.lookup(parent, name);
+		},
+		createNode(parent, name, mode, rdev) {
+			const node = new FS.FSNode(parent, name, mode, rdev);
+			FS.hashAddNode(node);
+			return node;
+		},
+		destroyNode(node) {
+			FS.hashRemoveNode(node);
+		},
+		isRoot(node) {
+			return node === node.parent;
+		},
+		isMountpoint(node) {
+			return !!node.mounted;
+		},
+		isFile(mode) {
+			return (mode & 61440) === 32768;
+		},
+		isDir(mode) {
+			return (mode & 61440) === 16384;
+		},
+		isLink(mode) {
+			return (mode & 61440) === 40960;
+		},
+		isChrdev(mode) {
+			return (mode & 61440) === 8192;
+		},
+		isBlkdev(mode) {
+			return (mode & 61440) === 24576;
+		},
+		isFIFO(mode) {
+			return (mode & 61440) === 4096;
+		},
+		isSocket(mode) {
+			return (mode & 49152) === 49152;
+		},
+		flagsToPermissionString(flag) {
+			let perms = [
+				"r",
+				"w",
+				"rw"
+			][flag & 3];
+			if (flag & 512) perms += "w";
+			return perms;
+		},
+		nodePermissions(node, perms) {
+			if (FS.ignorePermissions) return 0;
+			if (perms.includes("r") && !(node.mode & 292)) return 2;
+			if (perms.includes("w") && !(node.mode & 146)) return 2;
+			if (perms.includes("x") && !(node.mode & 73)) return 2;
+			return 0;
+		},
+		mayLookup(dir) {
+			if (!FS.isDir(dir.mode)) return 54;
+			const errCode = FS.nodePermissions(dir, "x");
+			if (errCode) return errCode;
+			if (!dir.node_ops.lookup) return 2;
+			return 0;
+		},
+		mayCreate(dir, name) {
+			if (!FS.isDir(dir.mode)) return 54;
+			try {
+				const node = FS.lookupNode(dir, name);
+				return 20;
+			} catch (e) {}
+			return FS.nodePermissions(dir, "wx");
+		},
+		mayDelete(dir, name, isdir) {
+			let node;
+			try {
+				node = FS.lookupNode(dir, name);
+			} catch (e) {
+				return e.errno;
+			}
+			const errCode = FS.nodePermissions(dir, "wx");
+			if (errCode) return errCode;
+			if (isdir) {
+				if (!FS.isDir(node.mode)) return 54;
+				if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) return 10;
+			} else if (FS.isDir(node.mode)) return 31;
+			return 0;
+		},
+		mayOpen(node, flags) {
+			if (!node) return 44;
+			if (FS.isLink(node.mode)) return 32;
+			const mode = FS.flagsToPermissionString(flags);
+			if (FS.isDir(node.mode)) {
+				if (mode !== "r" || flags & 576) return 31;
+			}
+			return FS.nodePermissions(node, mode);
+		},
+		checkOpExists(op, err$1) {
+			if (!op) throw new FS.ErrnoError(err$1);
+			return op;
+		},
+		MAX_OPEN_FDS: 4096,
+		nextfd() {
+			for (let fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) if (!FS.streams[fd]) return fd;
+			throw new FS.ErrnoError(33);
+		},
+		getStreamChecked(fd) {
+			const stream = FS.getStream(fd);
+			if (!stream) throw new FS.ErrnoError(8);
+			return stream;
+		},
+		getStream: (fd) => FS.streams[fd],
+		createStream(stream, fd = -1) {
+			stream = Object.assign(new FS.FSStream(), stream);
+			if (fd == -1) fd = FS.nextfd();
+			stream.fd = fd;
+			FS.streams[fd] = stream;
+			return stream;
+		},
+		closeStream(fd) {
+			FS.streams[fd] = null;
+		},
+		dupStream(origStream, fd = -1) {
+			const stream = FS.createStream(origStream, fd);
+			stream.stream_ops?.dup?.(stream);
+			return stream;
+		},
+		doSetAttr(stream, node, attr) {
+			let setattr = stream?.stream_ops.setattr;
+			const arg = setattr ? stream : node;
+			setattr ??= node.node_ops.setattr;
+			FS.checkOpExists(setattr, 63);
+			setattr(arg, attr);
+		},
+		chrdev_stream_ops: {
+			open(stream) {
+				const device = FS.getDevice(stream.node.rdev);
+				stream.stream_ops = device.stream_ops;
+				stream.stream_ops.open?.(stream);
+			},
+			llseek() {
+				throw new FS.ErrnoError(70);
+			}
+		},
+		major: (dev) => dev >> 8,
+		minor: (dev) => dev & 255,
+		makedev: (ma, mi) => ma << 8 | mi,
+		registerDevice(dev, ops) {
+			FS.devices[dev] = { stream_ops: ops };
+		},
+		getDevice: (dev) => FS.devices[dev],
+		getMounts(mount) {
+			const mounts = [];
+			const check = [mount];
+			while (check.length) {
+				const m = check.pop();
+				mounts.push(m);
+				check.push(...m.mounts);
+			}
+			return mounts;
+		},
+		syncfs(populate, callback) {
+			if (typeof populate == "function") {
+				callback = populate;
+				populate = false;
+			}
+			FS.syncFSRequests++;
+			if (FS.syncFSRequests > 1) err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+			const mounts = FS.getMounts(FS.root.mount);
+			let completed = 0;
+			function doCallback(errCode) {
+				FS.syncFSRequests--;
+				return callback(errCode);
+			}
+			function done(errCode) {
+				if (errCode) {
+					if (!done.errored) {
+						done.errored = true;
+						return doCallback(errCode);
+					}
+					return;
+				}
+				if (++completed >= mounts.length) doCallback(null);
+			}
+			for (const mount of mounts) if (mount.type.syncfs) mount.type.syncfs(mount, populate, done);
+			else done(null);
+		},
+		mount(type, opts, mountpoint) {
+			const root = mountpoint === "/";
+			const pseudo = !mountpoint;
+			let node;
+			if (root && FS.root) throw new FS.ErrnoError(10);
+			else if (!root && !pseudo) {
+				const lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+				mountpoint = lookup.path;
+				node = lookup.node;
+				if (FS.isMountpoint(node)) throw new FS.ErrnoError(10);
+				if (!FS.isDir(node.mode)) throw new FS.ErrnoError(54);
+			}
+			const mount = {
+				type,
+				opts,
+				mountpoint,
+				mounts: []
+			};
+			const mountRoot = type.mount(mount);
+			mountRoot.mount = mount;
+			mount.root = mountRoot;
+			if (root) FS.root = mountRoot;
+			else if (node) {
+				node.mounted = mount;
+				if (node.mount) node.mount.mounts.push(mount);
+			}
+			return mountRoot;
+		},
+		unmount(mountpoint) {
+			const lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+			if (!FS.isMountpoint(lookup.node)) throw new FS.ErrnoError(28);
+			const node = lookup.node;
+			const mount = node.mounted;
+			const mounts = FS.getMounts(mount);
+			for (let [hash, current] of Object.entries(FS.nameTable)) while (current) {
+				const next = current.name_next;
+				if (mounts.includes(current.mount)) FS.destroyNode(current);
+				current = next;
+			}
+			node.mounted = null;
+			const idx = node.mount.mounts.indexOf(mount);
+			node.mount.mounts.splice(idx, 1);
+		},
+		lookup(parent, name) {
+			return parent.node_ops.lookup(parent, name);
+		},
+		mknod(path, mode, dev) {
+			const lookup = FS.lookupPath(path, { parent: true });
+			const parent = lookup.node;
+			const name = PATH.basename(path);
+			if (!name) throw new FS.ErrnoError(28);
+			if (name === "." || name === "..") throw new FS.ErrnoError(20);
+			const errCode = FS.mayCreate(parent, name);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			if (!parent.node_ops.mknod) throw new FS.ErrnoError(63);
+			return parent.node_ops.mknod(parent, name, mode, dev);
+		},
+		statfs(path) {
+			return FS.statfsNode(FS.lookupPath(path, { follow: true }).node);
+		},
+		statfsStream(stream) {
+			return FS.statfsNode(stream.node);
+		},
+		statfsNode(node) {
+			const rtn = {
+				bsize: 4096,
+				frsize: 4096,
+				blocks: 1e6,
+				bfree: 5e5,
+				bavail: 5e5,
+				files: FS.nextInode,
+				ffree: FS.nextInode - 1,
+				fsid: 42,
+				flags: 2,
+				namelen: 255
+			};
+			if (node.node_ops.statfs) Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
+			return rtn;
+		},
+		create(path, mode = 438) {
+			mode &= 4095;
+			mode |= 32768;
+			return FS.mknod(path, mode, 0);
+		},
+		mkdir(path, mode = 511) {
+			mode &= 1023;
+			mode |= 16384;
+			return FS.mknod(path, mode, 0);
+		},
+		mkdirTree(path, mode) {
+			const dirs = path.split("/");
+			let d = "";
+			for (const dir of dirs) {
+				if (!dir) continue;
+				if (d || PATH.isAbs(path)) d += "/";
+				d += dir;
+				try {
+					FS.mkdir(d, mode);
+				} catch (e) {
+					if (e.errno != 20) throw e;
+				}
+			}
+		},
+		mkdev(path, mode, dev) {
+			if (typeof dev == "undefined") {
+				dev = mode;
+				mode = 438;
+			}
+			mode |= 8192;
+			return FS.mknod(path, mode, dev);
+		},
+		symlink(oldpath, newpath) {
+			if (!PATH_FS.resolve(oldpath)) throw new FS.ErrnoError(44);
+			const lookup = FS.lookupPath(newpath, { parent: true });
+			const parent = lookup.node;
+			if (!parent) throw new FS.ErrnoError(44);
+			const newname = PATH.basename(newpath);
+			const errCode = FS.mayCreate(parent, newname);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			if (!parent.node_ops.symlink) throw new FS.ErrnoError(63);
+			return parent.node_ops.symlink(parent, newname, oldpath);
+		},
+		rename(old_path, new_path) {
+			const old_dirname = PATH.dirname(old_path);
+			const new_dirname = PATH.dirname(new_path);
+			const old_name = PATH.basename(old_path);
+			const new_name = PATH.basename(new_path);
+			let lookup, old_dir, new_dir;
+			lookup = FS.lookupPath(old_path, { parent: true });
+			old_dir = lookup.node;
+			lookup = FS.lookupPath(new_path, { parent: true });
+			new_dir = lookup.node;
+			if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
+			if (old_dir.mount !== new_dir.mount) throw new FS.ErrnoError(75);
+			const old_node = FS.lookupNode(old_dir, old_name);
+			let relative = PATH_FS.relative(old_path, new_dirname);
+			if (relative.charAt(0) !== ".") throw new FS.ErrnoError(28);
+			relative = PATH_FS.relative(new_path, old_dirname);
+			if (relative.charAt(0) !== ".") throw new FS.ErrnoError(55);
+			let new_node;
+			try {
+				new_node = FS.lookupNode(new_dir, new_name);
+			} catch (e) {}
+			if (old_node === new_node) return;
+			const isdir = FS.isDir(old_node.mode);
+			let errCode = FS.mayDelete(old_dir, old_name, isdir);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			if (!old_dir.node_ops.rename) throw new FS.ErrnoError(63);
+			if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) throw new FS.ErrnoError(10);
+			if (new_dir !== old_dir) {
+				errCode = FS.nodePermissions(old_dir, "w");
+				if (errCode) throw new FS.ErrnoError(errCode);
+			}
+			FS.hashRemoveNode(old_node);
+			try {
+				old_dir.node_ops.rename(old_node, new_dir, new_name);
+				old_node.parent = new_dir;
+			} catch (e) {
+				throw e;
+			} finally {
+				FS.hashAddNode(old_node);
+			}
+		},
+		rmdir(path) {
+			const lookup = FS.lookupPath(path, { parent: true });
+			const parent = lookup.node;
+			const name = PATH.basename(path);
+			const node = FS.lookupNode(parent, name);
+			const errCode = FS.mayDelete(parent, name, true);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			if (!parent.node_ops.rmdir) throw new FS.ErrnoError(63);
+			if (FS.isMountpoint(node)) throw new FS.ErrnoError(10);
+			parent.node_ops.rmdir(parent, name);
+			FS.destroyNode(node);
+		},
+		readdir(path) {
+			const lookup = FS.lookupPath(path, { follow: true });
+			const node = lookup.node;
+			const readdir = FS.checkOpExists(node.node_ops.readdir, 54);
+			return readdir(node);
+		},
+		unlink(path) {
+			const lookup = FS.lookupPath(path, { parent: true });
+			const parent = lookup.node;
+			if (!parent) throw new FS.ErrnoError(44);
+			const name = PATH.basename(path);
+			const node = FS.lookupNode(parent, name);
+			const errCode = FS.mayDelete(parent, name, false);
+			if (errCode) throw new FS.ErrnoError(errCode);
+			if (!parent.node_ops.unlink) throw new FS.ErrnoError(63);
+			if (FS.isMountpoint(node)) throw new FS.ErrnoError(10);
+			parent.node_ops.unlink(parent, name);
+			FS.destroyNode(node);
+		},
+		readlink(path) {
+			const lookup = FS.lookupPath(path);
+			const link = lookup.node;
+			if (!link) throw new FS.ErrnoError(44);
+			if (!link.node_ops.readlink) throw new FS.ErrnoError(28);
+			return link.node_ops.readlink(link);
+		},
+		stat(path, dontFollow) {
+			const lookup = FS.lookupPath(path, { follow: !dontFollow });
+			const node = lookup.node;
+			const getattr = FS.checkOpExists(node.node_ops.getattr, 63);
+			return getattr(node);
+		},
+		fstat(fd) {
+			const stream = FS.getStreamChecked(fd);
+			const node = stream.node;
+			let getattr = stream.stream_ops.getattr;
+			const arg = getattr ? stream : node;
+			getattr ??= node.node_ops.getattr;
+			FS.checkOpExists(getattr, 63);
+			return getattr(arg);
+		},
+		lstat(path) {
+			return FS.stat(path, true);
+		},
+		doChmod(stream, node, mode, dontFollow) {
+			FS.doSetAttr(stream, node, {
+				mode: mode & 4095 | node.mode & -4096,
+				ctime: Date.now(),
+				dontFollow
+			});
+		},
+		chmod(path, mode, dontFollow) {
+			let node;
+			if (typeof path == "string") {
+				const lookup = FS.lookupPath(path, { follow: !dontFollow });
+				node = lookup.node;
+			} else node = path;
+			FS.doChmod(null, node, mode, dontFollow);
+		},
+		lchmod(path, mode) {
+			FS.chmod(path, mode, true);
+		},
+		fchmod(fd, mode) {
+			const stream = FS.getStreamChecked(fd);
+			FS.doChmod(stream, stream.node, mode, false);
+		},
+		doChown(stream, node, dontFollow) {
+			FS.doSetAttr(stream, node, {
+				timestamp: Date.now(),
+				dontFollow
+			});
+		},
+		chown(path, uid, gid, dontFollow) {
+			let node;
+			if (typeof path == "string") {
+				const lookup = FS.lookupPath(path, { follow: !dontFollow });
+				node = lookup.node;
+			} else node = path;
+			FS.doChown(null, node, dontFollow);
+		},
+		lchown(path, uid, gid) {
+			FS.chown(path, uid, gid, true);
+		},
+		fchown(fd, uid, gid) {
+			const stream = FS.getStreamChecked(fd);
+			FS.doChown(stream, stream.node, false);
+		},
+		doTruncate(stream, node, len) {
+			if (FS.isDir(node.mode)) throw new FS.ErrnoError(31);
+			if (!FS.isFile(node.mode)) throw new FS.ErrnoError(28);
+			const errCode = FS.nodePermissions(node, "w");
+			if (errCode) throw new FS.ErrnoError(errCode);
+			FS.doSetAttr(stream, node, {
+				size: len,
+				timestamp: Date.now()
+			});
+		},
+		truncate(path, len) {
+			if (len < 0) throw new FS.ErrnoError(28);
+			let node;
+			if (typeof path == "string") {
+				const lookup = FS.lookupPath(path, { follow: true });
+				node = lookup.node;
+			} else node = path;
+			FS.doTruncate(null, node, len);
+		},
+		ftruncate(fd, len) {
+			const stream = FS.getStreamChecked(fd);
+			if (len < 0 || (stream.flags & 2097155) === 0) throw new FS.ErrnoError(28);
+			FS.doTruncate(stream, stream.node, len);
+		},
+		utime(path, atime, mtime) {
+			const lookup = FS.lookupPath(path, { follow: true });
+			const node = lookup.node;
+			const setattr = FS.checkOpExists(node.node_ops.setattr, 63);
+			setattr(node, {
+				atime,
+				mtime
+			});
+		},
+		open(path, flags, mode = 438) {
+			if (path === "") throw new FS.ErrnoError(44);
+			flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+			if (flags & 64) mode = mode & 4095 | 32768;
+			else mode = 0;
+			let node;
+			let isDirPath;
+			if (typeof path == "object") node = path;
+			else {
+				isDirPath = path.endsWith("/");
+				const lookup = FS.lookupPath(path, {
+					follow: !(flags & 131072),
+					noent_okay: true
+				});
+				node = lookup.node;
+				path = lookup.path;
+			}
+			let created = false;
+			if (flags & 64) if (node) {
+				if (flags & 128) throw new FS.ErrnoError(20);
+			} else if (isDirPath) throw new FS.ErrnoError(31);
+			else {
+				node = FS.mknod(path, mode | 511, 0);
+				created = true;
+			}
+			if (!node) throw new FS.ErrnoError(44);
+			if (FS.isChrdev(node.mode)) flags &= -513;
+			if (flags & 65536 && !FS.isDir(node.mode)) throw new FS.ErrnoError(54);
+			if (!created) {
+				const errCode = FS.mayOpen(node, flags);
+				if (errCode) throw new FS.ErrnoError(errCode);
+			}
+			if (flags & 512 && !created) FS.truncate(node, 0);
+			flags &= -131713;
+			const stream = FS.createStream({
+				node,
+				path: FS.getPath(node),
+				flags,
+				seekable: true,
+				position: 0,
+				stream_ops: node.stream_ops,
+				ungotten: [],
+				error: false
+			});
+			if (stream.stream_ops.open) stream.stream_ops.open(stream);
+			if (created) FS.chmod(node, mode & 511);
+			return stream;
+		},
+		close(stream) {
+			if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+			if (stream.getdents) stream.getdents = null;
+			try {
+				if (stream.stream_ops.close) stream.stream_ops.close(stream);
+			} catch (e) {
+				throw e;
+			} finally {
+				FS.closeStream(stream.fd);
+			}
+			stream.fd = null;
+		},
+		isClosed(stream) {
+			return stream.fd === null;
+		},
+		llseek(stream, offset, whence) {
+			if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+			if (!stream.seekable || !stream.stream_ops.llseek) throw new FS.ErrnoError(70);
+			if (whence != 0 && whence != 1 && whence != 2) throw new FS.ErrnoError(28);
+			stream.position = stream.stream_ops.llseek(stream, offset, whence);
+			stream.ungotten = [];
+			return stream.position;
+		},
+		read(stream, buffer, offset, length, position) {
+			if (length < 0 || position < 0) throw new FS.ErrnoError(28);
+			if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+			if ((stream.flags & 2097155) === 1) throw new FS.ErrnoError(8);
+			if (FS.isDir(stream.node.mode)) throw new FS.ErrnoError(31);
+			if (!stream.stream_ops.read) throw new FS.ErrnoError(28);
+			const seeking = typeof position != "undefined";
+			if (!seeking) position = stream.position;
+			else if (!stream.seekable) throw new FS.ErrnoError(70);
+			const bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+			if (!seeking) stream.position += bytesRead;
+			return bytesRead;
+		},
+		write(stream, buffer, offset, length, position, canOwn) {
+			if (length < 0 || position < 0) throw new FS.ErrnoError(28);
+			if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+			if ((stream.flags & 2097155) === 0) throw new FS.ErrnoError(8);
+			if (FS.isDir(stream.node.mode)) throw new FS.ErrnoError(31);
+			if (!stream.stream_ops.write) throw new FS.ErrnoError(28);
+			if (stream.seekable && stream.flags & 1024) FS.llseek(stream, 0, 2);
+			const seeking = typeof position != "undefined";
+			if (!seeking) position = stream.position;
+			else if (!stream.seekable) throw new FS.ErrnoError(70);
+			const bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+			if (!seeking) stream.position += bytesWritten;
+			return bytesWritten;
+		},
+		mmap(stream, length, position, prot, flags) {
+			if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) throw new FS.ErrnoError(2);
+			if ((stream.flags & 2097155) === 1) throw new FS.ErrnoError(2);
+			if (!stream.stream_ops.mmap) throw new FS.ErrnoError(43);
+			if (!length) throw new FS.ErrnoError(28);
+			return stream.stream_ops.mmap(stream, length, position, prot, flags);
+		},
+		msync(stream, buffer, offset, length, mmapFlags) {
+			if (!stream.stream_ops.msync) return 0;
+			return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
+		},
+		ioctl(stream, cmd, arg) {
+			if (!stream.stream_ops.ioctl) throw new FS.ErrnoError(59);
+			return stream.stream_ops.ioctl(stream, cmd, arg);
+		},
+		readFile(path, opts = {}) {
+			opts.flags = opts.flags || 0;
+			opts.encoding = opts.encoding || "binary";
+			if (opts.encoding !== "utf8" && opts.encoding !== "binary") abort(`Invalid encoding type "${opts.encoding}"`);
+			const stream = FS.open(path, opts.flags);
+			const stat = FS.stat(path);
+			const length = stat.size;
+			let buf = new Uint8Array(length);
+			FS.read(stream, buf, 0, length, 0);
+			if (opts.encoding === "utf8") buf = UTF8ArrayToString(buf);
+			FS.close(stream);
+			return buf;
+		},
+		writeFile(path, data, opts = {}) {
+			opts.flags = opts.flags || 577;
+			const stream = FS.open(path, opts.flags, opts.mode);
+			if (typeof data == "string") data = new Uint8Array(intArrayFromString(data, true));
+			if (ArrayBuffer.isView(data)) FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
+			else abort("Unsupported data type");
+			FS.close(stream);
+		},
+		cwd: () => FS.currentPath,
+		chdir(path) {
+			const lookup = FS.lookupPath(path, { follow: true });
+			if (lookup.node === null) throw new FS.ErrnoError(44);
+			if (!FS.isDir(lookup.node.mode)) throw new FS.ErrnoError(54);
+			const errCode = FS.nodePermissions(lookup.node, "x");
+			if (errCode) throw new FS.ErrnoError(errCode);
+			FS.currentPath = lookup.path;
+		},
+		createDefaultDirectories() {
+			FS.mkdir("/tmp");
+			FS.mkdir("/home");
+			FS.mkdir("/home/web_user");
+		},
+		createDefaultDevices() {
+			FS.mkdir("/dev");
+			FS.registerDevice(FS.makedev(1, 3), {
+				read: () => 0,
+				write: (stream, buffer, offset, length, pos) => length,
+				llseek: () => 0
+			});
+			FS.mkdev("/dev/null", FS.makedev(1, 3));
+			TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+			TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+			FS.mkdev("/dev/tty", FS.makedev(5, 0));
+			FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+			const randomBuffer = new Uint8Array(1024);
+			let randomLeft = 0;
+			const randomByte = () => {
+				if (randomLeft === 0) {
+					randomFill(randomBuffer);
+					randomLeft = randomBuffer.byteLength;
+				}
+				return randomBuffer[--randomLeft];
+			};
+			FS.createDevice("/dev", "random", randomByte);
+			FS.createDevice("/dev", "urandom", randomByte);
+			FS.mkdir("/dev/shm");
+			FS.mkdir("/dev/shm/tmp");
+		},
+		createSpecialDirectories() {
+			FS.mkdir("/proc");
+			const proc_self = FS.mkdir("/proc/self");
+			FS.mkdir("/proc/self/fd");
+			FS.mount({ mount() {
+				const node = FS.createNode(proc_self, "fd", 16895, 73);
+				node.stream_ops = { llseek: MEMFS.stream_ops.llseek };
+				node.node_ops = {
+					lookup(parent, name) {
+						const fd = +name;
+						const stream = FS.getStreamChecked(fd);
+						const ret = {
+							parent: null,
+							mount: { mountpoint: "fake" },
+							node_ops: { readlink: () => stream.path },
+							id: fd + 1
+						};
+						ret.parent = ret;
+						return ret;
+					},
+					readdir() {
+						return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString());
+					}
+				};
+				return node;
+			} }, {}, "/proc/self/fd");
+		},
+		createStandardStreams(input, output, error) {
+			if (input) FS.createDevice("/dev", "stdin", input);
+			else FS.symlink("/dev/tty", "/dev/stdin");
+			if (output) FS.createDevice("/dev", "stdout", null, output);
+			else FS.symlink("/dev/tty", "/dev/stdout");
+			if (error) FS.createDevice("/dev", "stderr", null, error);
+			else FS.symlink("/dev/tty1", "/dev/stderr");
+			const stdin = FS.open("/dev/stdin", 0);
+			const stdout = FS.open("/dev/stdout", 1);
+			const stderr = FS.open("/dev/stderr", 1);
+		},
+		staticInit() {
+			FS.nameTable = Array.from({ length: 4096 });
+			FS.mount(MEMFS, {}, "/");
+			FS.createDefaultDirectories();
+			FS.createDefaultDevices();
+			FS.createSpecialDirectories();
+			FS.filesystems = {
+				MEMFS,
+				IDBFS
+			};
+		},
+		init(input, output, error) {
+			FS.initialized = true;
+			input ??= Module.stdin;
+			output ??= Module.stdout;
+			error ??= Module.stderr;
+			FS.createStandardStreams(input, output, error);
+		},
+		quit() {
+			FS.initialized = false;
+			for (const stream of FS.streams) if (stream) FS.close(stream);
+		},
+		findObject(path, dontResolveLastLink) {
+			const ret = FS.analyzePath(path, dontResolveLastLink);
+			if (!ret.exists) return null;
+			return ret.object;
+		},
+		analyzePath(path, dontResolveLastLink) {
+			try {
+				var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+				path = lookup.path;
+			} catch (e) {}
+			const ret = {
+				isRoot: false,
+				exists: false,
+				error: 0,
+				name: null,
+				path: null,
+				object: null,
+				parentExists: false,
+				parentPath: null,
+				parentObject: null
+			};
+			try {
+				var lookup = FS.lookupPath(path, { parent: true });
+				ret.parentExists = true;
+				ret.parentPath = lookup.path;
+				ret.parentObject = lookup.node;
+				ret.name = PATH.basename(path);
+				lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+				ret.exists = true;
+				ret.path = lookup.path;
+				ret.object = lookup.node;
+				ret.name = lookup.node.name;
+				ret.isRoot = lookup.path === "/";
+			} catch (e) {
+				ret.error = e.errno;
+			}
+			return ret;
+		},
+		createPath(parent, path, canRead, canWrite) {
+			parent = typeof parent == "string" ? parent : FS.getPath(parent);
+			const parts = path.split("/").reverse();
+			while (parts.length) {
+				const part = parts.pop();
+				if (!part) continue;
+				var current = PATH.join2(parent, part);
+				try {
+					FS.mkdir(current);
+				} catch (e) {
+					if (e.errno != 20) throw e;
+				}
+				parent = current;
+			}
+			return current;
+		},
+		createFile(parent, name, properties, canRead, canWrite) {
+			const path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+			const mode = FS_getMode(canRead, canWrite);
+			return FS.create(path, mode);
+		},
+		createDataFile(parent, name, data, canRead, canWrite, canOwn) {
+			let path = name;
+			if (parent) {
+				parent = typeof parent == "string" ? parent : FS.getPath(parent);
+				path = name ? PATH.join2(parent, name) : parent;
+			}
+			const mode = FS_getMode(canRead, canWrite);
+			const node = FS.create(path, mode);
+			if (data) {
+				if (typeof data == "string") {
+					const arr = Array.from({ length: data.length });
+					for (let i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+					data = arr;
+				}
+				FS.chmod(node, mode | 146);
+				const stream = FS.open(node, 577);
+				FS.write(stream, data, 0, data.length, 0, canOwn);
+				FS.close(stream);
+				FS.chmod(node, mode);
+			}
+		},
+		createDevice(parent, name, input, output) {
+			const path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+			const mode = FS_getMode(!!input, !!output);
+			FS.createDevice.major ??= 64;
+			const dev = FS.makedev(FS.createDevice.major++, 0);
+			FS.registerDevice(dev, {
+				open(stream) {
+					stream.seekable = false;
+				},
+				close(stream) {
+					if (output?.buffer?.length) output(10);
+				},
+				read(stream, buffer, offset, length, pos) {
+					let bytesRead = 0;
+					for (let i = 0; i < length; i++) {
+						var result;
+						try {
+							result = input();
+						} catch (e) {
+							throw new FS.ErrnoError(29);
+						}
+						if (result === void 0 && bytesRead === 0) throw new FS.ErrnoError(6);
+						if (result === null || result === void 0) break;
+						bytesRead++;
+						buffer[offset + i] = result;
+					}
+					if (bytesRead) stream.node.atime = Date.now();
+					return bytesRead;
+				},
+				write(stream, buffer, offset, length, pos) {
+					for (var i = 0; i < length; i++) try {
+						output(buffer[offset + i]);
+					} catch (e) {
+						throw new FS.ErrnoError(29);
+					}
+					if (length) stream.node.mtime = stream.node.ctime = Date.now();
+					return i;
+				}
+			});
+			return FS.mkdev(path, mode, dev);
+		},
+		forceLoadFile(obj) {
+			if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+			if (globalThis.XMLHttpRequest) abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+			else try {
+				obj.contents = readBinary(obj.url);
+			} catch (e) {
+				throw new FS.ErrnoError(29);
+			}
+		},
+		createLazyFile(parent, name, url, canRead, canWrite) {
+			class LazyUint8Array {
+				lengthKnown = false;
+				chunks = [];
+				get(idx) {
+					if (idx > this.length - 1 || idx < 0) return void 0;
+					const chunkOffset = idx % this.chunkSize;
+					const chunkNum = idx / this.chunkSize | 0;
+					return this.getter(chunkNum)[chunkOffset];
+				}
+				setDataGetter(getter) {
+					this.getter = getter;
+				}
+				cacheLength() {
+					const xhr = new XMLHttpRequest();
+					xhr.open("HEAD", url, false);
+					xhr.send(null);
+					if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort(`Couldn't load ${url}. Status: ${xhr.status}`);
+					let datalength = Number(xhr.getResponseHeader("Content-length"));
+					let header;
+					const hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+					const usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
+					let chunkSize = 1024 * 1024;
+					if (!hasByteServing) chunkSize = datalength;
+					const doXHR = (from, to) => {
+						if (from > to) abort(`invalid range (${from}, ${to}) or no bytes requested!`);
+						if (to > datalength - 1) abort(`only ${datalength} bytes available! programmer error!`);
+						const xhr$1 = new XMLHttpRequest();
+						xhr$1.open("GET", url, false);
+						if (datalength !== chunkSize) xhr$1.setRequestHeader("Range", `bytes=${from}-${to}`);
+						xhr$1.responseType = "arraybuffer";
+						if (xhr$1.overrideMimeType) xhr$1.overrideMimeType("text/plain; charset=x-user-defined");
+						xhr$1.send(null);
+						if (!(xhr$1.status >= 200 && xhr$1.status < 300 || xhr$1.status === 304)) abort(`Couldn't load ${url}. Status: ${xhr$1.status}`);
+						if (xhr$1.response !== void 0) return new Uint8Array(xhr$1.response || []);
+						return intArrayFromString(xhr$1.responseText || "", true);
+					};
+					const lazyArray = this;
+					lazyArray.setDataGetter((chunkNum) => {
+						const start = chunkNum * chunkSize;
+						let end = (chunkNum + 1) * chunkSize - 1;
+						end = Math.min(end, datalength - 1);
+						if (typeof lazyArray.chunks[chunkNum] == "undefined") lazyArray.chunks[chunkNum] = doXHR(start, end);
+						if (typeof lazyArray.chunks[chunkNum] == "undefined") abort("doXHR failed!");
+						return lazyArray.chunks[chunkNum];
+					});
+					if (usesGzip || !datalength) {
+						chunkSize = datalength = 1;
+						datalength = this.getter(0).length;
+						chunkSize = datalength;
+						out("LazyFiles on gzip forces download of the whole file when length is accessed");
+					}
+					this._length = datalength;
+					this._chunkSize = chunkSize;
+					this.lengthKnown = true;
+				}
+				get length() {
+					if (!this.lengthKnown) this.cacheLength();
+					return this._length;
+				}
+				get chunkSize() {
+					if (!this.lengthKnown) this.cacheLength();
+					return this._chunkSize;
+				}
+			}
+			if (globalThis.XMLHttpRequest) {
+				if (!ENVIRONMENT_IS_WORKER) abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
+				const lazyArray = new LazyUint8Array();
+				var properties = {
+					isDevice: false,
+					contents: lazyArray
+				};
+			} else var properties = {
+				isDevice: false,
+				url
+			};
+			const node = FS.createFile(parent, name, properties, canRead, canWrite);
+			if (properties.contents) node.contents = properties.contents;
+			else if (properties.url) {
+				node.contents = null;
+				node.url = properties.url;
+			}
+			Object.defineProperties(node, { usedBytes: { get() {
+				return this.contents.length;
+			} } });
+			const stream_ops = {};
+			for (const [key, fn] of Object.entries(node.stream_ops)) stream_ops[key] = (...args) => {
+				FS.forceLoadFile(node);
+				return fn(...args);
+			};
+			function writeChunks(stream, buffer, offset, length, position) {
+				const contents = stream.node.contents;
+				if (position >= contents.length) return 0;
+				const size = Math.min(contents.length - position, length);
+				if (contents.slice) for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
+				else for (var i = 0; i < size; i++) buffer[offset + i] = contents.get(position + i);
+				return size;
+			}
+			stream_ops.read = (stream, buffer, offset, length, position) => {
+				FS.forceLoadFile(node);
+				return writeChunks(stream, buffer, offset, length, position);
+			};
+			stream_ops.mmap = (stream, length, position, prot, flags) => {
+				FS.forceLoadFile(node);
+				const ptr = mmapAlloc(length);
+				if (!ptr) throw new FS.ErrnoError(48);
+				writeChunks(stream, HEAP8, ptr, length, position);
+				return {
+					ptr,
+					allocated: true
+				};
+			};
+			node.stream_ops = stream_ops;
+			return node;
+		}
+	};
+	const UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+		ptr >>>= 0;
+		if (!ptr) return "";
+		const end = findStringEnd(HEAPU8, ptr, maxBytesToRead, ignoreNul);
+		return UTF8Decoder.decode(HEAPU8.subarray(ptr >>> 0, end >>> 0));
+	};
+	var SYSCALLS = {
+		calculateAt(dirfd, path, allowEmpty) {
+			if (PATH.isAbs(path)) return path;
+			let dir;
+			if (dirfd === -100) dir = FS.cwd();
+			else {
+				const dirstream = SYSCALLS.getStreamFromFD(dirfd);
+				dir = dirstream.path;
+			}
+			if (path.length == 0) {
+				if (!allowEmpty) throw new FS.ErrnoError(44);
+				return dir;
+			}
+			return `${dir}/${path}`;
+		},
+		writeStat(buf, stat) {
+			HEAPU32[buf >>> 2 >>> 0] = stat.dev;
+			HEAPU32[buf + 4 >>> 2 >>> 0] = stat.mode;
+			HEAPU32[buf + 8 >>> 2 >>> 0] = stat.nlink;
+			HEAPU32[buf + 12 >>> 2 >>> 0] = stat.uid;
+			HEAPU32[buf + 16 >>> 2 >>> 0] = stat.gid;
+			HEAPU32[buf + 20 >>> 2 >>> 0] = stat.rdev;
+			HEAP64[buf + 24 >>> 3 >>> 0] = BigInt(stat.size);
+			HEAP32[buf + 32 >>> 2 >>> 0] = 4096;
+			HEAP32[buf + 36 >>> 2 >>> 0] = stat.blocks;
+			const atime = stat.atime.getTime();
+			const mtime = stat.mtime.getTime();
+			const ctime = stat.ctime.getTime();
+			HEAP64[buf + 40 >>> 3 >>> 0] = BigInt(Math.floor(atime / 1e3));
+			HEAPU32[buf + 48 >>> 2 >>> 0] = atime % 1e3 * 1e3 * 1e3;
+			HEAP64[buf + 56 >>> 3 >>> 0] = BigInt(Math.floor(mtime / 1e3));
+			HEAPU32[buf + 64 >>> 2 >>> 0] = mtime % 1e3 * 1e3 * 1e3;
+			HEAP64[buf + 72 >>> 3 >>> 0] = BigInt(Math.floor(ctime / 1e3));
+			HEAPU32[buf + 80 >>> 2 >>> 0] = ctime % 1e3 * 1e3 * 1e3;
+			HEAP64[buf + 88 >>> 3 >>> 0] = BigInt(stat.ino);
+			return 0;
+		},
+		writeStatFs(buf, stats) {
+			HEAPU32[buf + 4 >>> 2 >>> 0] = stats.bsize;
+			HEAPU32[buf + 60 >>> 2 >>> 0] = stats.bsize;
+			HEAP64[buf + 8 >>> 3 >>> 0] = BigInt(stats.blocks);
+			HEAP64[buf + 16 >>> 3 >>> 0] = BigInt(stats.bfree);
+			HEAP64[buf + 24 >>> 3 >>> 0] = BigInt(stats.bavail);
+			HEAP64[buf + 32 >>> 3 >>> 0] = BigInt(stats.files);
+			HEAP64[buf + 40 >>> 3 >>> 0] = BigInt(stats.ffree);
+			HEAPU32[buf + 48 >>> 2 >>> 0] = stats.fsid;
+			HEAPU32[buf + 64 >>> 2 >>> 0] = stats.flags;
+			HEAPU32[buf + 56 >>> 2 >>> 0] = stats.namelen;
+		},
+		doMsync(addr, stream, len, flags, offset) {
+			if (!FS.isFile(stream.node.mode)) throw new FS.ErrnoError(43);
+			if (flags & 2) return 0;
+			const buffer = HEAPU8.slice(addr, addr + len);
+			FS.msync(stream, buffer, offset, len, flags);
+		},
+		getStreamFromFD(fd) {
+			const stream = FS.getStreamChecked(fd);
+			return stream;
+		},
+		varargs: void 0,
+		getStr(ptr) {
+			const ret = UTF8ToString(ptr);
+			return ret;
+		}
+	};
+	const INT53_MAX = 9007199254740992;
+	const INT53_MIN = -9007199254740992;
+	const bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? Number.NaN : Number(num);
+	function ___syscall_chmod(path, mode) {
+		path >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			FS.chmod(path, mode);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_faccessat(dirfd, path, amode, flags) {
+		path >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			if (amode & -8) return -28;
+			const lookup = FS.lookupPath(path, { follow: true });
+			const node = lookup.node;
+			if (!node) return -44;
+			let perms = "";
+			if (amode & 4) perms += "r";
+			if (amode & 2) perms += "w";
+			if (amode & 1) perms += "x";
+			if (perms && FS.nodePermissions(node, perms)) return -2;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_fchmod(fd, mode) {
+		try {
+			FS.fchmod(fd, mode);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	const syscallGetVarargI = () => {
+		const ret = HEAP32[+SYSCALLS.varargs >>> 2 >>> 0];
+		SYSCALLS.varargs += 4;
+		return ret;
+	};
+	const syscallGetVarargP = syscallGetVarargI;
+	function ___syscall_fcntl64(fd, cmd, varargs) {
+		varargs >>>= 0;
+		SYSCALLS.varargs = varargs;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			switch (cmd) {
+				case 0: {
+					var arg = syscallGetVarargI();
+					if (arg < 0) return -28;
+					while (FS.streams[arg]) arg++;
+					let newStream;
+					newStream = FS.dupStream(stream, arg);
+					return newStream.fd;
+				}
+				case 1:
+				case 2: return 0;
+				case 3: return stream.flags;
+				case 4: {
+					var arg = syscallGetVarargI();
+					stream.flags |= arg;
+					return 0;
+				}
+				case 12: {
+					var arg = syscallGetVarargP();
+					const offset = 0;
+					HEAP16[arg + offset >>> 1 >>> 0] = 2;
+					return 0;
+				}
+				case 13:
+				case 14: return 0;
+			}
+			return -28;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_fdatasync(fd) {
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_fstat64(fd, buf) {
+		buf >>>= 0;
+		try {
+			return SYSCALLS.writeStat(buf, FS.fstat(fd));
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_ftruncate64(fd, length) {
+		length = bigintToI53Checked(length);
+		try {
+			if (isNaN(length)) return -61;
+			FS.ftruncate(fd, length);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	const stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+	function ___syscall_getcwd(buf, size) {
+		buf >>>= 0;
+		size >>>= 0;
+		try {
+			if (size === 0) return -28;
+			const cwd = FS.cwd();
+			const cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
+			if (size < cwdLengthInBytes) return -68;
+			stringToUTF8(cwd, buf, size);
+			return cwdLengthInBytes;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_getdents64(fd, dirp, count) {
+		dirp >>>= 0;
+		count >>>= 0;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			stream.getdents ||= FS.readdir(stream.path);
+			const struct_size = 280;
+			let pos = 0;
+			const off = FS.llseek(stream, 0, 1);
+			const startIdx = Math.floor(off / struct_size);
+			const endIdx = Math.min(stream.getdents.length, startIdx + Math.floor(count / struct_size));
+			for (var idx = startIdx; idx < endIdx; idx++) {
+				var id;
+				var type;
+				const name = stream.getdents[idx];
+				if (name === ".") {
+					id = stream.node.id;
+					type = 4;
+				} else if (name === "..") {
+					const lookup = FS.lookupPath(stream.path, { parent: true });
+					id = lookup.node.id;
+					type = 4;
+				} else {
+					var child;
+					try {
+						child = FS.lookupNode(stream.node, name);
+					} catch (e) {
+						if (e?.errno === 28) continue;
+						throw e;
+					}
+					id = child.id;
+					type = FS.isChrdev(child.mode) ? 2 : FS.isDir(child.mode) ? 4 : FS.isLink(child.mode) ? 10 : 8;
+				}
+				HEAP64[dirp + pos >>> 3 >>> 0] = BigInt(id);
+				HEAP64[dirp + pos + 8 >>> 3 >>> 0] = BigInt((idx + 1) * struct_size);
+				HEAP16[dirp + pos + 16 >>> 1 >>> 0] = 280;
+				HEAP8[dirp + pos + 18 >>> 0] = type;
+				stringToUTF8(name, dirp + pos + 19, 256);
+				pos += struct_size;
+			}
+			FS.llseek(stream, idx * struct_size, 0);
+			return pos;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_ioctl(fd, op, varargs) {
+		varargs >>>= 0;
+		SYSCALLS.varargs = varargs;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			switch (op) {
+				case 21509: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
+				case 21505: {
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tcgets) {
+						const termios = stream.tty.ops.ioctl_tcgets(stream);
+						var argp = syscallGetVarargP();
+						HEAP32[argp >>> 2 >>> 0] = termios.c_iflag || 0;
+						HEAP32[argp + 4 >>> 2 >>> 0] = termios.c_oflag || 0;
+						HEAP32[argp + 8 >>> 2 >>> 0] = termios.c_cflag || 0;
+						HEAP32[argp + 12 >>> 2 >>> 0] = termios.c_lflag || 0;
+						for (var i = 0; i < 32; i++) HEAP8[argp + i + 17 >>> 0] = termios.c_cc[i] || 0;
+						return 0;
+					}
+					return 0;
+				}
+				case 21510:
+				case 21511:
+				case 21512: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
+				case 21506:
+				case 21507:
+				case 21508: {
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tcsets) {
+						var argp = syscallGetVarargP();
+						const c_iflag = HEAP32[argp >>> 2 >>> 0];
+						const c_oflag = HEAP32[argp + 4 >>> 2 >>> 0];
+						const c_cflag = HEAP32[argp + 8 >>> 2 >>> 0];
+						const c_lflag = HEAP32[argp + 12 >>> 2 >>> 0];
+						const c_cc = [];
+						for (var i = 0; i < 32; i++) c_cc.push(HEAP8[argp + i + 17 >>> 0]);
+						return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
+							c_iflag,
+							c_oflag,
+							c_cflag,
+							c_lflag,
+							c_cc
+						});
+					}
+					return 0;
+				}
+				case 21519: {
+					if (!stream.tty) return -59;
+					var argp = syscallGetVarargP();
+					HEAP32[argp >>> 2 >>> 0] = 0;
+					return 0;
+				}
+				case 21520: {
+					if (!stream.tty) return -59;
+					return -28;
+				}
+				case 21537:
+				case 21531: {
+					var argp = syscallGetVarargP();
+					return FS.ioctl(stream, op, argp);
+				}
+				case 21523: {
+					if (!stream.tty) return -59;
+					if (stream.tty.ops.ioctl_tiocgwinsz) {
+						const winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+						var argp = syscallGetVarargP();
+						HEAP16[argp >>> 1 >>> 0] = winsize[0];
+						HEAP16[argp + 2 >>> 1 >>> 0] = winsize[1];
+					}
+					return 0;
+				}
+				case 21524: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
+				case 21515: {
+					if (!stream.tty) return -59;
+					return 0;
+				}
+				default: return -28;
+			}
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_lstat64(path, buf) {
+		path >>>= 0;
+		buf >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			return SYSCALLS.writeStat(buf, FS.lstat(path));
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_mkdirat(dirfd, path, mode) {
+		path >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			FS.mkdir(path, mode, 0);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_newfstatat(dirfd, path, buf, flags) {
+		path >>>= 0;
+		buf >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			const nofollow = flags & 256;
+			const allowEmpty = flags & 4096;
+			flags = flags & -6401;
+			path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
+			return SYSCALLS.writeStat(buf, nofollow ? FS.lstat(path) : FS.stat(path));
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_openat(dirfd, path, flags, varargs) {
+		path >>>= 0;
+		varargs >>>= 0;
+		SYSCALLS.varargs = varargs;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			const mode = varargs ? syscallGetVarargI() : 0;
+			return FS.open(path, flags, mode).fd;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
+		path >>>= 0;
+		buf >>>= 0;
+		bufsize >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			if (bufsize <= 0) return -28;
+			const ret = FS.readlink(path);
+			const len = Math.min(bufsize, lengthBytesUTF8(ret));
+			const endChar = HEAP8[buf + len >>> 0];
+			stringToUTF8(ret, buf, bufsize + 1);
+			HEAP8[buf + len >>> 0] = endChar;
+			return len;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
+		oldpath >>>= 0;
+		newpath >>>= 0;
+		try {
+			oldpath = SYSCALLS.getStr(oldpath);
+			newpath = SYSCALLS.getStr(newpath);
+			oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
+			newpath = SYSCALLS.calculateAt(newdirfd, newpath);
+			FS.rename(oldpath, newpath);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_rmdir(path) {
+		path >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			FS.rmdir(path);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_stat64(path, buf) {
+		path >>>= 0;
+		buf >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			return SYSCALLS.writeStat(buf, FS.stat(path));
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_truncate64(path, length) {
+		path >>>= 0;
+		length = bigintToI53Checked(length);
+		try {
+			if (isNaN(length)) return -61;
+			path = SYSCALLS.getStr(path);
+			FS.truncate(path, length);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function ___syscall_unlinkat(dirfd, path, flags) {
+		path >>>= 0;
+		try {
+			path = SYSCALLS.getStr(path);
+			path = SYSCALLS.calculateAt(dirfd, path);
+			if (!flags) FS.unlink(path);
+			else if (flags === 512) FS.rmdir(path);
+			else return -28;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	const __abort_js = () => abort("");
+	let runtimeKeepaliveCounter = 0;
+	const __emscripten_runtime_keepalive_clear = () => {
+		noExitRuntime = false;
+		runtimeKeepaliveCounter = 0;
+	};
+	const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+	const MONTH_DAYS_LEAP_CUMULATIVE = [
+		0,
+		31,
+		60,
+		91,
+		121,
+		152,
+		182,
+		213,
+		244,
+		274,
+		305,
+		335
+	];
+	const MONTH_DAYS_REGULAR_CUMULATIVE = [
+		0,
+		31,
+		59,
+		90,
+		120,
+		151,
+		181,
+		212,
+		243,
+		273,
+		304,
+		334
+	];
+	const ydayFromDate = (date) => {
+		const leap = isLeapYear(date.getFullYear());
+		const monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
+		const yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
+		return yday;
+	};
+	function __localtime_js(time, tmPtr) {
+		time = bigintToI53Checked(time);
+		tmPtr >>>= 0;
+		const date = new Date(time * 1e3);
+		HEAP32[tmPtr >>> 2 >>> 0] = date.getSeconds();
+		HEAP32[tmPtr + 4 >>> 2 >>> 0] = date.getMinutes();
+		HEAP32[tmPtr + 8 >>> 2 >>> 0] = date.getHours();
+		HEAP32[tmPtr + 12 >>> 2 >>> 0] = date.getDate();
+		HEAP32[tmPtr + 16 >>> 2 >>> 0] = date.getMonth();
+		HEAP32[tmPtr + 20 >>> 2 >>> 0] = date.getFullYear() - 1900;
+		HEAP32[tmPtr + 24 >>> 2 >>> 0] = date.getDay();
+		const yday = ydayFromDate(date) | 0;
+		HEAP32[tmPtr + 28 >>> 2 >>> 0] = yday;
+		HEAP32[tmPtr + 36 >>> 2 >>> 0] = -(date.getTimezoneOffset() * 60);
+		const start = new Date(date.getFullYear(), 0, 1);
+		const summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+		const winterOffset = start.getTimezoneOffset();
+		const dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
+		HEAP32[tmPtr + 32 >>> 2 >>> 0] = dst;
+	}
+	function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
+		len >>>= 0;
+		offset = bigintToI53Checked(offset);
+		allocated >>>= 0;
+		addr >>>= 0;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			const res = FS.mmap(stream, len, offset, prot, flags);
+			const ptr = res.ptr;
+			HEAP32[allocated >>> 2 >>> 0] = res.allocated;
+			HEAPU32[addr >>> 2 >>> 0] = ptr;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	function __munmap_js(addr, len, prot, flags, fd, offset) {
+		addr >>>= 0;
+		len >>>= 0;
+		offset = bigintToI53Checked(offset);
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			if (prot & 2) SYSCALLS.doMsync(addr, stream, len, flags, offset);
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return -e.errno;
+		}
+	}
+	const timers = {};
+	const handleException = (e) => {
+		if (e instanceof ExitStatus || e == "unwind") return EXITSTATUS;
+		quit_(1, e);
+	};
+	const keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+	const _proc_exit = (code) => {
+		EXITSTATUS = code;
+		if (!keepRuntimeAlive()) {
+			Module.onExit?.(code);
+			ABORT = true;
+		}
+		quit_(code, new ExitStatus(code));
+	};
+	const exitJS = (status, implicit) => {
+		EXITSTATUS = status;
+		_proc_exit(status);
+	};
+	const _exit = exitJS;
+	const maybeExit = () => {
+		if (!keepRuntimeAlive()) try {
+			_exit(EXITSTATUS);
+		} catch (e) {
+			handleException(e);
+		}
+	};
+	const callUserCallback = (func) => {
+		if (ABORT) return;
+		try {
+			return func();
+		} catch (e) {
+			handleException(e);
+		} finally {
+			maybeExit();
+		}
+	};
+	const _emscripten_get_now = () => performance.now();
+	const __setitimer_js = (which, timeout_ms) => {
+		if (timers[which]) {
+			clearTimeout(timers[which].id);
+			delete timers[which];
+		}
+		if (!timeout_ms) return 0;
+		const id = setTimeout(() => {
+			delete timers[which];
+			callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
+		}, timeout_ms);
+		timers[which] = {
+			id,
+			timeout_ms
+		};
+		return 0;
+	};
+	const __tzset_js = function(timezone, daylight, std_name, dst_name) {
+		timezone >>>= 0;
+		daylight >>>= 0;
+		std_name >>>= 0;
+		dst_name >>>= 0;
+		const currentYear = new Date().getFullYear();
+		const winter = new Date(currentYear, 0, 1);
+		const summer = new Date(currentYear, 6, 1);
+		const winterOffset = winter.getTimezoneOffset();
+		const summerOffset = summer.getTimezoneOffset();
+		const stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+		HEAPU32[timezone >>> 2 >>> 0] = stdTimezoneOffset * 60;
+		HEAP32[daylight >>> 2 >>> 0] = Number(winterOffset != summerOffset);
+		const extractZone = (timezoneOffset) => {
+			const sign = timezoneOffset >= 0 ? "-" : "+";
+			const absOffset = Math.abs(timezoneOffset);
+			const hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
+			const minutes = String(absOffset % 60).padStart(2, "0");
+			return `UTC${sign}${hours}${minutes}`;
+		};
+		const winterName = extractZone(winterOffset);
+		const summerName = extractZone(summerOffset);
+		if (summerOffset < winterOffset) {
+			stringToUTF8(winterName, std_name, 17);
+			stringToUTF8(summerName, dst_name, 17);
+		} else {
+			stringToUTF8(winterName, dst_name, 17);
+			stringToUTF8(summerName, std_name, 17);
+		}
+	};
+	const _emscripten_date_now = () => Date.now();
+	const nowIsMonotonic = 1;
+	const checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+	function _clock_time_get(clk_id, ignored_precision, ptime) {
+		ignored_precision = bigintToI53Checked(ignored_precision);
+		ptime >>>= 0;
+		if (!checkWasiClock(clk_id)) return 28;
+		let now;
+		if (clk_id === 0) now = _emscripten_date_now();
+		else if (nowIsMonotonic) now = _emscripten_get_now();
+		else return 52;
+		const nsec = Math.round(now * 1e3 * 1e3);
+		HEAP64[ptime >>> 3 >>> 0] = BigInt(nsec);
+		return 0;
+	}
+	const getHeapMax = () => 4294901760;
+	const growMemory = (size) => {
+		const oldHeapSize = wasmMemory.buffer.byteLength;
+		const pages = (size - oldHeapSize + 65535) / 65536 | 0;
+		try {
+			wasmMemory.grow(pages);
+			updateMemoryViews();
+			return 1;
+		} catch (e) {}
+	};
+	function _emscripten_resize_heap(requestedSize) {
+		requestedSize >>>= 0;
+		const oldSize = HEAPU8.length;
+		const maxHeapSize = getHeapMax();
+		if (requestedSize > maxHeapSize) return false;
+		for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
+			let overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+			overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+			const newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+			const replacement = growMemory(newSize);
+			if (replacement) return true;
+		}
+		return false;
+	}
+	const ENV = {};
+	const getExecutableName = () => thisProgram || "./this.program";
+	const getEnvStrings = () => {
+		if (!getEnvStrings.strings) {
+			const lang = `${(globalThis.navigator?.language ?? "C").replace("-", "_")}.UTF-8`;
+			const env = {
+				USER: "web_user",
+				LOGNAME: "web_user",
+				PATH: "/",
+				PWD: "/",
+				HOME: "/home/web_user",
+				LANG: lang,
+				_: getExecutableName()
+			};
+			for (var x in ENV) if (ENV[x] === void 0) delete env[x];
+			else env[x] = ENV[x];
+			const strings = [];
+			for (var x in env) strings.push(`${x}=${env[x]}`);
+			getEnvStrings.strings = strings;
+		}
+		return getEnvStrings.strings;
+	};
+	function _environ_get(__environ, environ_buf) {
+		__environ >>>= 0;
+		environ_buf >>>= 0;
+		let bufSize = 0;
+		let envp = 0;
+		for (const string of getEnvStrings()) {
+			const ptr = environ_buf + bufSize;
+			HEAPU32[__environ + envp >>> 2 >>> 0] = ptr;
+			bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+			envp += 4;
+		}
+		return 0;
+	}
+	function _environ_sizes_get(penviron_count, penviron_buf_size) {
+		penviron_count >>>= 0;
+		penviron_buf_size >>>= 0;
+		const strings = getEnvStrings();
+		HEAPU32[penviron_count >>> 2 >>> 0] = strings.length;
+		let bufSize = 0;
+		for (const string of strings) bufSize += lengthBytesUTF8(string) + 1;
+		HEAPU32[penviron_buf_size >>> 2 >>> 0] = bufSize;
+		return 0;
+	}
+	function _fd_close(fd) {
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			FS.close(stream);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	function _fd_fdstat_get(fd, pbuf) {
+		pbuf >>>= 0;
+		try {
+			const rightsBase = 0;
+			const rightsInheriting = 0;
+			const flags = 0;
+			{
+				const stream = SYSCALLS.getStreamFromFD(fd);
+				var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
+			}
+			HEAP8[pbuf >>> 0] = type;
+			HEAP16[pbuf + 2 >>> 1 >>> 0] = flags;
+			HEAP64[pbuf + 8 >>> 3 >>> 0] = BigInt(rightsBase);
+			HEAP64[pbuf + 16 >>> 3 >>> 0] = BigInt(rightsInheriting);
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	const doReadv = (stream, iov, iovcnt, offset) => {
+		let ret = 0;
+		for (let i = 0; i < iovcnt; i++) {
+			const ptr = HEAPU32[iov >>> 2 >>> 0];
+			const len = HEAPU32[iov + 4 >>> 2 >>> 0];
+			iov += 8;
+			const curr = FS.read(stream, HEAP8, ptr, len, offset);
+			if (curr < 0) return -1;
+			ret += curr;
+			if (curr < len) break;
+			if (typeof offset != "undefined") offset += curr;
+		}
+		return ret;
+	};
+	function _fd_pread(fd, iov, iovcnt, offset, pnum) {
+		iov >>>= 0;
+		iovcnt >>>= 0;
+		offset = bigintToI53Checked(offset);
+		pnum >>>= 0;
+		try {
+			if (isNaN(offset)) return 61;
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			const num = doReadv(stream, iov, iovcnt, offset);
+			HEAPU32[pnum >>> 2 >>> 0] = num;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	function _fd_read(fd, iov, iovcnt, pnum) {
+		iov >>>= 0;
+		iovcnt >>>= 0;
+		pnum >>>= 0;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			const num = doReadv(stream, iov, iovcnt);
+			HEAPU32[pnum >>> 2 >>> 0] = num;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	function _fd_seek(fd, offset, whence, newOffset) {
+		offset = bigintToI53Checked(offset);
+		newOffset >>>= 0;
+		try {
+			if (isNaN(offset)) return 61;
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			FS.llseek(stream, offset, whence);
+			HEAP64[newOffset >>> 3 >>> 0] = BigInt(stream.position);
+			if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	const doWritev = (stream, iov, iovcnt, offset) => {
+		let ret = 0;
+		for (let i = 0; i < iovcnt; i++) {
+			const ptr = HEAPU32[iov >>> 2 >>> 0];
+			const len = HEAPU32[iov + 4 >>> 2 >>> 0];
+			iov += 8;
+			const curr = FS.write(stream, HEAP8, ptr, len, offset);
+			if (curr < 0) return -1;
+			ret += curr;
+			if (curr < len) break;
+			if (typeof offset != "undefined") offset += curr;
+		}
+		return ret;
+	};
+	function _fd_write(fd, iov, iovcnt, pnum) {
+		iov >>>= 0;
+		iovcnt >>>= 0;
+		pnum >>>= 0;
+		try {
+			const stream = SYSCALLS.getStreamFromFD(fd);
+			const num = doWritev(stream, iov, iovcnt);
+			HEAPU32[pnum >>> 2 >>> 0] = num;
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	function _random_get(buffer, size) {
+		buffer >>>= 0;
+		size >>>= 0;
+		try {
+			randomFill(HEAPU8.subarray(buffer >>> 0, buffer + size >>> 0));
+			return 0;
+		} catch (e) {
+			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+			return e.errno;
+		}
+	}
+	const getCFunc = (ident) => {
+		const func = Module[`_${ident}`];
+		return func;
+	};
+	const writeArrayToMemory = (array, buffer) => {
+		HEAP8.set(array, buffer >>> 0);
+	};
+	const stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+	const stringToUTF8OnStack = (str) => {
+		const size = lengthBytesUTF8(str) + 1;
+		const ret = stackAlloc(size);
+		stringToUTF8(str, ret, size);
+		return ret;
+	};
+	const stackSave = () => _emscripten_stack_get_current();
+	const stackRestore = (val) => __emscripten_stack_restore(val);
+	const ccall = (ident, returnType, argTypes, args, opts) => {
+		const toC = {
+			string: (str) => {
+				let ret$1 = 0;
+				if (str !== null && str !== void 0 && str !== 0) ret$1 = stringToUTF8OnStack(str);
+				return ret$1;
+			},
+			array: (arr) => {
+				const ret$1 = stackAlloc(arr.length);
+				writeArrayToMemory(arr, ret$1);
+				return ret$1;
+			}
+		};
+		function convertReturnValue(ret$1) {
+			if (returnType === "string") return UTF8ToString(ret$1);
+			if (returnType === "pointer") return ret$1 >>> 0;
+			if (returnType === "boolean") return Boolean(ret$1);
+			return ret$1;
+		}
+		const func = getCFunc(ident);
+		const cArgs = [];
+		let stack = 0;
+		if (args) for (let i = 0; i < args.length; i++) {
+			const converter = toC[argTypes[i]];
+			if (converter) {
+				if (stack === 0) stack = stackSave();
+				cArgs[i] = converter(args[i]);
+			} else cArgs[i] = args[i];
+		}
+		let ret = func(...cArgs);
+		function onDone(ret$1) {
+			if (stack !== 0) stackRestore(stack);
+			return convertReturnValue(ret$1);
+		}
+		ret = onDone(ret);
+		return ret;
+	};
+	const FS_createPath = (...args) => FS.createPath(...args);
+	const FS_unlink = (...args) => FS.unlink(...args);
+	const FS_createLazyFile = (...args) => FS.createLazyFile(...args);
+	const FS_createDevice = (...args) => FS.createDevice(...args);
+	FS.createPreloadedFile = FS_createPreloadedFile;
+	FS.preloadFile = FS_preloadFile;
+	FS.staticInit();
+	{
+		if (Module.noExitRuntime) noExitRuntime = Module.noExitRuntime;
+		if (Module.preloadPlugins) preloadPlugins = Module.preloadPlugins;
+		if (Module.print) out = Module.print;
+		if (Module.printErr) err = Module.printErr;
+		if (Module.wasmBinary) wasmBinary = Module.wasmBinary;
+		if (Module.arguments) arguments_ = Module.arguments;
+		if (Module.thisProgram) thisProgram = Module.thisProgram;
+		if (Module.preInit) {
+			if (typeof Module.preInit == "function") Module.preInit = [Module.preInit];
+			while (Module.preInit.length > 0) Module.preInit.shift()();
+		}
+	}
+	Module.addRunDependency = addRunDependency;
+	Module.removeRunDependency = removeRunDependency;
+	Module.ccall = ccall;
+	Module.FS_preloadFile = FS_preloadFile;
+	Module.FS_unlink = FS_unlink;
+	Module.FS_createPath = FS_createPath;
+	Module.FS_createDevice = FS_createDevice;
+	Module.FS = FS;
+	Module.FS_createDataFile = FS_createDataFile;
+	Module.FS_createLazyFile = FS_createLazyFile;
+	let _free, _malloc, _rime_wasm_init, _rime_wasm_process_input, _rime_wasm_pick_candidate, _rime_wasm_flip_page, _rime_wasm_clear_input, _rime_wasm_set_option, _rime_wasm_get_version, _rime_wasm_destroy, _emscripten_builtin_memalign, __emscripten_timeout, ___trap, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, memory, __indirect_function_table, wasmMemory;
+	function assignWasmExports(wasmExports$1) {
+		_free = Module._free = wasmExports$1.R;
+		_malloc = Module._malloc = wasmExports$1.S;
+		_rime_wasm_init = Module._rime_wasm_init = wasmExports$1.T;
+		_rime_wasm_process_input = Module._rime_wasm_process_input = wasmExports$1.U;
+		_rime_wasm_pick_candidate = Module._rime_wasm_pick_candidate = wasmExports$1.V;
+		_rime_wasm_flip_page = Module._rime_wasm_flip_page = wasmExports$1.W;
+		_rime_wasm_clear_input = Module._rime_wasm_clear_input = wasmExports$1.X;
+		_rime_wasm_set_option = Module._rime_wasm_set_option = wasmExports$1.Y;
+		_rime_wasm_get_version = Module._rime_wasm_get_version = wasmExports$1.Z;
+		_rime_wasm_destroy = Module._rime_wasm_destroy = wasmExports$1._;
+		_emscripten_builtin_memalign = wasmExports$1.$;
+		__emscripten_timeout = wasmExports$1.aa;
+		___trap = wasmExports$1.ba;
+		__emscripten_stack_restore = wasmExports$1.ca;
+		__emscripten_stack_alloc = wasmExports$1.da;
+		_emscripten_stack_get_current = wasmExports$1.ea;
+		memory = wasmMemory = wasmExports$1.P;
+		__indirect_function_table = wasmExports$1.__indirect_function_table;
+	}
+	var wasmImports = {
+		r: ___syscall_chmod,
+		k: ___syscall_faccessat,
+		s: ___syscall_fchmod,
+		c: ___syscall_fcntl64,
+		j: ___syscall_fdatasync,
+		N: ___syscall_fstat64,
+		q: ___syscall_ftruncate64,
+		u: ___syscall_getcwd,
+		A: ___syscall_getdents64,
+		O: ___syscall_ioctl,
+		L: ___syscall_lstat64,
+		G: ___syscall_mkdirat,
+		K: ___syscall_newfstatat,
+		d: ___syscall_openat,
+		v: ___syscall_readlinkat,
+		z: ___syscall_renameat,
+		i: ___syscall_rmdir,
+		M: ___syscall_stat64,
+		t: ___syscall_truncate64,
+		h: ___syscall_unlinkat,
+		l: __abort_js,
+		n: __emscripten_runtime_keepalive_clear,
+		E: __localtime_js,
+		C: __mmap_js,
+		D: __munmap_js,
+		o: __setitimer_js,
+		F: __tzset_js,
+		w: _clock_time_get,
+		e: _emscripten_date_now,
+		b: _emscripten_get_now,
+		x: _emscripten_resize_heap,
+		I: _environ_get,
+		J: _environ_sizes_get,
+		a: _fd_close,
+		y: _fd_fdstat_get,
+		B: _fd_pread,
+		g: _fd_read,
+		H: _fd_seek,
+		f: _fd_write,
+		m: _proc_exit,
+		p: _random_get
+	};
+	function applySignatureConversions(wasmExports$1) {
+		wasmExports$1 = Object.assign({}, wasmExports$1);
+		const makeWrapper_pp = (f) => (a0) => f(a0) >>> 0;
+		const makeWrapper_ppp = (f) => (a0, a1) => f(a0, a1) >>> 0;
+		const makeWrapper_p = (f) => () => f() >>> 0;
+		wasmExports$1.S = makeWrapper_pp(wasmExports$1.S);
+		wasmExports$1.$ = makeWrapper_ppp(wasmExports$1.$);
+		wasmExports$1.da = makeWrapper_pp(wasmExports$1.da);
+		wasmExports$1.ea = makeWrapper_p(wasmExports$1.ea);
+		return wasmExports$1;
+	}
+	function run() {
+		if (runDependencies > 0) {
+			dependenciesFulfilled = run;
+			return;
+		}
+		preRun();
+		if (runDependencies > 0) {
+			dependenciesFulfilled = run;
+			return;
+		}
+		function doRun() {
+			Module.calledRun = true;
+			if (ABORT) return;
+			initRuntime();
+			readyPromiseResolve?.(Module);
+			Module.onRuntimeInitialized?.();
+			postRun();
+		}
+		if (Module.setStatus) {
+			Module.setStatus("Running...");
+			setTimeout(() => {
+				setTimeout(() => Module.setStatus(""), 1);
+				doRun();
+			}, 1);
+		} else doRun();
+	}
+	let wasmExports;
+	wasmExports = await createWasm();
+	run();
+	if (runtimeInitialized) moduleRtn = Module;
+	else moduleRtn = new Promise((resolve, reject) => {
+		readyPromiseResolve = resolve;
+		readyPromiseReject = reject;
+	});
+	return moduleRtn;
+}
+var rime_api_default = createRimeModule;
+
+//#endregion
+//#region src/rime.ts
+function syncfs(module, populate) {
+	return new Promise((resolve, reject) => {
+		module.FS.syncfs(populate, (err) => {
+			if (err) reject(err);
+			else resolve();
+		});
+	});
+}
+async function createRimeEngine(options = {}) {
+	const wasmDir = options.wasmDir ?? ".";
+	const Module = await rime_api_default({ locateFile(file) {
+		return `${wasmDir}/${file}`;
+	} });
+	try {
+		Module.FS.mkdir("/rime_user");
+	} catch {}
+	Module.FS.mount(Module.FS.filesystems.IDBFS, {}, "/rime_user");
+	await syncfs(Module, true);
+	try {
+		Module.FS.mkdir("/rime");
+	} catch {}
+	try {
+		Module.FS.mkdir("/rime/build");
+	} catch {}
+	const allDataFiles = options.dataFiles ?? [
+		"default.yaml",
+		"luna_pinyin.schema.yaml",
+		"luna_pinyin.table.bin",
+		"luna_pinyin.prism.bin",
+		"luna_pinyin.reverse.bin"
+	];
+	await Promise.all(allDataFiles.map(async (file) => {
+		const url = `${wasmDir}/${file}`;
+		const resp = await fetch(url);
+		if (!resp.ok) throw new Error(`Failed to fetch ${url}: ${resp.status}`);
+		const data = new Uint8Array(await resp.arrayBuffer());
+		Module.FS.writeFile(`/rime/build/${file}`, data);
+	}));
+	const rc = Module.ccall("rime_wasm_init", "number", [], []);
+	if (rc !== 0) throw new Error(`rime_wasm_init failed with code ${rc}`);
+	await syncfs(Module, false);
+	let destroyed = false;
+	function callJson(fn, argTypes, args) {
+		if (destroyed) throw new Error("Engine is destroyed");
+		const json = Module.ccall(fn, "string", argTypes, args);
+		return JSON.parse(json);
+	}
+	const engine = {
+		processInput(keys) {
+			return callJson("rime_wasm_process_input", ["string"], [keys]);
+		},
+		pickCandidate(index) {
+			const state = callJson("rime_wasm_pick_candidate", ["number"], [index]);
+			syncfs(Module, false).catch(() => {});
+			return state;
+		},
+		flipPage(forward) {
+			return callJson("rime_wasm_flip_page", ["number"], [forward ? 0 : 1]);
+		},
+		clearInput() {
+			if (destroyed) return;
+			Module.ccall("rime_wasm_clear_input", null, [], []);
+		},
+		setOption(name, value) {
+			if (destroyed) return;
+			Module.ccall("rime_wasm_set_option", null, ["string", "number"], [name, value ? 1 : 0]);
+		},
+		getVersion() {
+			if (destroyed) return "unknown";
+			return Module.ccall("rime_wasm_get_version", "string", [], []);
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			Module.ccall("rime_wasm_destroy", null, [], []);
+			syncfs(Module, false).catch(() => {});
+		}
+	};
+	return engine;
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* 创建基于 RIME WASM 的拼音引擎，实现 PinyinEngine 通用接口。
+* 内部处理分页逻辑，processInput 返回所有页的候选词集合。
+*/
+var RimePinyinEngine = class {
+	engine = null;
+	prevRimeInput = "";
+	initPromise = null;
+	constructor(options = {}) {
+		this.options = options;
+		this.initialize();
+	}
+	async getEngine() {
+		await this.initialize();
+		return this.engine;
+	}
+	async initialize() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = (async () => {
+			this.engine = await createRimeEngine(this.options);
+			this.engine.setOption("zh_simp", this.options.simplified ?? true);
+		})();
+		return this.initPromise;
+	}
+	async processInput(fullPinyin) {
+		const engine = await this.getEngine();
+		if (!fullPinyin) {
+			engine.clearInput();
+			this.prevRimeInput = "";
+			return null;
+		}
+		let state;
+		if (fullPinyin.startsWith(this.prevRimeInput)) {
+			const delta = fullPinyin.slice(this.prevRimeInput.length);
+			state = engine.processInput(delta);
+		} else {
+			engine.clearInput();
+			state = engine.processInput(fullPinyin);
+		}
+		this.prevRimeInput = fullPinyin;
+		return state;
+	}
+	async pickCandidate(index) {
+		const engine = await this.getEngine();
+		return engine.pickCandidate(index);
+	}
+	async clearInput() {
+		const engine = await this.getEngine();
+		return engine.clearInput();
+	}
+	async setSimplified(simplified) {
+		const engine = await this.getEngine();
+		return engine.setOption("zh_simp", simplified);
+	}
+	async destroy() {
+		const engine = await this.getEngine();
+		return engine.destroy();
+	}
+};
+
+//#endregion
+export { RimePinyinEngine };
+//# sourceMappingURL=index.mjs.map