npm - @zh-keyboard/pinyin - Versions diffs - 1.1.0 → 1.1.2 - Mend

@zh-keyboard/pinyin 1.1.0 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,35 +1,22 @@
 //#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++;
+	var moduleRtn;
+	var Module = moduleArg;
+	var ENVIRONMENT_IS_WEB = true;
+	var ENVIRONMENT_IS_WORKER = false;
+	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";
+		if (typeof ENVIRONMENT_IS_PTHREAD != "undefined" && ENVIRONMENT_IS_PTHREAD || typeof ENVIRONMENT_IS_WASM_WORKER != "undefined" && ENVIRONMENT_IS_WASM_WORKER) return;
 		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;
+			if (typeof window === "object") window["encodeURIComponent"](window.location.pathname.substring(0, window.location.pathname.lastIndexOf("/")) + "/");
+			else if (typeof process === "undefined" && typeof location !== "undefined") encodeURIComponent(location.pathname.substring(0, location.pathname.lastIndexOf("/")) + "/");
+			var PACKAGE_NAME = "/home/zzx/work/librime/wasm/dist/rime-api.data";
+			var REMOTE_PACKAGE_BASE = "rime-api.data";
+			var REMOTE_PACKAGE_NAME = Module["locateFile"] ? Module["locateFile"](REMOTE_PACKAGE_BASE, "") : REMOTE_PACKAGE_BASE;
+			var 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 = {};
+				if (!Module["dataFileDownloads"]) Module["dataFileDownloads"] = {};
 				try {
 					var response = await fetch(packageName);
 				} catch (e) {
@@ -40,24 +27,24 @@ async function createRimeModule(moduleArg = {}) {
 				const headers = response.headers;
 				const total = Number(headers.get("Content-Length") || packageSize);
 				let loaded = 0;
-				Module.setStatus && Module.setStatus("Downloading data...");
+				Module["setStatus"] && Module["setStatus"]("Downloading data...");
 				const reader = response.body.getReader();
 				while (1) {
-					const { done, value } = await reader.read();
+					var { done, value } = await reader.read();
 					if (done) break;
 					chunks.push(value);
 					loaded += value.length;
-					Module.dataFileDownloads[packageName] = {
+					Module["dataFileDownloads"][packageName] = {
 						loaded,
 						total
 					};
 					let totalLoaded = 0;
 					let totalSize = 0;
-					for (const download of Object.values(Module.dataFileDownloads)) {
+					for (const download of Object.values(Module["dataFileDownloads"])) {
 						totalLoaded += download.loaded;
 						totalSize += download.total;
 					}
-					Module.setStatus && Module.setStatus(`Downloading data... (${totalLoaded}/${totalSize})`);
+					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;
@@ -67,41 +54,41 @@ async function createRimeModule(moduleArg = {}) {
 				}
 				return packageData.buffer;
 			}
-			let fetchPromise;
-			let fetched = Module.getPreloadedPackage && Module.getPreloadedPackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE);
+			var fetchPromise;
+			var 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) {
+			async function runWithFS(Module) {
 				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}`);
+				Module["FS_createPath"]("/", "rime", true, true);
+				Module["FS_createPath"]("/rime", "opencc", true, true);
+				for (var file of metadata["files"]) {
+					var name = file["filename"];
+					Module["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}`);
+					assert(arrayBuffer.constructor.name === ArrayBuffer.name, "bad input to processPackageData " + arrayBuffer.constructor.name);
+					var byteArray = new Uint8Array(arrayBuffer);
+					for (var file of metadata["files"]) {
+						var name = file["filename"];
+						var data = byteArray.subarray(file["start"], file["end"]);
+						Module["FS_createDataFile"](name, null, data, true, true, true);
+						Module["removeRunDependency"](`fp ${name}`);
 					}
-					Module$1.removeRunDependency("datafile_/home/zzx/work/librime/wasm/dist/rime-api.data");
+					Module["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 };
+				Module["addRunDependency"]("datafile_/home/zzx/work/librime/wasm/dist/rime-api.data");
+				if (!Module["preloadResults"]) Module["preloadResults"] = {};
+				Module["preloadResults"][PACKAGE_NAME] = { fromCache: false };
 				if (!fetched) fetched = await fetchPromise;
 				processPackageData(fetched);
 			}
-			if (Module.calledRun) runWithFS(Module);
+			if (Module["calledRun"]) runWithFS(Module);
 			else {
-				if (!Module.preRun) Module.preRun = [];
-				Module.preRun.push(runWithFS);
+				if (!Module["preRun"]) Module["preRun"] = [];
+				Module["preRun"].push(runWithFS);
 			}
 		}
 		loadPackage({
@@ -140,128 +127,82 @@ async function createRimeModule(moduleArg = {}) {
 			remote_package_size: 1027747
 		});
 	})();
-	let arguments_ = [];
-	let thisProgram = "./this.program";
-	let quit_ = (status, toThrow) => {
+	var thisProgram = "./this.program";
+	var quit_ = (status, toThrow) => {
 		throw toThrow;
 	};
-	const _scriptName = import.meta.url;
-	let scriptDirectory = "";
+	var _scriptName = import.meta.url;
+	var scriptDirectory = "";
 	function locateFile(path) {
-		if (Module.locateFile) return Module.locateFile(path, scriptDirectory);
+		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) {
+	var readAsync, readBinary;
+	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}`);
-			};
-		}
+		readAsync = async (url) => {
+			var 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;
+	var out = console.log.bind(console);
+	var err = console.error.bind(console);
+	var wasmBinary;
+	var ABORT = false;
+	var EXITSTATUS;
+	var readyPromiseResolve, readyPromiseReject, HEAP8, HEAPU8, HEAP16, HEAP32, HEAPU32, HEAP64;
+	var runtimeInitialized = false;
 	function updateMemoryViews() {
-		const b = wasmMemory.buffer;
+		var b = wasmMemory.buffer;
 		HEAP8 = new Int8Array(b);
 		HEAP16 = new Int16Array(b);
 		HEAPU8 = new Uint8Array(b);
-		HEAPU16 = new Uint16Array(b);
+		new Uint16Array(b);
 		HEAP32 = new Int32Array(b);
 		HEAPU32 = new Uint32Array(b);
-		HEAPF32 = new Float32Array(b);
-		HEAPF64 = new Float64Array(b);
+		new Float32Array(b);
+		new Float64Array(b);
 		HEAP64 = new BigInt64Array(b);
-		HEAPU64 = new BigUint64Array(b);
+		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());
+		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();
+		if (!Module["noFSInit"] && !FS.initialized) FS.init();
 		TTY.init();
-		wasmExports.Q();
+		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());
+		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})`;
+		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);
+		var e = new WebAssembly.RuntimeError(what);
 		readyPromiseReject?.(e);
 		throw e;
 	}
-	let wasmBinaryFile;
+	var wasmBinaryFile;
 	function findWasmBinary() {
-		if (Module.locateFile) return locateFile("rime-api.wasm");
+		if (Module["locateFile"]) return locateFile("rime-api.wasm");
 		return new URL("rime-api.wasm", import.meta.url).href;
 	}
 	function getBinarySync(file) {
@@ -271,26 +212,24 @@ async function createRimeModule(moduleArg = {}) {
 	}
 	async function getWasmBinary(binaryFile) {
 		if (!wasmBinary) try {
-			const response = await readAsync(binaryFile);
+			var 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;
+			var binary = await getWasmBinary(binaryFile);
+			return await WebAssembly.instantiate(binary, imports);
 		} 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;
+		if (!binary) try {
+			var response = fetch(binaryFile, { credentials: "same-origin" });
+			return await WebAssembly.instantiateStreaming(response, imports);
 		} catch (reason) {
 			err(`wasm streaming compile failed: ${reason}`);
 			err("falling back to ArrayBuffer instantiation");
@@ -298,8 +237,7 @@ async function createRimeModule(moduleArg = {}) {
 		return instantiateArrayBuffer(binaryFile, imports);
 	}
 	function getWasmImports() {
-		const imports = { a: wasmImports };
-		return imports;
+		return { a: wasmImports };
 	}
 	async function createWasm() {
 		function receiveInstance(instance, module) {
@@ -309,19 +247,17 @@ async function createRimeModule(moduleArg = {}) {
 			updateMemoryViews();
 			return wasmExports;
 		}
-		function receiveInstantiationResult(result$1) {
-			return receiveInstance(result$1.instance);
+		function receiveInstantiationResult(result) {
+			return receiveInstance(result["instance"]);
 		}
-		const info = getWasmImports();
-		if (Module.instantiateWasm) return new Promise((resolve, reject) => {
-			Module.instantiateWasm(info, (inst, mod) => {
+		var 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;
+		return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
 	}
 	class ExitStatus {
 		name = "ExitStatus";
@@ -337,17 +273,16 @@ async function createRimeModule(moduleArg = {}) {
 	var addOnPostRun = (cb) => onPostRuns.push(cb);
 	var onPreRuns = [];
 	var addOnPreRun = (cb) => onPreRuns.push(cb);
-	let noExitRuntime = true;
+	var noExitRuntime = true;
 	var PATH = {
 		isAbs: (path) => path.charAt(0) === "/",
 		splitPath: (filename) => {
-			const splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?)?(\.[^./]*|))\/*$/;
-			return splitPathRe.exec(filename).slice(1);
+			return /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(filename).slice(1);
 		},
 		normalizeArray: (parts, allowAboveRoot) => {
-			let up = 0;
-			for (let i = parts.length - 1; i >= 0; i--) {
-				const last = parts[i];
+			var up = 0;
+			for (var i = parts.length - 1; i >= 0; i--) {
+				var last = parts[i];
 				if (last === ".") parts.splice(i, 1);
 				else if (last === "..") {
 					parts.splice(i, 1);
@@ -361,44 +296,34 @@ async function createRimeModule(moduleArg = {}) {
 			return parts;
 		},
 		normalize: (path) => {
-			const isAbsolute = PATH.isAbs(path);
-			const trailingSlash = path.slice(-1) === "/";
+			var isAbsolute = PATH.isAbs(path), 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];
+			var result = PATH.splitPath(path), root = result[0], dir = result[1];
 			if (!root && !dir) return ".";
 			if (dir) dir = dir.slice(0, -1);
 			return root + dir;
 		},
-		basename: (path) => path && path.match(/([^/]+|\/)\/*$/)[1],
+		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);
+		join2: (l, r) => PATH.normalize(l + "/" + r)
 	};
-	let randomFill = (view) => {
+	var initRandomFill = () => (view) => crypto.getRandomValues(view);
+	var 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();
+			var resolvedPath = "", resolvedAbsolute = false;
+			for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+				var 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}`;
+				resolvedPath = path + "/" + resolvedPath;
 				resolvedAbsolute = PATH.isAbs(path);
 			}
 			resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
@@ -408,44 +333,44 @@ async function createRimeModule(moduleArg = {}) {
 			from = PATH_FS.resolve(from).slice(1);
 			to = PATH_FS.resolve(to).slice(1);
 			function trim(arr) {
-				let start = 0;
+				var start = 0;
 				for (; start < arr.length; start++) if (arr[start] !== "") break;
-				let end = arr.length - 1;
+				var 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;
+			var fromParts = trim(from.split("/"));
+			var toParts = trim(to.split("/"));
+			var length = Math.min(fromParts.length, toParts.length);
+			var samePartsLength = length;
 			for (var i = 0; i < length; i++) if (fromParts[i] !== toParts[i]) {
 				samePartsLength = i;
 				break;
 			}
-			let outputParts = [];
+			var 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;
+	var UTF8Decoder = new TextDecoder();
+	var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+		var maxIdx = idx + maxBytesToRead;
 		if (ignoreNul) return maxIdx;
 		while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
 		return idx;
 	};
-	const UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+	var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
 		idx >>>= 0;
-		const endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+		var 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);
+	var FS_stdin_getChar_buffer = [];
+	var lengthBytesUTF8 = (str) => {
+		var len = 0;
+		for (var i = 0; i < str.length; ++i) {
+			var c = str.charCodeAt(i);
 			if (c <= 127) len++;
 			else if (c <= 2047) len += 2;
 			else if (c >= 55296 && c <= 57343) {
@@ -455,13 +380,13 @@ async function createRimeModule(moduleArg = {}) {
 		}
 		return len;
 	};
-	const stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+	var 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);
+		var startIdx = outIdx;
+		var endIdx = outIdx + maxBytesToWrite - 1;
+		for (var i = 0; i < str.length; ++i) {
+			var u = str.codePointAt(i);
 			if (u <= 127) {
 				if (outIdx >= endIdx) break;
 				heap[outIdx++ >>> 0] = u;
@@ -486,29 +411,17 @@ async function createRimeModule(moduleArg = {}) {
 		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);
+	var intArrayFromString = (stringy, dontAddNull, length) => {
+		var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+		var u8array = new Array(len);
+		var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
 		if (dontAddNull) u8array.length = numBytesWritten;
 		return u8array;
 	};
-	const FS_stdin_getChar = () => {
+	var 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) {
+			var result = null;
+			if (globalThis.window?.prompt) {
 				result = window.prompt("Input: ");
 				if (result !== null) result += "\n";
 			}
@@ -531,7 +444,7 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		stream_ops: {
 			open(stream) {
-				const tty = TTY.ttys[stream.node.rdev];
+				var tty = TTY.ttys[stream.node.rdev];
 				if (!tty) throw new FS.ErrnoError(43);
 				stream.tty = tty;
 				stream.seekable = false;
@@ -544,8 +457,8 @@ async function createRimeModule(moduleArg = {}) {
 			},
 			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 bytesRead = 0;
+				for (var i = 0; i < length; i++) {
 					var result;
 					try {
 						result = stream.tty.ops.get_char(stream.tty);
@@ -651,11 +564,11 @@ async function createRimeModule(moduleArg = {}) {
 			}
 		}
 	};
-	const zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
-	const alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
-	const mmapAlloc = (size) => {
+	var zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
+	var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+	var mmapAlloc = (size) => {
 		size = alignMemory(size, 65536);
-		const ptr = _emscripten_builtin_memalign(65536, size);
+		var ptr = _emscripten_builtin_memalign(65536, size);
 		if (ptr) zeroMemory(ptr, size);
 		return ptr;
 	};
@@ -710,7 +623,7 @@ async function createRimeModule(moduleArg = {}) {
 					stream: FS.chrdev_stream_ops
 				}
 			};
-			const node = FS.createNode(parent, name, mode, dev);
+			var 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;
@@ -740,12 +653,11 @@ async function createRimeModule(moduleArg = {}) {
 			return new Uint8Array(node.contents);
 		},
 		expandFileStorage(node, newCapacity) {
-			const prevCapacity = node.contents ? node.contents.length : 0;
+			var 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);
+			newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < 1024 * 1024 ? 2 : 1.125) >>> 0);
 			if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
-			const oldContents = node.contents;
+			var oldContents = node.contents;
 			node.contents = new Uint8Array(newCapacity);
 			if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
 		},
@@ -755,7 +667,7 @@ async function createRimeModule(moduleArg = {}) {
 				node.contents = null;
 				node.usedBytes = 0;
 			} else {
-				const oldContents = node.contents;
+				var oldContents = node.contents;
 				node.contents = new Uint8Array(newSize);
 				if (oldContents) node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
 				node.usedBytes = newSize;
@@ -763,7 +675,7 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		node_ops: {
 			getattr(node) {
-				const attr = {};
+				var attr = {};
 				attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
 				attr.ino = node.id;
 				attr.mode = node.mode;
@@ -802,12 +714,12 @@ async function createRimeModule(moduleArg = {}) {
 				return MEMFS.createNode(parent, name, mode, dev);
 			},
 			rename(old_node, new_dir, new_name) {
-				let new_node;
+				var 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);
+					if (FS.isDir(old_node.mode)) for (var i in new_node.contents) throw new FS.ErrnoError(55);
 					FS.hashRemoveNode(new_node);
 				}
 				delete old_node.parent.contents[old_node.name];
@@ -820,8 +732,7 @@ async function createRimeModule(moduleArg = {}) {
 				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);
+				for (var i in FS.lookupNode(parent, name).contents) throw new FS.ErrnoError(55);
 				delete parent.contents[name];
 				parent.ctime = parent.mtime = Date.now();
 			},
@@ -833,7 +744,7 @@ async function createRimeModule(moduleArg = {}) {
 				];
 			},
 			symlink(parent, newname, oldpath) {
-				const node = MEMFS.createNode(parent, newname, 41471, 0);
+				var node = MEMFS.createNode(parent, newname, 41471, 0);
 				node.link = oldpath;
 				return node;
 			},
@@ -844,17 +755,17 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		stream_ops: {
 			read(stream, buffer, offset, length, position) {
-				const contents = stream.node.contents;
+				var contents = stream.node.contents;
 				if (position >= stream.node.usedBytes) return 0;
-				const size = Math.min(stream.node.usedBytes - position, length);
+				var 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];
+				else for (var 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;
+				var node = stream.node;
 				node.mtime = node.ctime = Date.now();
 				if (buffer.subarray && (!node.contents || node.contents.subarray)) {
 					if (canOwn) {
@@ -872,12 +783,12 @@ async function createRimeModule(moduleArg = {}) {
 				}
 				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];
+				else for (var 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;
+				var position = offset;
 				if (whence === 1) position += stream.position;
 				else if (whence === 2) {
 					if (FS.isFile(stream.node.mode)) position += stream.node.usedBytes;
@@ -887,9 +798,9 @@ async function createRimeModule(moduleArg = {}) {
 			},
 			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;
+				var ptr;
+				var allocated;
+				var contents = stream.node.contents;
 				if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
 					allocated = false;
 					ptr = contents.byteOffset;
@@ -914,21 +825,20 @@ async function createRimeModule(moduleArg = {}) {
 			}
 		}
 	};
-	const FS_modeStringToFlags = (str) => {
-		const flagModes = {
-			"r": 0,
+	var FS_modeStringToFlags = (str) => {
+		var flags = {
+			r: 0,
 			"r+": 2,
-			"w": 577,
+			w: 577,
 			"w+": 578,
-			"a": 1089,
+			a: 1089,
 			"a+": 1090
-		};
-		const flags = flagModes[str];
-		if (typeof flags == "undefined") throw new TypeError(`Unknown file open mode: ${str}`);
+		}[str];
+		if (typeof flags == "undefined") throw new Error(`Unknown file open mode: ${str}`);
 		return flags;
 	};
-	const FS_getMode = (canRead, canWrite) => {
-		let mode = 0;
+	var FS_getMode = (canRead, canWrite) => {
+		var mode = 0;
 		if (canRead) mode |= 365;
 		if (canWrite) mode |= 146;
 		return mode;
@@ -951,13 +861,13 @@ async function createRimeModule(moduleArg = {}) {
 			else if (mount.idbPersistState === "idb") mount.idbPersistState = "again";
 		},
 		mount: (mount) => {
-			const mnt = MEMFS.mount(mount);
+			var mnt = MEMFS.mount(mount);
 			if (mount?.opts?.autoPersist) {
 				mount.idbPersistState = 0;
-				const memfs_node_ops = mnt.node_ops;
+				var 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);
+					var 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;
@@ -967,7 +877,7 @@ async function createRimeModule(moduleArg = {}) {
 						return node.memfs_stream_ops.write(stream, buffer, offset, length, position, canOwn);
 					};
 					node.stream_ops.close = (stream) => {
-						const n = stream.node;
+						var n = stream.node;
 						if (n.isModified) {
 							IDBFS.queuePersist(n.idbfs_mount);
 							n.isModified = false;
@@ -985,24 +895,24 @@ async function createRimeModule(moduleArg = {}) {
 			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.getLocalSet(mount, (err, local) => {
+				if (err) return callback(err);
+				IDBFS.getRemoteSet(mount, (err, remote) => {
+					if (err) return callback(err);
+					var src = populate ? remote : local;
+					var dst = populate ? local : remote;
 					IDBFS.reconcile(src, dst, callback);
 				});
 			});
 		},
 		quit: () => {
-			for (const value of Object.values(IDBFS.dbs)) value.close();
+			for (var value of Object.values(IDBFS.dbs)) value.close();
 			IDBFS.dbs = {};
 		},
 		getDB: (name, callback) => {
-			let db = IDBFS.dbs[name];
+			var db = IDBFS.dbs[name];
 			if (db) return callback(null, db);
-			let req;
+			var req;
 			try {
 				req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
 			} catch (e) {
@@ -1010,11 +920,11 @@ async function createRimeModule(moduleArg = {}) {
 			}
 			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);
+				var db = e.target.result;
+				var transaction = e.target.transaction;
+				var fileStore;
+				if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+				else fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
 				if (!fileStore.indexNames.contains("timestamp")) fileStore.createIndex("timestamp", "timestamp", { unique: false });
 			};
 			req.onsuccess = () => {
@@ -1028,16 +938,16 @@ async function createRimeModule(moduleArg = {}) {
 			};
 		},
 		getLocalSet: (mount, callback) => {
-			const entries = {};
+			var 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));
+			var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
 			while (check.length) {
-				const path = check.pop();
+				var path = check.pop();
 				var stat;
 				try {
 					stat = FS.stat(path);
@@ -1053,19 +963,18 @@ async function createRimeModule(moduleArg = {}) {
 			});
 		},
 		getRemoteSet: (mount, callback) => {
-			const entries = {};
-			IDBFS.getDB(mount.mountpoint, (err$1, db) => {
-				if (err$1) return callback(err$1);
+			var entries = {};
+			IDBFS.getDB(mount.mountpoint, (err, db) => {
+				if (err) return callback(err);
 				try {
-					const transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
+					var 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");
+					var index = transaction.objectStore(IDBFS.DB_STORE_NAME).index("timestamp");
 					index.openKeyCursor().onsuccess = (event) => {
-						const cursor = event.target.result;
+						var cursor = event.target.result;
 						if (!cursor) return callback(null, {
 							type: "remote",
 							db,
@@ -1080,10 +989,9 @@ async function createRimeModule(moduleArg = {}) {
 			});
 		},
 		loadLocalEntry: (path, callback) => {
-			let stat, node;
+			var stat, node;
 			try {
-				const lookup = FS.lookupPath(path);
-				node = lookup.node;
+				node = FS.lookupPath(path).node;
 				stat = FS.stat(path);
 			} catch (e) {
 				return callback(e);
@@ -1099,15 +1007,15 @@ async function createRimeModule(moduleArg = {}) {
 					mode: stat.mode,
 					contents: node.contents
 				});
-			} else return callback(new Error("node type not supported"));
+			} else return callback(/* @__PURE__ */ 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);
+				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(/* @__PURE__ */ new Error("node type not supported"));
+				FS.chmod(path, entry["mode"]);
+				FS.utime(path, entry["timestamp"], entry["timestamp"]);
 			} catch (e) {
 				return callback(e);
 			}
@@ -1115,7 +1023,7 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		removeLocalEntry: (path, callback) => {
 			try {
-				const stat = FS.stat(path);
+				var stat = FS.stat(path);
 				if (FS.isDir(stat.mode)) FS.rmdir(path);
 				else if (FS.isFile(stat.mode)) FS.unlink(path);
 			} catch (e) {
@@ -1124,7 +1032,7 @@ async function createRimeModule(moduleArg = {}) {
 			callback(null);
 		},
 		loadRemoteEntry: (store, path, callback) => {
-			const req = store.get(path);
+			var req = store.get(path);
 			req.onsuccess = (event) => callback(null, event.target.result);
 			req.onerror = (e) => {
 				callback(e.target.error);
@@ -1145,7 +1053,7 @@ async function createRimeModule(moduleArg = {}) {
 			};
 		},
 		removeRemoteEntry: (store, path, callback) => {
-			const req = store.delete(path);
+			var req = store.delete(path);
 			req.onsuccess = (event) => callback();
 			req.onerror = (e) => {
 				callback(e.target.error);
@@ -1153,85 +1061,84 @@ async function createRimeModule(moduleArg = {}) {
 			};
 		},
 		reconcile: (src, dst, callback) => {
-			let total = 0;
-			const create = [];
+			var total = 0;
+			var create = [];
 			for (var [key, e] of Object.entries(src.entries)) {
-				const e2 = dst.entries[key];
-				if (!e2 || e.timestamp.getTime() != e2.timestamp.getTime()) {
+				var e2 = dst.entries[key];
+				if (!e2 || e["timestamp"].getTime() != e2["timestamp"].getTime()) {
 					create.push(key);
 					total++;
 				}
 			}
-			const remove = [];
+			var 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) {
+			var errored = false;
+			var transaction = (src.type === "remote" ? src.db : dst.db).transaction([IDBFS.DB_STORE_NAME], "readwrite");
+			var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+			function done(err) {
+				if (err && !errored) {
 					errored = true;
-					return callback(err$1);
+					return callback(err);
 				}
 			}
-			transaction.onerror = transaction.onabort = (e$1) => {
-				done(e$1.target.error);
-				e$1.preventDefault();
+			transaction.onerror = transaction.onabort = (e) => {
+				done(e.target.error);
+				e.preventDefault();
 			};
-			transaction.oncomplete = (e$1) => {
+			transaction.oncomplete = (e) => {
 				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);
+			for (const path of create.sort()) if (dst.type === "local") IDBFS.loadRemoteEntry(store, path, (err, entry) => {
+				if (err) return done(err);
 				IDBFS.storeLocalEntry(path, entry, done);
 			});
-			else IDBFS.loadLocalEntry(path, (err$1, entry) => {
-				if (err$1) return done(err$1);
+			else IDBFS.loadLocalEntry(path, (err, entry) => {
+				if (err) return done(err);
 				IDBFS.storeRemoteEntry(store, path, entry, done);
 			});
-			for (const path of remove.sort().reverse()) if (dst.type === "local") IDBFS.removeLocalEntry(path, done);
+			for (var 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);
+	var asyncLoad = async (url) => {
+		var 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) => {
+	var FS_createDataFile = (...args) => FS.createDataFile(...args);
+	var getUniqueRunDependency = (id) => id;
+	var runDependencies = 0;
+	var dependenciesFulfilled = null;
+	var removeRunDependency = (id) => {
 		runDependencies--;
-		Module.monitorRunDependencies?.(runDependencies);
+		Module["monitorRunDependencies"]?.(runDependencies);
 		if (runDependencies == 0) {
 			if (dependenciesFulfilled) {
-				const callback = dependenciesFulfilled;
+				var callback = dependenciesFulfilled;
 				dependenciesFulfilled = null;
 				callback();
 			}
 		}
 	};
-	const addRunDependency = (id) => {
+	var addRunDependency = (id) => {
 		runDependencies++;
-		Module.monitorRunDependencies?.(runDependencies);
+		Module["monitorRunDependencies"]?.(runDependencies);
 	};
-	let preloadPlugins = [];
-	const FS_handledByPreloadPlugin = async (byteArray, fullname) => {
+	var preloadPlugins = [];
+	var 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);
+		for (var 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}`);
+	var FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
+		var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+		var dep = getUniqueRunDependency(`cp ${fullname}`);
 		addRunDependency(dep);
 		try {
-			let byteArray = url;
+			var byteArray = url;
 			if (typeof url == "string") byteArray = await asyncLoad(url);
 			byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
 			preFinish?.();
@@ -1240,7 +1147,7 @@ async function createRimeModule(moduleArg = {}) {
 			removeRunDependency(dep);
 		}
 	};
-	const FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+	var 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 = {
@@ -1329,19 +1236,19 @@ async function createRimeModule(moduleArg = {}) {
 		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 (!PATH.isAbs(path)) path = FS.cwd() + "/" + path;
+			linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
+				var parts = path.split("/").filter((p) => !!p);
+				var current = FS.root;
+				var current_path = "/";
+				for (var i = 0; i < parts.length; i++) {
+					var 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("/")}`;
+							path = current_path + "/" + parts.slice(i + 1).join("/");
 							nlinks--;
 							continue linkloop;
 						} else current = current.parent;
@@ -1357,9 +1264,9 @@ async function createRimeModule(moduleArg = {}) {
 					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("/")}`;
+						var 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;
 					}
 				}
@@ -1371,10 +1278,10 @@ async function createRimeModule(moduleArg = {}) {
 			throw new FS.ErrnoError(32);
 		},
 		getPath(node) {
-			let path;
+			var path;
 			while (true) {
 				if (FS.isRoot(node)) {
-					const mount = node.mount.mountpoint;
+					var mount = node.mount.mountpoint;
 					if (!path) return mount;
 					return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
 				}
@@ -1383,20 +1290,20 @@ async function createRimeModule(moduleArg = {}) {
 			}
 		},
 		hashName(parentid, name) {
-			let hash = 0;
-			for (let i = 0; i < name.length; i++) hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+			var hash = 0;
+			for (var 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);
+			var 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);
+			var 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];
+				var current = FS.nameTable[hash];
 				while (current) {
 					if (current.name_next === node) {
 						current.name_next = node.name_next;
@@ -1407,17 +1314,17 @@ async function createRimeModule(moduleArg = {}) {
 			}
 		},
 		lookupNode(parent, name) {
-			const errCode = FS.mayLookup(parent);
+			var 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;
+			var hash = FS.hashName(parent.id, name);
+			for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+				var 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);
+			var node = new FS.FSNode(parent, name, mode, rdev);
 			FS.hashAddNode(node);
 			return node;
 		},
@@ -1452,7 +1359,7 @@ async function createRimeModule(moduleArg = {}) {
 			return (mode & 49152) === 49152;
 		},
 		flagsToPermissionString(flag) {
-			let perms = [
+			var perms = [
 				"r",
 				"w",
 				"rw"
@@ -1469,7 +1376,7 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		mayLookup(dir) {
 			if (!FS.isDir(dir.mode)) return 54;
-			const errCode = FS.nodePermissions(dir, "x");
+			var errCode = FS.nodePermissions(dir, "x");
 			if (errCode) return errCode;
 			if (!dir.node_ops.lookup) return 2;
 			return 0;
@@ -1477,19 +1384,19 @@ async function createRimeModule(moduleArg = {}) {
 		mayCreate(dir, name) {
 			if (!FS.isDir(dir.mode)) return 54;
 			try {
-				const node = FS.lookupNode(dir, name);
+				FS.lookupNode(dir, name);
 				return 20;
 			} catch (e) {}
 			return FS.nodePermissions(dir, "wx");
 		},
 		mayDelete(dir, name, isdir) {
-			let node;
+			var node;
 			try {
 				node = FS.lookupNode(dir, name);
 			} catch (e) {
 				return e.errno;
 			}
-			const errCode = FS.nodePermissions(dir, "wx");
+			var errCode = FS.nodePermissions(dir, "wx");
 			if (errCode) return errCode;
 			if (isdir) {
 				if (!FS.isDir(node.mode)) return 54;
@@ -1500,23 +1407,23 @@ async function createRimeModule(moduleArg = {}) {
 		mayOpen(node, flags) {
 			if (!node) return 44;
 			if (FS.isLink(node.mode)) return 32;
-			const mode = FS.flagsToPermissionString(flags);
+			var 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);
+		checkOpExists(op, err) {
+			if (!op) throw new FS.ErrnoError(err);
 			return op;
 		},
 		MAX_OPEN_FDS: 4096,
 		nextfd() {
-			for (let fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) if (!FS.streams[fd]) return fd;
+			for (var 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);
+			var stream = FS.getStream(fd);
 			if (!stream) throw new FS.ErrnoError(8);
 			return stream;
 		},
@@ -1532,21 +1439,20 @@ async function createRimeModule(moduleArg = {}) {
 			FS.streams[fd] = null;
 		},
 		dupStream(origStream, fd = -1) {
-			const stream = FS.createStream(origStream, fd);
+			var 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;
+			var setattr = stream?.stream_ops.setattr;
+			var 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 = FS.getDevice(stream.node.rdev).stream_ops;
 				stream.stream_ops.open?.(stream);
 			},
 			llseek() {
@@ -1561,10 +1467,10 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		getDevice: (dev) => FS.devices[dev],
 		getMounts(mount) {
-			const mounts = [];
-			const check = [mount];
+			var mounts = [];
+			var check = [mount];
 			while (check.length) {
-				const m = check.pop();
+				var m = check.pop();
 				mounts.push(m);
 				check.push(...m.mounts);
 			}
@@ -1577,8 +1483,8 @@ async function createRimeModule(moduleArg = {}) {
 			}
 			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;
+			var mounts = FS.getMounts(FS.root.mount);
+			var completed = 0;
 			function doCallback(errCode) {
 				FS.syncFSRequests--;
 				return callback(errCode);
@@ -1593,28 +1499,28 @@ async function createRimeModule(moduleArg = {}) {
 				}
 				if (++completed >= mounts.length) doCallback(null);
 			}
-			for (const mount of mounts) if (mount.type.syncfs) mount.type.syncfs(mount, populate, done);
+			for (var 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;
+			var root = mountpoint === "/";
+			var pseudo = !mountpoint;
+			var node;
 			if (root && FS.root) throw new FS.ErrnoError(10);
 			else if (!root && !pseudo) {
-				const lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+				var 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 = {
+			var mount = {
 				type,
 				opts,
 				mountpoint,
 				mounts: []
 			};
-			const mountRoot = type.mount(mount);
+			var mountRoot = type.mount(mount);
 			mountRoot.mount = mount;
 			mount.root = mountRoot;
 			if (root) FS.root = mountRoot;
@@ -1625,30 +1531,29 @@ async function createRimeModule(moduleArg = {}) {
 			return mountRoot;
 		},
 		unmount(mountpoint) {
-			const lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+			var 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;
+			var node = lookup.node;
+			var mount = node.mounted;
+			var mounts = FS.getMounts(mount);
+			for (var [hash, current] of Object.entries(FS.nameTable)) while (current) {
+				var next = current.name_next;
 				if (mounts.includes(current.mount)) FS.destroyNode(current);
 				current = next;
 			}
 			node.mounted = null;
-			const idx = node.mount.mounts.indexOf(mount);
+			var 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);
+			var parent = FS.lookupPath(path, { parent: true }).node;
+			var 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);
+			var 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);
@@ -1660,7 +1565,7 @@ async function createRimeModule(moduleArg = {}) {
 			return FS.statfsNode(stream.node);
 		},
 		statfsNode(node) {
-			const rtn = {
+			var rtn = {
 				bsize: 4096,
 				frsize: 4096,
 				blocks: 1e6,
@@ -1686,9 +1591,9 @@ async function createRimeModule(moduleArg = {}) {
 			return FS.mknod(path, mode, 0);
 		},
 		mkdirTree(path, mode) {
-			const dirs = path.split("/");
-			let d = "";
-			for (const dir of dirs) {
+			var dirs = path.split("/");
+			var d = "";
+			for (var dir of dirs) {
 				if (!dir) continue;
 				if (d || PATH.isAbs(path)) d += "/";
 				d += dir;
@@ -1709,39 +1614,36 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		symlink(oldpath, newpath) {
 			if (!PATH_FS.resolve(oldpath)) throw new FS.ErrnoError(44);
-			const lookup = FS.lookupPath(newpath, { parent: true });
-			const parent = lookup.node;
+			var parent = FS.lookupPath(newpath, { parent: true }).node;
 			if (!parent) throw new FS.ErrnoError(44);
-			const newname = PATH.basename(newpath);
-			const errCode = FS.mayCreate(parent, newname);
+			var newname = PATH.basename(newpath);
+			var 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;
+			var old_dirname = PATH.dirname(old_path);
+			var new_dirname = PATH.dirname(new_path);
+			var old_name = PATH.basename(old_path);
+			var new_name = PATH.basename(new_path);
+			var lookup = FS.lookupPath(old_path, { parent: true }), old_dir = lookup.node, new_dir;
 			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);
+			var old_node = FS.lookupNode(old_dir, old_name);
+			var 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;
+			var 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);
+			var isdir = FS.isDir(old_node.mode);
+			var 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);
@@ -1762,11 +1664,10 @@ async function createRimeModule(moduleArg = {}) {
 			}
 		},
 		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);
+			var parent = FS.lookupPath(path, { parent: true }).node;
+			var name = PATH.basename(path);
+			var node = FS.lookupNode(parent, name);
+			var 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);
@@ -1774,18 +1675,15 @@ async function createRimeModule(moduleArg = {}) {
 			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);
+			var node = FS.lookupPath(path, { follow: true }).node;
+			return FS.checkOpExists(node.node_ops.readdir, 54)(node);
 		},
 		unlink(path) {
-			const lookup = FS.lookupPath(path, { parent: true });
-			const parent = lookup.node;
+			var parent = FS.lookupPath(path, { parent: true }).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);
+			var name = PATH.basename(path);
+			var node = FS.lookupNode(parent, name);
+			var 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);
@@ -1793,23 +1691,20 @@ async function createRimeModule(moduleArg = {}) {
 			FS.destroyNode(node);
 		},
 		readlink(path) {
-			const lookup = FS.lookupPath(path);
-			const link = lookup.node;
+			var link = FS.lookupPath(path).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);
+			var node = FS.lookupPath(path, { follow: !dontFollow }).node;
+			return FS.checkOpExists(node.node_ops.getattr, 63)(node);
 		},
 		fstat(fd) {
-			const stream = FS.getStreamChecked(fd);
-			const node = stream.node;
-			let getattr = stream.stream_ops.getattr;
-			const arg = getattr ? stream : node;
+			var stream = FS.getStreamChecked(fd);
+			var node = stream.node;
+			var getattr = stream.stream_ops.getattr;
+			var arg = getattr ? stream : node;
 			getattr ??= node.node_ops.getattr;
 			FS.checkOpExists(getattr, 63);
 			return getattr(arg);
@@ -1825,18 +1720,16 @@ async function createRimeModule(moduleArg = {}) {
 			});
 		},
 		chmod(path, mode, dontFollow) {
-			let node;
-			if (typeof path == "string") {
-				const lookup = FS.lookupPath(path, { follow: !dontFollow });
-				node = lookup.node;
-			} else node = path;
+			var node;
+			if (typeof path == "string") node = FS.lookupPath(path, { follow: !dontFollow }).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);
+			var stream = FS.getStreamChecked(fd);
 			FS.doChmod(stream, stream.node, mode, false);
 		},
 		doChown(stream, node, dontFollow) {
@@ -1846,24 +1739,22 @@ async function createRimeModule(moduleArg = {}) {
 			});
 		},
 		chown(path, uid, gid, dontFollow) {
-			let node;
-			if (typeof path == "string") {
-				const lookup = FS.lookupPath(path, { follow: !dontFollow });
-				node = lookup.node;
-			} else node = path;
+			var node;
+			if (typeof path == "string") node = FS.lookupPath(path, { follow: !dontFollow }).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);
+			var 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");
+			var errCode = FS.nodePermissions(node, "w");
 			if (errCode) throw new FS.ErrnoError(errCode);
 			FS.doSetAttr(stream, node, {
 				size: len,
@@ -1872,23 +1763,19 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		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;
+			var node;
+			if (typeof path == "string") node = FS.lookupPath(path, { follow: true }).node;
+			else node = path;
 			FS.doTruncate(null, node, len);
 		},
 		ftruncate(fd, len) {
-			const stream = FS.getStreamChecked(fd);
+			var 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, {
+			var node = FS.lookupPath(path, { follow: true }).node;
+			FS.checkOpExists(node.node_ops.setattr, 63)(node, {
 				atime,
 				mtime
 			});
@@ -1898,19 +1785,19 @@ async function createRimeModule(moduleArg = {}) {
 			flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
 			if (flags & 64) mode = mode & 4095 | 32768;
 			else mode = 0;
-			let node;
-			let isDirPath;
+			var node;
+			var isDirPath;
 			if (typeof path == "object") node = path;
 			else {
 				isDirPath = path.endsWith("/");
-				const lookup = FS.lookupPath(path, {
+				var lookup = FS.lookupPath(path, {
 					follow: !(flags & 131072),
 					noent_okay: true
 				});
 				node = lookup.node;
 				path = lookup.path;
 			}
-			let created = false;
+			var created = false;
 			if (flags & 64) if (node) {
 				if (flags & 128) throw new FS.ErrnoError(20);
 			} else if (isDirPath) throw new FS.ErrnoError(31);
@@ -1922,12 +1809,12 @@ async function createRimeModule(moduleArg = {}) {
 			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);
+				var 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({
+			var stream = FS.createStream({
 				node,
 				path: FS.getPath(node),
 				flags,
@@ -1970,10 +1857,10 @@ async function createRimeModule(moduleArg = {}) {
 			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";
+			var 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);
+			var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
 			if (!seeking) stream.position += bytesRead;
 			return bytesRead;
 		},
@@ -1984,10 +1871,10 @@ async function createRimeModule(moduleArg = {}) {
 			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";
+			var 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);
+			var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
 			if (!seeking) stream.position += bytesWritten;
 			return bytesWritten;
 		},
@@ -2010,10 +1897,9 @@ async function createRimeModule(moduleArg = {}) {
 			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);
+			var stream = FS.open(path, opts.flags);
+			var length = FS.stat(path).size;
+			var buf = new Uint8Array(length);
 			FS.read(stream, buf, 0, length, 0);
 			if (opts.encoding === "utf8") buf = UTF8ArrayToString(buf);
 			FS.close(stream);
@@ -2021,7 +1907,7 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		writeFile(path, data, opts = {}) {
 			opts.flags = opts.flags || 577;
-			const stream = FS.open(path, opts.flags, opts.mode);
+			var 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");
@@ -2029,10 +1915,10 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		cwd: () => FS.currentPath,
 		chdir(path) {
-			const lookup = FS.lookupPath(path, { follow: true });
+			var 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");
+			var errCode = FS.nodePermissions(lookup.node, "x");
 			if (errCode) throw new FS.ErrnoError(errCode);
 			FS.currentPath = lookup.path;
 		},
@@ -2053,9 +1939,8 @@ async function createRimeModule(moduleArg = {}) {
 			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 = () => {
+			var randomBuffer = new Uint8Array(1024), randomLeft = 0;
+			var randomByte = () => {
 				if (randomLeft === 0) {
 					randomFill(randomBuffer);
 					randomLeft = randomBuffer.byteLength;
@@ -2069,16 +1954,16 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		createSpecialDirectories() {
 			FS.mkdir("/proc");
-			const proc_self = FS.mkdir("/proc/self");
+			var proc_self = FS.mkdir("/proc/self");
 			FS.mkdir("/proc/self/fd");
 			FS.mount({ mount() {
-				const node = FS.createNode(proc_self, "fd", 16895, 73);
+				var 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 = {
+						var fd = +name;
+						var stream = FS.getStreamChecked(fd);
+						var ret = {
 							parent: null,
 							mount: { mountpoint: "fake" },
 							node_ops: { readlink: () => stream.path },
@@ -2101,12 +1986,12 @@ async function createRimeModule(moduleArg = {}) {
 			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);
+			FS.open("/dev/stdin", 0);
+			FS.open("/dev/stdout", 1);
+			FS.open("/dev/stderr", 1);
 		},
 		staticInit() {
-			FS.nameTable = Array.from({ length: 4096 });
+			FS.nameTable = new Array(4096);
 			FS.mount(MEMFS, {}, "/");
 			FS.createDefaultDirectories();
 			FS.createDefaultDevices();
@@ -2118,17 +2003,17 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		init(input, output, error) {
 			FS.initialized = true;
-			input ??= Module.stdin;
-			output ??= Module.stdout;
-			error ??= Module.stderr;
+			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);
+			for (var stream of FS.streams) if (stream) FS.close(stream);
 		},
 		findObject(path, dontResolveLastLink) {
-			const ret = FS.analyzePath(path, dontResolveLastLink);
+			var ret = FS.analyzePath(path, dontResolveLastLink);
 			if (!ret.exists) return null;
 			return ret.object;
 		},
@@ -2137,7 +2022,7 @@ async function createRimeModule(moduleArg = {}) {
 				var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
 				path = lookup.path;
 			} catch (e) {}
-			const ret = {
+			var ret = {
 				isRoot: false,
 				exists: false,
 				error: 0,
@@ -2167,9 +2052,9 @@ async function createRimeModule(moduleArg = {}) {
 		},
 		createPath(parent, path, canRead, canWrite) {
 			parent = typeof parent == "string" ? parent : FS.getPath(parent);
-			const parts = path.split("/").reverse();
+			var parts = path.split("/").reverse();
 			while (parts.length) {
-				const part = parts.pop();
+				var part = parts.pop();
 				if (!part) continue;
 				var current = PATH.join2(parent, part);
 				try {
@@ -2182,36 +2067,36 @@ async function createRimeModule(moduleArg = {}) {
 			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);
+			var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+			var mode = FS_getMode(canRead, canWrite);
 			return FS.create(path, mode);
 		},
 		createDataFile(parent, name, data, canRead, canWrite, canOwn) {
-			let path = name;
+			var 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);
+			var mode = FS_getMode(canRead, canWrite);
+			var 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);
+					var arr = new Array(data.length);
+					for (var 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);
+				var 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);
+			var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+			var mode = FS_getMode(!!input, !!output);
 			FS.createDevice.major ??= 64;
-			const dev = FS.makedev(FS.createDevice.major++, 0);
+			var dev = FS.makedev(FS.createDevice.major++, 0);
 			FS.registerDevice(dev, {
 				open(stream) {
 					stream.seekable = false;
@@ -2220,8 +2105,8 @@ async function createRimeModule(moduleArg = {}) {
 					if (output?.buffer?.length) output(10);
 				},
 				read(stream, buffer, offset, length, pos) {
-					let bytesRead = 0;
-					for (let i = 0; i < length; i++) {
+					var bytesRead = 0;
+					for (var i = 0; i < length; i++) {
 						var result;
 						try {
 							result = input();
@@ -2262,42 +2147,42 @@ async function createRimeModule(moduleArg = {}) {
 				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;
+					if (idx > this.length - 1 || idx < 0) return;
+					var chunkOffset = idx % this.chunkSize;
+					var chunkNum = idx / this.chunkSize | 0;
 					return this.getter(chunkNum)[chunkOffset];
 				}
 				setDataGetter(getter) {
 					this.getter = getter;
 				}
 				cacheLength() {
-					const xhr = new XMLHttpRequest();
+					var 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 (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr.status);
+					var datalength = Number(xhr.getResponseHeader("Content-length"));
+					var header;
+					var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+					var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
+					var 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);
+					var 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!");
+						var xhr = new XMLHttpRequest();
+						xhr.open("GET", url, false);
+						if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+						xhr.responseType = "arraybuffer";
+						if (xhr.overrideMimeType) xhr.overrideMimeType("text/plain; charset=x-user-defined");
+						xhr.send(null);
+						if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr.status);
+						if (xhr.response !== void 0) return new Uint8Array(xhr.response || []);
+						return intArrayFromString(xhr.responseText || "", true);
 					};
-					const lazyArray = this;
+					var lazyArray = this;
 					lazyArray.setDataGetter((chunkNum) => {
-						const start = chunkNum * chunkSize;
-						let end = (chunkNum + 1) * chunkSize - 1;
+						var start = chunkNum * chunkSize;
+						var 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!");
@@ -2324,33 +2209,32 @@ async function createRimeModule(moduleArg = {}) {
 			}
 			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
+					contents: new LazyUint8Array()
 				};
 			} else var properties = {
 				isDevice: false,
 				url
 			};
-			const node = FS.createFile(parent, name, properties, canRead, canWrite);
+			var 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() {
+			Object.defineProperties(node, { usedBytes: { get: function() {
 				return this.contents.length;
 			} } });
-			const stream_ops = {};
+			var 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;
+				var contents = stream.node.contents;
 				if (position >= contents.length) return 0;
-				const size = Math.min(contents.length - position, length);
+				var 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;
@@ -2361,7 +2245,7 @@ async function createRimeModule(moduleArg = {}) {
 			};
 			stream_ops.mmap = (stream, length, position, prot, flags) => {
 				FS.forceLoadFile(node);
-				const ptr = mmapAlloc(length);
+				var ptr = mmapAlloc(length);
 				if (!ptr) throw new FS.ErrnoError(48);
 				writeChunks(stream, HEAP8, ptr, length, position);
 				return {
@@ -2373,26 +2257,23 @@ async function createRimeModule(moduleArg = {}) {
 			return node;
 		}
 	};
-	const UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+	var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
 		ptr >>>= 0;
 		if (!ptr) return "";
-		const end = findStringEnd(HEAPU8, ptr, maxBytesToRead, ignoreNul);
+		var 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;
+			var dir;
 			if (dirfd === -100) dir = FS.cwd();
-			else {
-				const dirstream = SYSCALLS.getStreamFromFD(dirfd);
-				dir = dirstream.path;
-			}
+			else dir = SYSCALLS.getStreamFromFD(dirfd).path;
 			if (path.length == 0) {
 				if (!allowEmpty) throw new FS.ErrnoError(44);
 				return dir;
 			}
-			return `${dir}/${path}`;
+			return dir + "/" + path;
 		},
 		writeStat(buf, stat) {
 			HEAPU32[buf >>> 2 >>> 0] = stat.dev;
@@ -2404,9 +2285,9 @@ async function createRimeModule(moduleArg = {}) {
 			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();
+			var atime = stat.atime.getTime();
+			var mtime = stat.mtime.getTime();
+			var 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));
@@ -2431,22 +2312,20 @@ async function createRimeModule(moduleArg = {}) {
 		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);
+			var buffer = HEAPU8.slice(addr, addr + len);
 			FS.msync(stream, buffer, offset, len, flags);
 		},
 		getStreamFromFD(fd) {
-			const stream = FS.getStreamChecked(fd);
-			return stream;
+			return FS.getStreamChecked(fd);
 		},
 		varargs: void 0,
 		getStr(ptr) {
-			const ret = UTF8ToString(ptr);
-			return ret;
+			return UTF8ToString(ptr);
 		}
 	};
-	const INT53_MAX = 9007199254740992;
-	const INT53_MIN = -9007199254740992;
-	const bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? Number.NaN : Number(num);
+	var INT53_MAX = 9007199254740992;
+	var INT53_MIN = -9007199254740992;
+	var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
 	function ___syscall_chmod(path, mode) {
 		path >>>= 0;
 		try {
@@ -2464,10 +2343,9 @@ async function createRimeModule(moduleArg = {}) {
 			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;
+			var node = FS.lookupPath(path, { follow: true }).node;
 			if (!node) return -44;
-			let perms = "";
+			var perms = "";
 			if (amode & 4) perms += "r";
 			if (amode & 2) perms += "w";
 			if (amode & 1) perms += "x";
@@ -2487,40 +2365,35 @@ async function createRimeModule(moduleArg = {}) {
 			return -e.errno;
 		}
 	}
-	const syscallGetVarargI = () => {
-		const ret = HEAP32[+SYSCALLS.varargs >>> 2 >>> 0];
+	var syscallGetVarargI = () => {
+		var ret = HEAP32[+SYSCALLS.varargs >>> 2 >>> 0];
 		SYSCALLS.varargs += 4;
 		return ret;
 	};
-	const syscallGetVarargP = syscallGetVarargI;
+	var syscallGetVarargP = syscallGetVarargI;
 	function ___syscall_fcntl64(fd, cmd, varargs) {
 		varargs >>>= 0;
 		SYSCALLS.varargs = varargs;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			var stream = SYSCALLS.getStreamFromFD(fd);
 			switch (cmd) {
-				case 0: {
+				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;
-				}
+					return FS.dupStream(stream, arg).fd;
 				case 1:
 				case 2: return 0;
 				case 3: return stream.flags;
-				case 4: {
+				case 4:
 					var arg = syscallGetVarargI();
 					stream.flags |= arg;
 					return 0;
-				}
-				case 12: {
+				case 12:
 					var arg = syscallGetVarargP();
-					const offset = 0;
+					var offset = 0;
 					HEAP16[arg + offset >>> 1 >>> 0] = 2;
 					return 0;
-				}
 				case 13:
 				case 14: return 0;
 			}
@@ -2532,7 +2405,7 @@ async function createRimeModule(moduleArg = {}) {
 	}
 	function ___syscall_fdatasync(fd) {
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			SYSCALLS.getStreamFromFD(fd);
 			return 0;
 		} catch (e) {
 			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
@@ -2559,14 +2432,14 @@ async function createRimeModule(moduleArg = {}) {
 			return -e.errno;
 		}
 	}
-	const stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+	var 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;
+			var cwd = FS.cwd();
+			var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
 			if (size < cwdLengthInBytes) return -68;
 			stringToUTF8(cwd, buf, size);
 			return cwdLengthInBytes;
@@ -2579,23 +2452,22 @@ async function createRimeModule(moduleArg = {}) {
 		dirp >>>= 0;
 		count >>>= 0;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			var 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));
+			var struct_size = 280;
+			var pos = 0;
+			var off = FS.llseek(stream, 0, 1);
+			var startIdx = Math.floor(off / struct_size);
+			var 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];
+				var 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;
+					id = FS.lookupPath(stream.path, { parent: true }).node.id;
 					type = 4;
 				} else {
 					var child;
@@ -2626,16 +2498,15 @@ async function createRimeModule(moduleArg = {}) {
 		varargs >>>= 0;
 		SYSCALLS.varargs = varargs;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			var stream = SYSCALLS.getStreamFromFD(fd);
 			switch (op) {
-				case 21509: {
+				case 21509:
 					if (!stream.tty) return -59;
 					return 0;
-				}
-				case 21505: {
+				case 21505:
 					if (!stream.tty) return -59;
 					if (stream.tty.ops.ioctl_tcgets) {
-						const termios = stream.tty.ops.ioctl_tcgets(stream);
+						var 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;
@@ -2645,24 +2516,22 @@ async function createRimeModule(moduleArg = {}) {
 						return 0;
 					}
 					return 0;
-				}
 				case 21510:
 				case 21511:
-				case 21512: {
+				case 21512:
 					if (!stream.tty) return -59;
 					return 0;
-				}
 				case 21506:
 				case 21507:
-				case 21508: {
+				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 = [];
+						var c_iflag = HEAP32[argp >>> 2 >>> 0];
+						var c_oflag = HEAP32[argp + 4 >>> 2 >>> 0];
+						var c_cflag = HEAP32[argp + 8 >>> 2 >>> 0];
+						var c_lflag = HEAP32[argp + 12 >>> 2 >>> 0];
+						var 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,
@@ -2673,40 +2542,33 @@ async function createRimeModule(moduleArg = {}) {
 						});
 					}
 					return 0;
-				}
-				case 21519: {
+				case 21519:
 					if (!stream.tty) return -59;
 					var argp = syscallGetVarargP();
 					HEAP32[argp >>> 2 >>> 0] = 0;
 					return 0;
-				}
-				case 21520: {
+				case 21520:
 					if (!stream.tty) return -59;
 					return -28;
-				}
 				case 21537:
-				case 21531: {
+				case 21531:
 					var argp = syscallGetVarargP();
 					return FS.ioctl(stream, op, argp);
-				}
-				case 21523: {
+				case 21523:
 					if (!stream.tty) return -59;
 					if (stream.tty.ops.ioctl_tiocgwinsz) {
-						const winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+						var 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: {
+				case 21524:
 					if (!stream.tty) return -59;
 					return 0;
-				}
-				case 21515: {
+				case 21515:
 					if (!stream.tty) return -59;
 					return 0;
-				}
 				default: return -28;
 			}
 		} catch (e) {
@@ -2742,8 +2604,8 @@ async function createRimeModule(moduleArg = {}) {
 		buf >>>= 0;
 		try {
 			path = SYSCALLS.getStr(path);
-			const nofollow = flags & 256;
-			const allowEmpty = flags & 4096;
+			var nofollow = flags & 256;
+			var allowEmpty = flags & 4096;
 			flags = flags & -6401;
 			path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
 			return SYSCALLS.writeStat(buf, nofollow ? FS.lstat(path) : FS.stat(path));
@@ -2759,7 +2621,7 @@ async function createRimeModule(moduleArg = {}) {
 		try {
 			path = SYSCALLS.getStr(path);
 			path = SYSCALLS.calculateAt(dirfd, path);
-			const mode = varargs ? syscallGetVarargI() : 0;
+			var mode = varargs ? syscallGetVarargI() : 0;
 			return FS.open(path, flags, mode).fd;
 		} catch (e) {
 			if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
@@ -2774,9 +2636,9 @@ async function createRimeModule(moduleArg = {}) {
 			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];
+			var ret = FS.readlink(path);
+			var len = Math.min(bufsize, lengthBytesUTF8(ret));
+			var endChar = HEAP8[buf + len >>> 0];
 			stringToUTF8(ret, buf, bufsize + 1);
 			HEAP8[buf + len >>> 0] = endChar;
 			return len;
@@ -2849,14 +2711,14 @@ async function createRimeModule(moduleArg = {}) {
 			return -e.errno;
 		}
 	}
-	const __abort_js = () => abort("");
-	let runtimeKeepaliveCounter = 0;
-	const __emscripten_runtime_keepalive_clear = () => {
+	var __abort_js = () => abort("");
+	var runtimeKeepaliveCounter = 0;
+	var __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 = [
+	var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+	var MONTH_DAYS_LEAP_CUMULATIVE = [
 		0,
 		31,
 		60,
@@ -2870,7 +2732,7 @@ async function createRimeModule(moduleArg = {}) {
 		305,
 		335
 	];
-	const MONTH_DAYS_REGULAR_CUMULATIVE = [
+	var MONTH_DAYS_REGULAR_CUMULATIVE = [
 		0,
 		31,
 		59,
@@ -2884,16 +2746,13 @@ async function createRimeModule(moduleArg = {}) {
 		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;
+	var ydayFromDate = (date) => {
+		return (isLeapYear(date.getFullYear()) ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE)[date.getMonth()] + date.getDate() - 1;
 	};
 	function __localtime_js(time, tmPtr) {
 		time = bigintToI53Checked(time);
 		tmPtr >>>= 0;
-		const date = new Date(time * 1e3);
+		var date = /* @__PURE__ */ new Date(time * 1e3);
 		HEAP32[tmPtr >>> 2 >>> 0] = date.getSeconds();
 		HEAP32[tmPtr + 4 >>> 2 >>> 0] = date.getMinutes();
 		HEAP32[tmPtr + 8 >>> 2 >>> 0] = date.getHours();
@@ -2901,13 +2760,13 @@ async function createRimeModule(moduleArg = {}) {
 		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;
+		var 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;
+		var start = new Date(date.getFullYear(), 0, 1);
+		var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+		var winterOffset = start.getTimezoneOffset();
+		var 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) {
@@ -2916,9 +2775,9 @@ async function createRimeModule(moduleArg = {}) {
 		allocated >>>= 0;
 		addr >>>= 0;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
-			const res = FS.mmap(stream, len, offset, prot, flags);
-			const ptr = res.ptr;
+			var stream = SYSCALLS.getStreamFromFD(fd);
+			var res = FS.mmap(stream, len, offset, prot, flags);
+			var ptr = res.ptr;
 			HEAP32[allocated >>> 2 >>> 0] = res.allocated;
 			HEAPU32[addr >>> 2 >>> 0] = ptr;
 			return 0;
@@ -2932,40 +2791,40 @@ async function createRimeModule(moduleArg = {}) {
 		len >>>= 0;
 		offset = bigintToI53Checked(offset);
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			var 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) => {
+	var timers = {};
+	var handleException = (e) => {
 		if (e instanceof ExitStatus || e == "unwind") return EXITSTATUS;
 		quit_(1, e);
 	};
-	const keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
-	const _proc_exit = (code) => {
+	var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+	var _proc_exit = (code) => {
 		EXITSTATUS = code;
 		if (!keepRuntimeAlive()) {
-			Module.onExit?.(code);
+			Module["onExit"]?.(code);
 			ABORT = true;
 		}
 		quit_(code, new ExitStatus(code));
 	};
-	const exitJS = (status, implicit) => {
+	var exitJS = (status, implicit) => {
 		EXITSTATUS = status;
 		_proc_exit(status);
 	};
-	const _exit = exitJS;
-	const maybeExit = () => {
+	var _exit = exitJS;
+	var maybeExit = () => {
 		if (!keepRuntimeAlive()) try {
 			_exit(EXITSTATUS);
 		} catch (e) {
 			handleException(e);
 		}
 	};
-	const callUserCallback = (func) => {
+	var callUserCallback = (func) => {
 		if (ABORT) return;
 		try {
 			return func();
@@ -2975,45 +2834,42 @@ async function createRimeModule(moduleArg = {}) {
 			maybeExit();
 		}
 	};
-	const _emscripten_get_now = () => performance.now();
-	const __setitimer_js = (which, timeout_ms) => {
+	var _emscripten_get_now = () => performance.now();
+	var __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,
+			id: setTimeout(() => {
+				delete timers[which];
+				callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
+			}, timeout_ms),
 			timeout_ms
 		};
 		return 0;
 	};
-	const __tzset_js = function(timezone, daylight, std_name, dst_name) {
+	var __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);
+		var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+		var winter = new Date(currentYear, 0, 1);
+		var summer = new Date(currentYear, 6, 1);
+		var winterOffset = winter.getTimezoneOffset();
+		var summerOffset = summer.getTimezoneOffset();
+		var 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}`;
+		var extractZone = (timezoneOffset) => {
+			var sign = timezoneOffset >= 0 ? "-" : "+";
+			var absOffset = Math.abs(timezoneOffset);
+			return `UTC${sign}${String(Math.floor(absOffset / 60)).padStart(2, "0")}${String(absOffset % 60).padStart(2, "0")}`;
 		};
-		const winterName = extractZone(winterOffset);
-		const summerName = extractZone(summerOffset);
+		var winterName = extractZone(winterOffset);
+		var summerName = extractZone(summerOffset);
 		if (summerOffset < winterOffset) {
 			stringToUTF8(winterName, std_name, 17);
 			stringToUTF8(summerName, dst_name, 17);
@@ -3022,25 +2878,24 @@ async function createRimeModule(moduleArg = {}) {
 			stringToUTF8(summerName, std_name, 17);
 		}
 	};
-	const _emscripten_date_now = () => Date.now();
-	const nowIsMonotonic = 1;
-	const checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+	var _emscripten_date_now = () => Date.now();
+	var nowIsMonotonic = 1;
+	var 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;
+		var 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);
+		var 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;
+	var getHeapMax = () => 4294901760;
+	var growMemory = (size) => {
+		var pages = (size - wasmMemory.buffer.byteLength + 65535) / 65536 | 0;
 		try {
 			wasmMemory.grow(pages);
 			updateMemoryViews();
@@ -3049,35 +2904,32 @@ async function createRimeModule(moduleArg = {}) {
 	};
 	function _emscripten_resize_heap(requestedSize) {
 		requestedSize >>>= 0;
-		const oldSize = HEAPU8.length;
-		const maxHeapSize = getHeapMax();
+		var oldSize = HEAPU8.length;
+		var maxHeapSize = getHeapMax();
 		if (requestedSize > maxHeapSize) return false;
-		for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
-			let overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+		for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+			var 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;
+			if (growMemory(Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)))) return true;
 		}
 		return false;
 	}
-	const ENV = {};
-	const getExecutableName = () => thisProgram || "./this.program";
-	const getEnvStrings = () => {
+	var ENV = {};
+	var getExecutableName = () => thisProgram || "./this.program";
+	var getEnvStrings = () => {
 		if (!getEnvStrings.strings) {
-			const lang = `${(globalThis.navigator?.language ?? "C").replace("-", "_")}.UTF-8`;
-			const env = {
+			var env = {
 				USER: "web_user",
 				LOGNAME: "web_user",
 				PATH: "/",
 				PWD: "/",
 				HOME: "/home/web_user",
-				LANG: lang,
+				LANG: (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8",
 				_: getExecutableName()
 			};
 			for (var x in ENV) if (ENV[x] === void 0) delete env[x];
 			else env[x] = ENV[x];
-			const strings = [];
+			var strings = [];
 			for (var x in env) strings.push(`${x}=${env[x]}`);
 			getEnvStrings.strings = strings;
 		}
@@ -3086,10 +2938,10 @@ async function createRimeModule(moduleArg = {}) {
 	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;
+		var bufSize = 0;
+		var envp = 0;
+		for (var string of getEnvStrings()) {
+			var ptr = environ_buf + bufSize;
 			HEAPU32[__environ + envp >>> 2 >>> 0] = ptr;
 			bufSize += stringToUTF8(string, ptr, Infinity) + 1;
 			envp += 4;
@@ -3099,16 +2951,16 @@ async function createRimeModule(moduleArg = {}) {
 	function _environ_sizes_get(penviron_count, penviron_buf_size) {
 		penviron_count >>>= 0;
 		penviron_buf_size >>>= 0;
-		const strings = getEnvStrings();
+		var strings = getEnvStrings();
 		HEAPU32[penviron_count >>> 2 >>> 0] = strings.length;
-		let bufSize = 0;
-		for (const string of strings) bufSize += lengthBytesUTF8(string) + 1;
+		var bufSize = 0;
+		for (var 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);
+			var stream = SYSCALLS.getStreamFromFD(fd);
 			FS.close(stream);
 			return 0;
 		} catch (e) {
@@ -3119,13 +2971,11 @@ async function createRimeModule(moduleArg = {}) {
 	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;
-			}
+			var rightsBase = 0;
+			var rightsInheriting = 0;
+			var flags = 0;
+			var 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);
@@ -3136,13 +2986,13 @@ async function createRimeModule(moduleArg = {}) {
 			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];
+	var doReadv = (stream, iov, iovcnt, offset) => {
+		var ret = 0;
+		for (var i = 0; i < iovcnt; i++) {
+			var ptr = HEAPU32[iov >>> 2 >>> 0];
+			var len = HEAPU32[iov + 4 >>> 2 >>> 0];
 			iov += 8;
-			const curr = FS.read(stream, HEAP8, ptr, len, offset);
+			var curr = FS.read(stream, HEAP8, ptr, len, offset);
 			if (curr < 0) return -1;
 			ret += curr;
 			if (curr < len) break;
@@ -3157,8 +3007,7 @@ async function createRimeModule(moduleArg = {}) {
 		pnum >>>= 0;
 		try {
 			if (isNaN(offset)) return 61;
-			const stream = SYSCALLS.getStreamFromFD(fd);
-			const num = doReadv(stream, iov, iovcnt, offset);
+			var num = doReadv(SYSCALLS.getStreamFromFD(fd), iov, iovcnt, offset);
 			HEAPU32[pnum >>> 2 >>> 0] = num;
 			return 0;
 		} catch (e) {
@@ -3171,8 +3020,7 @@ async function createRimeModule(moduleArg = {}) {
 		iovcnt >>>= 0;
 		pnum >>>= 0;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
-			const num = doReadv(stream, iov, iovcnt);
+			var num = doReadv(SYSCALLS.getStreamFromFD(fd), iov, iovcnt);
 			HEAPU32[pnum >>> 2 >>> 0] = num;
 			return 0;
 		} catch (e) {
@@ -3185,7 +3033,7 @@ async function createRimeModule(moduleArg = {}) {
 		newOffset >>>= 0;
 		try {
 			if (isNaN(offset)) return 61;
-			const stream = SYSCALLS.getStreamFromFD(fd);
+			var 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;
@@ -3195,13 +3043,13 @@ async function createRimeModule(moduleArg = {}) {
 			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];
+	var doWritev = (stream, iov, iovcnt, offset) => {
+		var ret = 0;
+		for (var i = 0; i < iovcnt; i++) {
+			var ptr = HEAPU32[iov >>> 2 >>> 0];
+			var len = HEAPU32[iov + 4 >>> 2 >>> 0];
 			iov += 8;
-			const curr = FS.write(stream, HEAP8, ptr, len, offset);
+			var curr = FS.write(stream, HEAP8, ptr, len, offset);
 			if (curr < 0) return -1;
 			ret += curr;
 			if (curr < len) break;
@@ -3214,8 +3062,7 @@ async function createRimeModule(moduleArg = {}) {
 		iovcnt >>>= 0;
 		pnum >>>= 0;
 		try {
-			const stream = SYSCALLS.getStreamFromFD(fd);
-			const num = doWritev(stream, iov, iovcnt);
+			var num = doWritev(SYSCALLS.getStreamFromFD(fd), iov, iovcnt);
 			HEAPU32[pnum >>> 2 >>> 0] = num;
 			return 0;
 		} catch (e) {
@@ -3234,109 +3081,106 @@ async function createRimeModule(moduleArg = {}) {
 			return e.errno;
 		}
 	}
-	const getCFunc = (ident) => {
-		const func = Module[`_${ident}`];
-		return func;
+	var getCFunc = (ident) => {
+		return Module["_" + ident];
 	};
-	const writeArrayToMemory = (array, buffer) => {
+	var 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);
+	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+	var stringToUTF8OnStack = (str) => {
+		var size = lengthBytesUTF8(str) + 1;
+		var 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 = {
+	var stackSave = () => _emscripten_stack_get_current();
+	var stackRestore = (val) => __emscripten_stack_restore(val);
+	var ccall = (ident, returnType, argTypes, args, opts) => {
+		var toC = {
 			string: (str) => {
-				let ret$1 = 0;
-				if (str !== null && str !== void 0 && str !== 0) ret$1 = stringToUTF8OnStack(str);
-				return ret$1;
+				var ret = 0;
+				if (str !== null && str !== void 0 && str !== 0) ret = stringToUTF8OnStack(str);
+				return ret;
 			},
 			array: (arr) => {
-				const ret$1 = stackAlloc(arr.length);
-				writeArrayToMemory(arr, ret$1);
-				return ret$1;
+				var ret = stackAlloc(arr.length);
+				writeArrayToMemory(arr, ret);
+				return ret;
 			}
 		};
-		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]];
+		function convertReturnValue(ret) {
+			if (returnType === "string") return UTF8ToString(ret);
+			if (returnType === "pointer") return ret >>> 0;
+			if (returnType === "boolean") return Boolean(ret);
+			return ret;
+		}
+		var func = getCFunc(ident);
+		var cArgs = [];
+		var stack = 0;
+		if (args) for (var i = 0; i < args.length; i++) {
+			var 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) {
+		var ret = func(...cArgs);
+		function onDone(ret) {
 			if (stack !== 0) stackRestore(stack);
-			return convertReturnValue(ret$1);
+			return convertReturnValue(ret);
 		}
 		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);
+	var FS_createPath = (...args) => FS.createPath(...args);
+	var FS_unlink = (...args) => FS.unlink(...args);
+	var FS_createLazyFile = (...args) => FS.createLazyFile(...args);
+	var 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()();
-		}
+	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"]) 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;
+	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;
+	var _emscripten_builtin_memalign, __emscripten_timeout, ___trap, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, wasmMemory;
+	function assignWasmExports(wasmExports) {
+		Module["_free"] = wasmExports["R"];
+		Module["_malloc"] = wasmExports["S"];
+		Module["_rime_wasm_init"] = wasmExports["T"];
+		Module["_rime_wasm_process_input"] = wasmExports["U"];
+		Module["_rime_wasm_pick_candidate"] = wasmExports["V"];
+		Module["_rime_wasm_flip_page"] = wasmExports["W"];
+		Module["_rime_wasm_clear_input"] = wasmExports["X"];
+		Module["_rime_wasm_set_option"] = wasmExports["Y"];
+		Module["_rime_wasm_get_version"] = wasmExports["Z"];
+		Module["_rime_wasm_destroy"] = wasmExports["_"];
+		_emscripten_builtin_memalign = wasmExports["$"];
+		__emscripten_timeout = wasmExports["aa"];
+		___trap = wasmExports["ba"];
+		__emscripten_stack_restore = wasmExports["ca"];
+		__emscripten_stack_alloc = wasmExports["da"];
+		_emscripten_stack_get_current = wasmExports["ea"];
+		wasmMemory = wasmExports["P"];
+		wasmExports["__indirect_function_table"];
 	}
 	var wasmImports = {
 		r: ___syscall_chmod,
@@ -3381,16 +3225,16 @@ async function createRimeModule(moduleArg = {}) {
 		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 applySignatureConversions(wasmExports) {
+		wasmExports = Object.assign({}, wasmExports);
+		var makeWrapper_pp = (f) => (a0) => f(a0) >>> 0;
+		var makeWrapper_ppp = (f) => (a0, a1) => f(a0, a1) >>> 0;
+		var makeWrapper_p = (f) => () => f() >>> 0;
+		wasmExports["S"] = makeWrapper_pp(wasmExports["S"]);
+		wasmExports["$"] = makeWrapper_ppp(wasmExports["$"]);
+		wasmExports["da"] = makeWrapper_pp(wasmExports["da"]);
+		wasmExports["ea"] = makeWrapper_p(wasmExports["ea"]);
+		return wasmExports;
 	}
 	function run() {
 		if (runDependencies > 0) {
@@ -3403,23 +3247,22 @@ async function createRimeModule(moduleArg = {}) {
 			return;
 		}
 		function doRun() {
-			Module.calledRun = true;
+			Module["calledRun"] = true;
 			if (ABORT) return;
 			initRuntime();
 			readyPromiseResolve?.(Module);
-			Module.onRuntimeInitialized?.();
+			Module["onRuntimeInitialized"]?.();
 			postRun();
 		}
-		if (Module.setStatus) {
-			Module.setStatus("Running...");
+		if (Module["setStatus"]) {
+			Module["setStatus"]("Running...");
 			setTimeout(() => {
-				setTimeout(() => Module.setStatus(""), 1);
+				setTimeout(() => Module["setStatus"](""), 1);
 				doRun();
 			}, 1);
 		} else doRun();
 	}
-	let wasmExports;
-	wasmExports = await createWasm();
+	var wasmExports = await createWasm();
 	run();
 	if (runtimeInitialized) moduleRtn = Module;
 	else moduleRtn = new Promise((resolve, reject) => {
@@ -3428,8 +3271,6 @@ async function createRimeModule(moduleArg = {}) {
 	});
 	return moduleRtn;
 }
-var rime_api_default = createRimeModule;
 //#endregion
 //#region src/rime.ts
 function syncfs(module, populate) {
@@ -3442,7 +3283,7 @@ function syncfs(module, populate) {
 }
 async function createRimeEngine(options = {}) {
 	const wasmDir = options.wasmDir ?? ".";
-	const Module = await rime_api_default({ locateFile(file) {
+	const Module = await createRimeModule({ locateFile(file) {
 		return `${wasmDir}/${file}`;
 	} });
 	try {
@@ -3479,7 +3320,7 @@ async function createRimeEngine(options = {}) {
 		const json = Module.ccall(fn, "string", argTypes, args);
 		return JSON.parse(json);
 	}
-	const engine = {
+	return {
 		processInput(keys) {
 			return callJson("rime_wasm_process_input", ["string"], [keys]);
 		},
@@ -3510,9 +3351,7 @@ async function createRimeEngine(options = {}) {
 			syncfs(Module, false).catch(() => {});
 		}
 	};
-	return engine;
 }
 //#endregion
 //#region src/index.ts
 /**
@@ -3558,23 +3397,19 @@ var RimePinyinEngine = class {
 		return state;
 	}
 	async pickCandidate(index) {
-		const engine = await this.getEngine();
-		return engine.pickCandidate(index);
+		return (await this.getEngine()).pickCandidate(index);
 	}
 	async clearInput() {
-		const engine = await this.getEngine();
-		return engine.clearInput();
+		return (await this.getEngine()).clearInput();
 	}
 	async setSimplified(simplified) {
-		const engine = await this.getEngine();
-		return engine.setOption("zh_simp", simplified);
+		return (await this.getEngine()).setOption("zh_simp", simplified);
 	}
 	async destroy() {
-		const engine = await this.getEngine();
-		return engine.destroy();
+		return (await this.getEngine()).destroy();
 	}
 };
 //#endregion
 export { RimePinyinEngine };
 //# sourceMappingURL=index.mjs.map