@zh-keyboard/pinyin 1.1.0 → 1.1.2

package/dist/index.js

@@ -1,37 +1,23 @@
-"use strict";
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#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$1 = createRequire(require("url").pathToFileURL(__filename).href);
-	}
-	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$1("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) {
@@ -42,24 +28,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;
@@ -69,41 +55,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({
@@ -142,128 +128,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 = require("url").pathToFileURL(__filename).href;
-	let scriptDirectory = "";
+	var _scriptName = require("url").pathToFileURL(__filename).href;
+	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$1("node:fs");
-		if (_scriptName.startsWith("file:")) scriptDirectory = `${require$1("node:path").dirname(require$1("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", require("url").pathToFileURL(__filename).href).href;
 	}
 	function getBinarySync(file) {
@@ -273,26 +213,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");
@@ -300,30 +238,27 @@ 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$1) {
+		function receiveInstance(instance, module) {
 			wasmExports = instance.exports;
 			wasmExports = applySignatureConversions(wasmExports);
 			assignWasmExports(wasmExports);
 			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$1 = receiveInstantiationResult(result);
-		return exports$1;
+		return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
 	}
 	class ExitStatus {
 		name = "ExitStatus";
@@ -339,17 +274,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);
@@ -363,44 +297,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$1("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("/");
@@ -410,44 +334,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) {
@@ -457,13 +381,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;
@@ -488,29 +412,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";
 			}
@@ -533,7 +445,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;
@@ -546,8 +458,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);
@@ -653,11 +565,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;
 	};
@@ -712,7 +624,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;
@@ -742,12 +654,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);
 		},
@@ -757,7 +668,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;
@@ -765,7 +676,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;
@@ -804,12 +715,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];
@@ -822,8 +733,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();
 			},
@@ -835,7 +745,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;
 			},
@@ -846,17 +756,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) {
@@ -874,12 +784,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;
@@ -889,9 +799,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;
@@ -916,21 +826,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;
@@ -953,13 +862,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;
@@ -969,7 +878,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;
@@ -987,24 +896,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) {
@@ -1012,11 +921,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 = () => {
@@ -1030,16 +939,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);
@@ -1055,19 +964,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,
@@ -1082,10 +990,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);
@@ -1101,15 +1008,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);
 			}
@@ -1117,7 +1024,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) {
@@ -1126,7 +1033,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);
@@ -1147,7 +1054,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);
@@ -1155,85 +1062,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?.();
@@ -1242,7 +1148,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 = {
@@ -1331,19 +1237,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;
@@ -1359,9 +1265,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;
 					}
 				}
@@ -1373,10 +1279,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;
 				}
@@ -1385,20 +1291,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;
@@ -1409,17 +1315,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;
 		},
@@ -1454,7 +1360,7 @@ async function createRimeModule(moduleArg = {}) {
 			return (mode & 49152) === 49152;
 		},
 		flagsToPermissionString(flag) {
-			let perms = [
+			var perms = [
 				"r",
 				"w",
 				"rw"
@@ -1471,7 +1377,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;
@@ -1479,19 +1385,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;
@@ -1502,23 +1408,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;
 		},
@@ -1534,21 +1440,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() {
@@ -1563,10 +1468,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);
 			}
@@ -1579,8 +1484,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);
@@ -1595,28 +1500,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;
@@ -1627,30 +1532,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);
@@ -1662,7 +1566,7 @@ async function createRimeModule(moduleArg = {}) {
 			return FS.statfsNode(stream.node);
 		},
 		statfsNode(node) {
-			const rtn = {
+			var rtn = {
 				bsize: 4096,
 				frsize: 4096,
 				blocks: 1e6,
@@ -1688,9 +1592,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;
@@ -1711,39 +1615,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);
@@ -1764,11 +1665,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);
@@ -1776,18 +1676,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);
@@ -1795,23 +1692,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);
@@ -1827,18 +1721,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) {
@@ -1848,24 +1740,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,
@@ -1874,23 +1764,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
 			});
@@ -1900,19 +1786,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);
@@ -1924,12 +1810,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,
@@ -1972,10 +1858,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;
 		},
@@ -1986,10 +1872,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;
 		},
@@ -2012,10 +1898,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);
@@ -2023,7 +1908,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");
@@ -2031,10 +1916,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;
 		},
@@ -2055,9 +1940,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;
@@ -2071,16 +1955,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 },
@@ -2103,12 +1987,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();
@@ -2120,17 +2004,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;
 		},
@@ -2139,7 +2023,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,
@@ -2169,9 +2053,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 {
@@ -2184,36 +2068,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;
@@ -2222,8 +2106,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();
@@ -2264,42 +2148,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!");
@@ -2326,33 +2210,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;
@@ -2363,7 +2246,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 {
@@ -2375,26 +2258,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;
@@ -2406,9 +2286,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));
@@ -2433,22 +2313,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 {
@@ -2466,10 +2344,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";
@@ -2489,40 +2366,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;
 			}
@@ -2534,7 +2406,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;
@@ -2561,14 +2433,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;
@@ -2581,23 +2453,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;
@@ -2628,16 +2499,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;
@@ -2647,24 +2517,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,
@@ -2675,40 +2543,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) {
@@ -2744,8 +2605,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));
@@ -2761,7 +2622,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;
@@ -2776,9 +2637,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;
@@ -2851,14 +2712,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,
@@ -2872,7 +2733,7 @@ async function createRimeModule(moduleArg = {}) {
 		305,
 		335
 	];
-	const MONTH_DAYS_REGULAR_CUMULATIVE = [
+	var MONTH_DAYS_REGULAR_CUMULATIVE = [
 		0,
 		31,
 		59,
@@ -2886,16 +2747,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();
@@ -2903,13 +2761,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) {
@@ -2918,9 +2776,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;
@@ -2934,40 +2792,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();
@@ -2977,45 +2835,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);
@@ -3024,25 +2879,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();
@@ -3051,35 +2905,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;
 		}
@@ -3088,10 +2939,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;
@@ -3101,16 +2952,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) {
@@ -3121,13 +2972,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);
@@ -3138,13 +2987,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;
@@ -3159,8 +3008,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) {
@@ -3173,8 +3021,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) {
@@ -3187,7 +3034,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;
@@ -3197,13 +3044,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;
@@ -3216,8 +3063,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) {
@@ -3236,109 +3082,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,
@@ -3383,16 +3226,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) {
@@ -3405,23 +3248,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) => {
@@ -3430,13 +3272,11 @@ async function createRimeModule(moduleArg = {}) {
 	});
 	return moduleRtn;
 }
-var rime_api_default = createRimeModule;
-
 //#endregion
 //#region src/rime.ts
-function syncfs(module$1, populate) {
+function syncfs(module, populate) {
 	return new Promise((resolve, reject) => {
-		module$1.FS.syncfs(populate, (err) => {
+		module.FS.syncfs(populate, (err) => {
 			if (err) reject(err);
 			else resolve();
 		});
@@ -3444,7 +3284,7 @@ function syncfs(module$1, 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 {
@@ -3481,7 +3321,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]);
 		},
@@ -3512,9 +3352,7 @@ async function createRimeEngine(options = {}) {
 			syncfs(Module, false).catch(() => {});
 		}
 	};
-	return engine;
 }
-
 //#endregion
 //#region src/index.ts
 /**
@@ -3560,23 +3398,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
-exports.RimePinyinEngine = RimePinyinEngine
+exports.RimePinyinEngine = RimePinyinEngine;
+
 //# sourceMappingURL=index.js.map