rdkit-esm 0.1.0

package/dist/index.js

@@ -0,0 +1,4623 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
+});
+
+//#endregion
+//#region MinimalLib/dist/RDKit_minimal.js
+var require_RDKit_minimal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var initRDKitModule$1 = (() => {
+		var _scriptName = globalThis.document?.currentScript?.src;
+		return async function(moduleArg = {}) {
+			var moduleRtn;
+			var Module = moduleArg;
+			var ENVIRONMENT_IS_WEB = !!globalThis.window;
+			var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+			var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+			var thisProgram = "./this.program";
+			if (typeof __filename != "undefined") _scriptName = __filename;
+			else if (ENVIRONMENT_IS_WORKER) _scriptName = self.location.href;
+			var scriptDirectory = "";
+			function locateFile(path) {
+				if (Module["locateFile"]) return Module["locateFile"](path, scriptDirectory);
+				return scriptDirectory + path;
+			}
+			var readAsync, readBinary;
+			if (ENVIRONMENT_IS_NODE) {
+				var fs = __require("node:fs");
+				scriptDirectory = __dirname + "/";
+				readBinary = (filename) => {
+					filename = isFileURI(filename) ? new URL(filename) : filename;
+					return fs.readFileSync(filename);
+				};
+				readAsync = async (filename, binary = true) => {
+					filename = isFileURI(filename) ? new URL(filename) : filename;
+					return fs.readFileSync(filename, binary ? void 0 : "utf8");
+				};
+				if (process.argv.length > 1) thisProgram = process.argv[1].replace(/\\/g, "/");
+				process.argv.slice(2);
+			} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+				try {
+					scriptDirectory = new URL(".", _scriptName).href;
+				} catch {}
+				if (ENVIRONMENT_IS_WORKER) readBinary = (url) => {
+					var 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) => {
+						var 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);
+					});
+					var response = await fetch(url, { credentials: "same-origin" });
+					if (response.ok) return response.arrayBuffer();
+					throw new Error(response.status + " : " + response.url);
+				};
+			}
+			var out = console.log.bind(console);
+			var err = console.error.bind(console);
+			var wasmBinary;
+			var ABORT = false;
+			var isFileURI = (filename) => filename.startsWith("file://");
+			function writeStackCookie() {
+				var max = _emscripten_stack_get_end();
+				if (max == 0) max += 4;
+				HEAPU32[max >>> 2 >>> 0] = 34821223;
+				HEAPU32[max + 4 >>> 2 >>> 0] = 2310721022;
+				HEAPU32[0] = 1668509029;
+			}
+			function checkStackCookie() {
+				if (ABORT) return;
+				var max = _emscripten_stack_get_end();
+				if (max == 0) max += 4;
+				var cookie1 = HEAPU32[max >>> 2 >>> 0];
+				var cookie2 = HEAPU32[max + 4 >>> 2 >>> 0];
+				if (cookie1 != 34821223 || cookie2 != 2310721022) abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
+				if (HEAPU32[0] != 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
+			}
+			var readyPromiseResolve, readyPromiseReject;
+			var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+			var HEAP64, HEAPU64;
+			var runtimeInitialized = false;
+			function updateMemoryViews() {
+				var b = wasmMemory.buffer;
+				HEAP8 = new Int8Array(b);
+				HEAP16 = new Int16Array(b);
+				HEAPU8 = new Uint8Array(b);
+				HEAPU16 = new Uint16Array(b);
+				HEAP32 = new Int32Array(b);
+				HEAPU32 = new Uint32Array(b);
+				HEAPF32 = new Float32Array(b);
+				HEAPF64 = new Float64Array(b);
+				HEAP64 = new BigInt64Array(b);
+				HEAPU64 = new BigUint64Array(b);
+			}
+			function preRun() {
+				if (Module["preRun"]) {
+					if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+					while (Module["preRun"].length) addOnPreRun(Module["preRun"].shift());
+				}
+				callRuntimeCallbacks(onPreRuns);
+			}
+			function initRuntime() {
+				runtimeInitialized = true;
+				checkStackCookie();
+				if (!Module["noFSInit"] && !FS.initialized) FS.init();
+				TTY.init();
+				wasmExports["Y"]();
+				FS.ignorePermissions = false;
+			}
+			function postRun() {
+				checkStackCookie();
+				if (Module["postRun"]) {
+					if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+					while (Module["postRun"].length) addOnPostRun(Module["postRun"].shift());
+				}
+				callRuntimeCallbacks(onPostRuns);
+			}
+			function abort(what) {
+				Module["onAbort"]?.(what);
+				what = "Aborted(" + what + ")";
+				err(what);
+				ABORT = true;
+				what += ". Build with -sASSERTIONS for more info.";
+				if (runtimeInitialized) ___trap();
+				var e = new WebAssembly.RuntimeError(what);
+				readyPromiseReject?.(e);
+				throw e;
+			}
+			var wasmBinaryFile;
+			function findWasmBinary() {
+				return locateFile("RDKit_minimal.wasm");
+			}
+			function getBinarySync(file) {
+				if (file == wasmBinaryFile && wasmBinary) return new Uint8Array(wasmBinary);
+				if (readBinary) return readBinary(file);
+				throw "both async and sync fetching of the wasm failed";
+			}
+			async function getWasmBinary(binaryFile) {
+				if (!wasmBinary) try {
+					var response = await readAsync(binaryFile);
+					return new Uint8Array(response);
+				} catch {}
+				return getBinarySync(binaryFile);
+			}
+			async function instantiateArrayBuffer(binaryFile, imports) {
+				try {
+					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 {
+					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");
+				}
+				return instantiateArrayBuffer(binaryFile, imports);
+			}
+			function getWasmImports() {
+				return { a: wasmImports };
+			}
+			async function createWasm() {
+				function receiveInstance(instance, module$1) {
+					wasmExports = instance.exports;
+					wasmExports = applySignatureConversions(wasmExports);
+					assignWasmExports(wasmExports);
+					updateMemoryViews();
+					return wasmExports;
+				}
+				function receiveInstantiationResult(result) {
+					return receiveInstance(result["instance"]);
+				}
+				var info = getWasmImports();
+				if (Module["instantiateWasm"]) return new Promise((resolve, reject) => {
+					Module["instantiateWasm"](info, (inst, mod) => {
+						resolve(receiveInstance(inst, mod));
+					});
+				});
+				wasmBinaryFile ??= findWasmBinary();
+				return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
+			}
+			var callRuntimeCallbacks = (callbacks) => {
+				while (callbacks.length > 0) callbacks.shift()(Module);
+			};
+			var onPostRuns = [];
+			var addOnPostRun = (cb) => onPostRuns.push(cb);
+			var onPreRuns = [];
+			var addOnPreRun = (cb) => onPreRuns.push(cb);
+			var ptrToString = (ptr) => {
+				ptr >>>= 0;
+				return "0x" + ptr.toString(16).padStart(8, "0");
+			};
+			var syscallGetVarargI = () => {
+				var ret = HEAP32[+SYSCALLS.varargs >>> 2 >>> 0];
+				SYSCALLS.varargs += 4;
+				return ret;
+			};
+			var syscallGetVarargP = syscallGetVarargI;
+			var PATH = {
+				isAbs: (path) => path.charAt(0) === "/",
+				splitPath: (filename) => {
+					return /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(filename).slice(1);
+				},
+				normalizeArray: (parts, allowAboveRoot) => {
+					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);
+							up++;
+						} else if (up) {
+							parts.splice(i, 1);
+							up--;
+						}
+					}
+					if (allowAboveRoot) for (; up; up--) parts.unshift("..");
+					return parts;
+				},
+				normalize: (path) => {
+					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) => {
+					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],
+				join: (...paths) => PATH.normalize(paths.join("/")),
+				join2: (l, r) => PATH.normalize(l + "/" + r)
+			};
+			var initRandomFill = () => {
+				if (ENVIRONMENT_IS_NODE) {
+					var nodeCrypto = __require("node:crypto");
+					return (view) => nodeCrypto.randomFillSync(view);
+				}
+				return (view) => crypto.getRandomValues(view);
+			};
+			var randomFill = (view) => {
+				(randomFill = initRandomFill())(view);
+			};
+			var PATH_FS = {
+				resolve: (...args) => {
+					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;
+						resolvedAbsolute = PATH.isAbs(path);
+					}
+					resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
+					return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+				},
+				relative: (from, to) => {
+					from = PATH_FS.resolve(from).slice(1);
+					to = PATH_FS.resolve(to).slice(1);
+					function trim(arr) {
+						var start = 0;
+						for (; start < arr.length; start++) if (arr[start] !== "") break;
+						var end = arr.length - 1;
+						for (; end >= 0; end--) if (arr[end] !== "") break;
+						if (start > end) return [];
+						return arr.slice(start, end - start + 1);
+					}
+					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;
+					}
+					var outputParts = [];
+					for (var i = samePartsLength; i < fromParts.length; i++) outputParts.push("..");
+					outputParts = outputParts.concat(toParts.slice(samePartsLength));
+					return outputParts.join("/");
+				}
+			};
+			var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
+			var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+				var maxIdx = idx + maxBytesToRead;
+				if (ignoreNul) return maxIdx;
+				while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+				return idx;
+			};
+			var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+				idx >>>= 0;
+				var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+				if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+				var str = "";
+				while (idx < endPtr) {
+					var u0 = heapOrArray[idx++];
+					if (!(u0 & 128)) {
+						str += String.fromCharCode(u0);
+						continue;
+					}
+					var u1 = heapOrArray[idx++] & 63;
+					if ((u0 & 224) == 192) {
+						str += String.fromCharCode((u0 & 31) << 6 | u1);
+						continue;
+					}
+					var u2 = heapOrArray[idx++] & 63;
+					if ((u0 & 240) == 224) u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+					else u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+					if (u0 < 65536) str += String.fromCharCode(u0);
+					else {
+						var ch = u0 - 65536;
+						str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+					}
+				}
+				return str;
+			};
+			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) {
+						len += 4;
+						++i;
+					} else len += 3;
+				}
+				return len;
+			};
+			var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+				outIdx >>>= 0;
+				if (!(maxBytesToWrite > 0)) return 0;
+				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;
+					} else if (u <= 2047) {
+						if (outIdx + 1 >= endIdx) break;
+						heap[outIdx++ >>> 0] = 192 | u >> 6;
+						heap[outIdx++ >>> 0] = 128 | u & 63;
+					} else if (u <= 65535) {
+						if (outIdx + 2 >= endIdx) break;
+						heap[outIdx++ >>> 0] = 224 | u >> 12;
+						heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+						heap[outIdx++ >>> 0] = 128 | u & 63;
+					} else {
+						if (outIdx + 3 >= endIdx) break;
+						heap[outIdx++ >>> 0] = 240 | u >> 18;
+						heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
+						heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+						heap[outIdx++ >>> 0] = 128 | u & 63;
+						i++;
+					}
+				}
+				heap[outIdx >>> 0] = 0;
+				return outIdx - startIdx;
+			};
+			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;
+			};
+			var FS_stdin_getChar = () => {
+				if (!FS_stdin_getChar_buffer.length) {
+					var result = null;
+					if (ENVIRONMENT_IS_NODE) {
+						var BUFSIZE = 256;
+						var buf = Buffer.alloc(BUFSIZE);
+						var bytesRead = 0;
+						var fd = process.stdin.fd;
+						try {
+							bytesRead = fs.readSync(fd, buf, 0, BUFSIZE);
+						} catch (e) {
+							if (e.toString().includes("EOF")) bytesRead = 0;
+							else throw e;
+						}
+						if (bytesRead > 0) result = buf.slice(0, bytesRead).toString("utf-8");
+					} else if (globalThis.window?.prompt) {
+						result = window.prompt("Input: ");
+						if (result !== null) result += "\n";
+					}
+					if (!result) return null;
+					FS_stdin_getChar_buffer = intArrayFromString(result, true);
+				}
+				return FS_stdin_getChar_buffer.shift();
+			};
+			var TTY = {
+				ttys: [],
+				init() {},
+				shutdown() {},
+				register(dev, ops) {
+					TTY.ttys[dev] = {
+						input: [],
+						output: [],
+						ops
+					};
+					FS.registerDevice(dev, TTY.stream_ops);
+				},
+				stream_ops: {
+					open(stream) {
+						var tty = TTY.ttys[stream.node.rdev];
+						if (!tty) throw new FS.ErrnoError(43);
+						stream.tty = tty;
+						stream.seekable = false;
+					},
+					close(stream) {
+						stream.tty.ops.fsync(stream.tty);
+					},
+					fsync(stream) {
+						stream.tty.ops.fsync(stream.tty);
+					},
+					read(stream, buffer, offset, length, pos) {
+						if (!stream.tty || !stream.tty.ops.get_char) throw new FS.ErrnoError(60);
+						var bytesRead = 0;
+						for (var i = 0; i < length; i++) {
+							var result;
+							try {
+								result = stream.tty.ops.get_char(stream.tty);
+							} catch (e) {
+								throw new FS.ErrnoError(29);
+							}
+							if (result === void 0 && bytesRead === 0) throw new FS.ErrnoError(6);
+							if (result === null || result === void 0) break;
+							bytesRead++;
+							buffer[offset + i] = result;
+						}
+						if (bytesRead) stream.node.atime = Date.now();
+						return bytesRead;
+					},
+					write(stream, buffer, offset, length, pos) {
+						if (!stream.tty || !stream.tty.ops.put_char) throw new FS.ErrnoError(60);
+						try {
+							for (var i = 0; i < length; i++) stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+						} catch (e) {
+							throw new FS.ErrnoError(29);
+						}
+						if (length) stream.node.mtime = stream.node.ctime = Date.now();
+						return i;
+					}
+				},
+				default_tty_ops: {
+					get_char(tty) {
+						return FS_stdin_getChar();
+					},
+					put_char(tty, val) {
+						if (val === null || val === 10) {
+							out(UTF8ArrayToString(tty.output));
+							tty.output = [];
+						} else if (val != 0) tty.output.push(val);
+					},
+					fsync(tty) {
+						if (tty.output?.length > 0) {
+							out(UTF8ArrayToString(tty.output));
+							tty.output = [];
+						}
+					},
+					ioctl_tcgets(tty) {
+						return {
+							c_iflag: 25856,
+							c_oflag: 5,
+							c_cflag: 191,
+							c_lflag: 35387,
+							c_cc: [
+								3,
+								28,
+								127,
+								21,
+								4,
+								0,
+								1,
+								0,
+								17,
+								19,
+								26,
+								0,
+								18,
+								15,
+								23,
+								22,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0
+							]
+						};
+					},
+					ioctl_tcsets(tty, optional_actions, data) {
+						return 0;
+					},
+					ioctl_tiocgwinsz(tty) {
+						return [24, 80];
+					}
+				},
+				default_tty1_ops: {
+					put_char(tty, val) {
+						if (val === null || val === 10) {
+							err(UTF8ArrayToString(tty.output));
+							tty.output = [];
+						} else if (val != 0) tty.output.push(val);
+					},
+					fsync(tty) {
+						if (tty.output?.length > 0) {
+							err(UTF8ArrayToString(tty.output));
+							tty.output = [];
+						}
+					}
+				}
+			};
+			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);
+				var ptr = _emscripten_builtin_memalign(65536, size);
+				if (ptr) zeroMemory(ptr, size);
+				return ptr;
+			};
+			var MEMFS = {
+				ops_table: null,
+				mount(mount) {
+					return MEMFS.createNode(null, "/", 16895, 0);
+				},
+				createNode(parent, name, mode, dev) {
+					if (FS.isBlkdev(mode) || FS.isFIFO(mode)) throw new FS.ErrnoError(63);
+					MEMFS.ops_table ||= {
+						dir: {
+							node: {
+								getattr: MEMFS.node_ops.getattr,
+								setattr: MEMFS.node_ops.setattr,
+								lookup: MEMFS.node_ops.lookup,
+								mknod: MEMFS.node_ops.mknod,
+								rename: MEMFS.node_ops.rename,
+								unlink: MEMFS.node_ops.unlink,
+								rmdir: MEMFS.node_ops.rmdir,
+								readdir: MEMFS.node_ops.readdir,
+								symlink: MEMFS.node_ops.symlink
+							},
+							stream: { llseek: MEMFS.stream_ops.llseek }
+						},
+						file: {
+							node: {
+								getattr: MEMFS.node_ops.getattr,
+								setattr: MEMFS.node_ops.setattr
+							},
+							stream: {
+								llseek: MEMFS.stream_ops.llseek,
+								read: MEMFS.stream_ops.read,
+								write: MEMFS.stream_ops.write,
+								mmap: MEMFS.stream_ops.mmap,
+								msync: MEMFS.stream_ops.msync
+							}
+						},
+						link: {
+							node: {
+								getattr: MEMFS.node_ops.getattr,
+								setattr: MEMFS.node_ops.setattr,
+								readlink: MEMFS.node_ops.readlink
+							},
+							stream: {}
+						},
+						chrdev: {
+							node: {
+								getattr: MEMFS.node_ops.getattr,
+								setattr: MEMFS.node_ops.setattr
+							},
+							stream: FS.chrdev_stream_ops
+						}
+					};
+					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;
+						node.contents = {};
+					} else if (FS.isFile(node.mode)) {
+						node.node_ops = MEMFS.ops_table.file.node;
+						node.stream_ops = MEMFS.ops_table.file.stream;
+						node.usedBytes = 0;
+						node.contents = null;
+					} else if (FS.isLink(node.mode)) {
+						node.node_ops = MEMFS.ops_table.link.node;
+						node.stream_ops = MEMFS.ops_table.link.stream;
+					} else if (FS.isChrdev(node.mode)) {
+						node.node_ops = MEMFS.ops_table.chrdev.node;
+						node.stream_ops = MEMFS.ops_table.chrdev.stream;
+					}
+					node.atime = node.mtime = node.ctime = Date.now();
+					if (parent) {
+						parent.contents[name] = node;
+						parent.atime = parent.mtime = parent.ctime = node.atime;
+					}
+					return node;
+				},
+				getFileDataAsTypedArray(node) {
+					if (!node.contents) return new Uint8Array(0);
+					if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
+					return new Uint8Array(node.contents);
+				},
+				expandFileStorage(node, newCapacity) {
+					var prevCapacity = node.contents ? node.contents.length : 0;
+					if (prevCapacity >= newCapacity) return;
+					newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < 1024 * 1024 ? 2 : 1.125) >>> 0);
+					if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
+					var oldContents = node.contents;
+					node.contents = new Uint8Array(newCapacity);
+					if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
+				},
+				resizeFileStorage(node, newSize) {
+					if (node.usedBytes == newSize) return;
+					if (newSize == 0) {
+						node.contents = null;
+						node.usedBytes = 0;
+					} else {
+						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;
+					}
+				},
+				node_ops: {
+					getattr(node) {
+						var attr = {};
+						attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+						attr.ino = node.id;
+						attr.mode = node.mode;
+						attr.nlink = 1;
+						attr.uid = 0;
+						attr.gid = 0;
+						attr.rdev = node.rdev;
+						if (FS.isDir(node.mode)) attr.size = 4096;
+						else if (FS.isFile(node.mode)) attr.size = node.usedBytes;
+						else if (FS.isLink(node.mode)) attr.size = node.link.length;
+						else attr.size = 0;
+						attr.atime = new Date(node.atime);
+						attr.mtime = new Date(node.mtime);
+						attr.ctime = new Date(node.ctime);
+						attr.blksize = 4096;
+						attr.blocks = Math.ceil(attr.size / attr.blksize);
+						return attr;
+					},
+					setattr(node, attr) {
+						for (const key of [
+							"mode",
+							"atime",
+							"mtime",
+							"ctime"
+						]) if (attr[key] != null) node[key] = attr[key];
+						if (attr.size !== void 0) MEMFS.resizeFileStorage(node, attr.size);
+					},
+					lookup(parent, name) {
+						if (!MEMFS.doesNotExistError) {
+							MEMFS.doesNotExistError = new FS.ErrnoError(44);
+							MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+						}
+						throw MEMFS.doesNotExistError;
+					},
+					mknod(parent, name, mode, dev) {
+						return MEMFS.createNode(parent, name, mode, dev);
+					},
+					rename(old_node, new_dir, new_name) {
+						var new_node;
+						try {
+							new_node = FS.lookupNode(new_dir, new_name);
+						} catch (e) {}
+						if (new_node) {
+							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];
+						new_dir.contents[new_name] = old_node;
+						old_node.name = new_name;
+						new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
+					},
+					unlink(parent, name) {
+						delete parent.contents[name];
+						parent.ctime = parent.mtime = Date.now();
+					},
+					rmdir(parent, name) {
+						for (var i in FS.lookupNode(parent, name).contents) throw new FS.ErrnoError(55);
+						delete parent.contents[name];
+						parent.ctime = parent.mtime = Date.now();
+					},
+					readdir(node) {
+						return [
+							".",
+							"..",
+							...Object.keys(node.contents)
+						];
+					},
+					symlink(parent, newname, oldpath) {
+						var node = MEMFS.createNode(parent, newname, 41471, 0);
+						node.link = oldpath;
+						return node;
+					},
+					readlink(node) {
+						if (!FS.isLink(node.mode)) throw new FS.ErrnoError(28);
+						return node.link;
+					}
+				},
+				stream_ops: {
+					read(stream, buffer, offset, length, position) {
+						var contents = stream.node.contents;
+						if (position >= stream.node.usedBytes) return 0;
+						var size = Math.min(stream.node.usedBytes - position, length);
+						if (size > 8 && contents.subarray) buffer.set(contents.subarray(position, position + size), offset);
+						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;
+						var node = stream.node;
+						node.mtime = node.ctime = Date.now();
+						if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+							if (canOwn) {
+								node.contents = buffer.subarray(offset, offset + length);
+								node.usedBytes = length;
+								return length;
+							} else if (node.usedBytes === 0 && position === 0) {
+								node.contents = buffer.slice(offset, offset + length);
+								node.usedBytes = length;
+								return length;
+							} else if (position + length <= node.usedBytes) {
+								node.contents.set(buffer.subarray(offset, offset + length), position);
+								return length;
+							}
+						}
+						MEMFS.expandFileStorage(node, position + length);
+						if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position);
+						else for (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) {
+						var position = offset;
+						if (whence === 1) position += stream.position;
+						else if (whence === 2) {
+							if (FS.isFile(stream.node.mode)) position += stream.node.usedBytes;
+						}
+						if (position < 0) throw new FS.ErrnoError(28);
+						return position;
+					},
+					mmap(stream, length, position, prot, flags) {
+						if (!FS.isFile(stream.node.mode)) throw new FS.ErrnoError(43);
+						var ptr;
+						var allocated;
+						var contents = stream.node.contents;
+						if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
+							allocated = false;
+							ptr = contents.byteOffset;
+						} else {
+							allocated = true;
+							ptr = mmapAlloc(length);
+							if (!ptr) throw new FS.ErrnoError(48);
+							if (contents) {
+								if (position > 0 || position + length < contents.length) if (contents.subarray) contents = contents.subarray(position, position + length);
+								else contents = Array.prototype.slice.call(contents, position, position + length);
+								HEAP8.set(contents, ptr >>> 0);
+							}
+						}
+						return {
+							ptr,
+							allocated
+						};
+					},
+					msync(stream, buffer, offset, length, mmapFlags) {
+						MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+						return 0;
+					}
+				}
+			};
+			var FS_modeStringToFlags = (str) => {
+				var flags = {
+					r: 0,
+					"r+": 2,
+					w: 577,
+					"w+": 578,
+					a: 1089,
+					"a+": 1090
+				}[str];
+				if (typeof flags == "undefined") throw new Error(`Unknown file open mode: ${str}`);
+				return flags;
+			};
+			var FS_getMode = (canRead, canWrite) => {
+				var mode = 0;
+				if (canRead) mode |= 365;
+				if (canWrite) mode |= 146;
+				return mode;
+			};
+			var asyncLoad = async (url) => {
+				var arrayBuffer = await readAsync(url);
+				return new Uint8Array(arrayBuffer);
+			};
+			var FS_createDataFile = (...args) => FS.createDataFile(...args);
+			var getUniqueRunDependency = (id) => id;
+			var runDependencies = 0;
+			var dependenciesFulfilled = null;
+			var removeRunDependency = (id) => {
+				runDependencies--;
+				Module["monitorRunDependencies"]?.(runDependencies);
+				if (runDependencies == 0) {
+					if (dependenciesFulfilled) {
+						var callback = dependenciesFulfilled;
+						dependenciesFulfilled = null;
+						callback();
+					}
+				}
+			};
+			var addRunDependency = (id) => {
+				runDependencies++;
+				Module["monitorRunDependencies"]?.(runDependencies);
+			};
+			var preloadPlugins = [];
+			var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
+				if (typeof Browser != "undefined") Browser.init();
+				for (var plugin of preloadPlugins) if (plugin["canHandle"](fullname)) return plugin["handle"](byteArray, fullname);
+				return byteArray;
+			};
+			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 {
+					var byteArray = url;
+					if (typeof url == "string") byteArray = await asyncLoad(url);
+					byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
+					preFinish?.();
+					if (!dontCreateFile) FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+				} finally {
+					removeRunDependency(dep);
+				}
+			};
+			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 = {
+				root: null,
+				mounts: [],
+				devices: {},
+				streams: [],
+				nextInode: 1,
+				nameTable: null,
+				currentPath: "/",
+				initialized: false,
+				ignorePermissions: true,
+				filesystems: null,
+				syncFSRequests: 0,
+				ErrnoError: class {
+					name = "ErrnoError";
+					constructor(errno) {
+						this.errno = errno;
+					}
+				},
+				FSStream: class {
+					shared = {};
+					get object() {
+						return this.node;
+					}
+					set object(val) {
+						this.node = val;
+					}
+					get isRead() {
+						return (this.flags & 2097155) !== 1;
+					}
+					get isWrite() {
+						return (this.flags & 2097155) !== 0;
+					}
+					get isAppend() {
+						return this.flags & 1024;
+					}
+					get flags() {
+						return this.shared.flags;
+					}
+					set flags(val) {
+						this.shared.flags = val;
+					}
+					get position() {
+						return this.shared.position;
+					}
+					set position(val) {
+						this.shared.position = val;
+					}
+				},
+				FSNode: class {
+					node_ops = {};
+					stream_ops = {};
+					readMode = 365;
+					writeMode = 146;
+					mounted = null;
+					constructor(parent, name, mode, rdev) {
+						if (!parent) parent = this;
+						this.parent = parent;
+						this.mount = parent.mount;
+						this.id = FS.nextInode++;
+						this.name = name;
+						this.mode = mode;
+						this.rdev = rdev;
+						this.atime = this.mtime = this.ctime = Date.now();
+					}
+					get read() {
+						return (this.mode & this.readMode) === this.readMode;
+					}
+					set read(val) {
+						val ? this.mode |= this.readMode : this.mode &= ~this.readMode;
+					}
+					get write() {
+						return (this.mode & this.writeMode) === this.writeMode;
+					}
+					set write(val) {
+						val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
+					}
+					get isFolder() {
+						return FS.isDir(this.mode);
+					}
+					get isDevice() {
+						return FS.isChrdev(this.mode);
+					}
+				},
+				lookupPath(path, opts = {}) {
+					if (!path) throw new FS.ErrnoError(44);
+					opts.follow_mount ??= true;
+					if (!PATH.isAbs(path)) path = FS.cwd() + "/" + path;
+					linkloop: for (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("/");
+									nlinks--;
+									continue linkloop;
+								} else current = current.parent;
+								continue;
+							}
+							current_path = PATH.join2(current_path, parts[i]);
+							try {
+								current = FS.lookupNode(current, parts[i]);
+							} catch (e) {
+								if (e?.errno === 44 && islast && opts.noent_okay) return { path: current_path };
+								throw e;
+							}
+							if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) current = current.mounted.root;
+							if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+								if (!current.node_ops.readlink) throw new FS.ErrnoError(52);
+								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;
+							}
+						}
+						return {
+							path: current_path,
+							node: current
+						};
+					}
+					throw new FS.ErrnoError(32);
+				},
+				getPath(node) {
+					var path;
+					while (true) {
+						if (FS.isRoot(node)) {
+							var mount = node.mount.mountpoint;
+							if (!path) return mount;
+							return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+						}
+						path = path ? `${node.name}/${path}` : node.name;
+						node = node.parent;
+					}
+				},
+				hashName(parentid, name) {
+					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) {
+					var hash = FS.hashName(node.parent.id, node.name);
+					node.name_next = FS.nameTable[hash];
+					FS.nameTable[hash] = node;
+				},
+				hashRemoveNode(node) {
+					var hash = FS.hashName(node.parent.id, node.name);
+					if (FS.nameTable[hash] === node) FS.nameTable[hash] = node.name_next;
+					else {
+						var current = FS.nameTable[hash];
+						while (current) {
+							if (current.name_next === node) {
+								current.name_next = node.name_next;
+								break;
+							}
+							current = current.name_next;
+						}
+					}
+				},
+				lookupNode(parent, name) {
+					var errCode = FS.mayLookup(parent);
+					if (errCode) throw new FS.ErrnoError(errCode);
+					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) {
+					var node = new FS.FSNode(parent, name, mode, rdev);
+					FS.hashAddNode(node);
+					return node;
+				},
+				destroyNode(node) {
+					FS.hashRemoveNode(node);
+				},
+				isRoot(node) {
+					return node === node.parent;
+				},
+				isMountpoint(node) {
+					return !!node.mounted;
+				},
+				isFile(mode) {
+					return (mode & 61440) === 32768;
+				},
+				isDir(mode) {
+					return (mode & 61440) === 16384;
+				},
+				isLink(mode) {
+					return (mode & 61440) === 40960;
+				},
+				isChrdev(mode) {
+					return (mode & 61440) === 8192;
+				},
+				isBlkdev(mode) {
+					return (mode & 61440) === 24576;
+				},
+				isFIFO(mode) {
+					return (mode & 61440) === 4096;
+				},
+				isSocket(mode) {
+					return (mode & 49152) === 49152;
+				},
+				flagsToPermissionString(flag) {
+					var perms = [
+						"r",
+						"w",
+						"rw"
+					][flag & 3];
+					if (flag & 512) perms += "w";
+					return perms;
+				},
+				nodePermissions(node, perms) {
+					if (FS.ignorePermissions) return 0;
+					if (perms.includes("r") && !(node.mode & 292)) return 2;
+					if (perms.includes("w") && !(node.mode & 146)) return 2;
+					if (perms.includes("x") && !(node.mode & 73)) return 2;
+					return 0;
+				},
+				mayLookup(dir) {
+					if (!FS.isDir(dir.mode)) return 54;
+					var errCode = FS.nodePermissions(dir, "x");
+					if (errCode) return errCode;
+					if (!dir.node_ops.lookup) return 2;
+					return 0;
+				},
+				mayCreate(dir, name) {
+					if (!FS.isDir(dir.mode)) return 54;
+					try {
+						FS.lookupNode(dir, name);
+						return 20;
+					} catch (e) {}
+					return FS.nodePermissions(dir, "wx");
+				},
+				mayDelete(dir, name, isdir) {
+					var node;
+					try {
+						node = FS.lookupNode(dir, name);
+					} catch (e) {
+						return e.errno;
+					}
+					var errCode = FS.nodePermissions(dir, "wx");
+					if (errCode) return errCode;
+					if (isdir) {
+						if (!FS.isDir(node.mode)) return 54;
+						if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) return 10;
+					} else if (FS.isDir(node.mode)) return 31;
+					return 0;
+				},
+				mayOpen(node, flags) {
+					if (!node) return 44;
+					if (FS.isLink(node.mode)) return 32;
+					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);
+					return op;
+				},
+				MAX_OPEN_FDS: 4096,
+				nextfd() {
+					for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) if (!FS.streams[fd]) return fd;
+					throw new FS.ErrnoError(33);
+				},
+				getStreamChecked(fd) {
+					var stream = FS.getStream(fd);
+					if (!stream) throw new FS.ErrnoError(8);
+					return stream;
+				},
+				getStream: (fd) => FS.streams[fd],
+				createStream(stream, fd = -1) {
+					stream = Object.assign(new FS.FSStream(), stream);
+					if (fd == -1) fd = FS.nextfd();
+					stream.fd = fd;
+					FS.streams[fd] = stream;
+					return stream;
+				},
+				closeStream(fd) {
+					FS.streams[fd] = null;
+				},
+				dupStream(origStream, fd = -1) {
+					var stream = FS.createStream(origStream, fd);
+					stream.stream_ops?.dup?.(stream);
+					return stream;
+				},
+				doSetAttr(stream, node, attr) {
+					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) {
+						stream.stream_ops = FS.getDevice(stream.node.rdev).stream_ops;
+						stream.stream_ops.open?.(stream);
+					},
+					llseek() {
+						throw new FS.ErrnoError(70);
+					}
+				},
+				major: (dev) => dev >> 8,
+				minor: (dev) => dev & 255,
+				makedev: (ma, mi) => ma << 8 | mi,
+				registerDevice(dev, ops) {
+					FS.devices[dev] = { stream_ops: ops };
+				},
+				getDevice: (dev) => FS.devices[dev],
+				getMounts(mount) {
+					var mounts = [];
+					var check = [mount];
+					while (check.length) {
+						var m = check.pop();
+						mounts.push(m);
+						check.push(...m.mounts);
+					}
+					return mounts;
+				},
+				syncfs(populate, callback) {
+					if (typeof populate == "function") {
+						callback = populate;
+						populate = false;
+					}
+					FS.syncFSRequests++;
+					if (FS.syncFSRequests > 1) err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+					var mounts = FS.getMounts(FS.root.mount);
+					var completed = 0;
+					function doCallback(errCode) {
+						FS.syncFSRequests--;
+						return callback(errCode);
+					}
+					function done(errCode) {
+						if (errCode) {
+							if (!done.errored) {
+								done.errored = true;
+								return doCallback(errCode);
+							}
+							return;
+						}
+						if (++completed >= mounts.length) doCallback(null);
+					}
+					for (var mount of mounts) if (mount.type.syncfs) mount.type.syncfs(mount, populate, done);
+					else done(null);
+				},
+				mount(type, opts, mountpoint) {
+					var root = mountpoint === "/";
+					var pseudo = !mountpoint;
+					var node;
+					if (root && FS.root) throw new FS.ErrnoError(10);
+					else if (!root && !pseudo) {
+						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);
+					}
+					var mount = {
+						type,
+						opts,
+						mountpoint,
+						mounts: []
+					};
+					var mountRoot = type.mount(mount);
+					mountRoot.mount = mount;
+					mount.root = mountRoot;
+					if (root) FS.root = mountRoot;
+					else if (node) {
+						node.mounted = mount;
+						if (node.mount) node.mount.mounts.push(mount);
+					}
+					return mountRoot;
+				},
+				unmount(mountpoint) {
+					var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+					if (!FS.isMountpoint(lookup.node)) throw new FS.ErrnoError(28);
+					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;
+					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) {
+					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);
+					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);
+				},
+				statfs(path) {
+					return FS.statfsNode(FS.lookupPath(path, { follow: true }).node);
+				},
+				statfsStream(stream) {
+					return FS.statfsNode(stream.node);
+				},
+				statfsNode(node) {
+					var rtn = {
+						bsize: 4096,
+						frsize: 4096,
+						blocks: 1e6,
+						bfree: 5e5,
+						bavail: 5e5,
+						files: FS.nextInode,
+						ffree: FS.nextInode - 1,
+						fsid: 42,
+						flags: 2,
+						namelen: 255
+					};
+					if (node.node_ops.statfs) Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
+					return rtn;
+				},
+				create(path, mode = 438) {
+					mode &= 4095;
+					mode |= 32768;
+					return FS.mknod(path, mode, 0);
+				},
+				mkdir(path, mode = 511) {
+					mode &= 1023;
+					mode |= 16384;
+					return FS.mknod(path, mode, 0);
+				},
+				mkdirTree(path, mode) {
+					var dirs = path.split("/");
+					var d = "";
+					for (var dir of dirs) {
+						if (!dir) continue;
+						if (d || PATH.isAbs(path)) d += "/";
+						d += dir;
+						try {
+							FS.mkdir(d, mode);
+						} catch (e) {
+							if (e.errno != 20) throw e;
+						}
+					}
+				},
+				mkdev(path, mode, dev) {
+					if (typeof dev == "undefined") {
+						dev = mode;
+						mode = 438;
+					}
+					mode |= 8192;
+					return FS.mknod(path, mode, dev);
+				},
+				symlink(oldpath, newpath) {
+					if (!PATH_FS.resolve(oldpath)) throw new FS.ErrnoError(44);
+					var parent = FS.lookupPath(newpath, { parent: true }).node;
+					if (!parent) throw new FS.ErrnoError(44);
+					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) {
+					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);
+					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);
+					var new_node;
+					try {
+						new_node = FS.lookupNode(new_dir, new_name);
+					} catch (e) {}
+					if (old_node === new_node) return;
+					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);
+					if (!old_dir.node_ops.rename) throw new FS.ErrnoError(63);
+					if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) throw new FS.ErrnoError(10);
+					if (new_dir !== old_dir) {
+						errCode = FS.nodePermissions(old_dir, "w");
+						if (errCode) throw new FS.ErrnoError(errCode);
+					}
+					FS.hashRemoveNode(old_node);
+					try {
+						old_dir.node_ops.rename(old_node, new_dir, new_name);
+						old_node.parent = new_dir;
+					} catch (e) {
+						throw e;
+					} finally {
+						FS.hashAddNode(old_node);
+					}
+				},
+				rmdir(path) {
+					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);
+					parent.node_ops.rmdir(parent, name);
+					FS.destroyNode(node);
+				},
+				readdir(path) {
+					var node = FS.lookupPath(path, { follow: true }).node;
+					return FS.checkOpExists(node.node_ops.readdir, 54)(node);
+				},
+				unlink(path) {
+					var parent = FS.lookupPath(path, { parent: true }).node;
+					if (!parent) throw new FS.ErrnoError(44);
+					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);
+					parent.node_ops.unlink(parent, name);
+					FS.destroyNode(node);
+				},
+				readlink(path) {
+					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) {
+					var node = FS.lookupPath(path, { follow: !dontFollow }).node;
+					return FS.checkOpExists(node.node_ops.getattr, 63)(node);
+				},
+				fstat(fd) {
+					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);
+				},
+				lstat(path) {
+					return FS.stat(path, true);
+				},
+				doChmod(stream, node, mode, dontFollow) {
+					FS.doSetAttr(stream, node, {
+						mode: mode & 4095 | node.mode & -4096,
+						ctime: Date.now(),
+						dontFollow
+					});
+				},
+				chmod(path, mode, dontFollow) {
+					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) {
+					var stream = FS.getStreamChecked(fd);
+					FS.doChmod(stream, stream.node, mode, false);
+				},
+				doChown(stream, node, dontFollow) {
+					FS.doSetAttr(stream, node, {
+						timestamp: Date.now(),
+						dontFollow
+					});
+				},
+				chown(path, uid, gid, dontFollow) {
+					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) {
+					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);
+					var errCode = FS.nodePermissions(node, "w");
+					if (errCode) throw new FS.ErrnoError(errCode);
+					FS.doSetAttr(stream, node, {
+						size: len,
+						timestamp: Date.now()
+					});
+				},
+				truncate(path, len) {
+					if (len < 0) throw new FS.ErrnoError(28);
+					var node;
+					if (typeof path == "string") node = FS.lookupPath(path, { follow: true }).node;
+					else node = path;
+					FS.doTruncate(null, node, len);
+				},
+				ftruncate(fd, len) {
+					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) {
+					var node = FS.lookupPath(path, { follow: true }).node;
+					FS.checkOpExists(node.node_ops.setattr, 63)(node, {
+						atime,
+						mtime
+					});
+				},
+				open(path, flags, mode = 438) {
+					if (path === "") throw new FS.ErrnoError(44);
+					flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+					if (flags & 64) mode = mode & 4095 | 32768;
+					else mode = 0;
+					var node;
+					var isDirPath;
+					if (typeof path == "object") node = path;
+					else {
+						isDirPath = path.endsWith("/");
+						var lookup = FS.lookupPath(path, {
+							follow: !(flags & 131072),
+							noent_okay: true
+						});
+						node = lookup.node;
+						path = lookup.path;
+					}
+					var created = false;
+					if (flags & 64) if (node) {
+						if (flags & 128) throw new FS.ErrnoError(20);
+					} else if (isDirPath) throw new FS.ErrnoError(31);
+					else {
+						node = FS.mknod(path, mode | 511, 0);
+						created = true;
+					}
+					if (!node) throw new FS.ErrnoError(44);
+					if (FS.isChrdev(node.mode)) flags &= -513;
+					if (flags & 65536 && !FS.isDir(node.mode)) throw new FS.ErrnoError(54);
+					if (!created) {
+						var errCode = FS.mayOpen(node, flags);
+						if (errCode) throw new FS.ErrnoError(errCode);
+					}
+					if (flags & 512 && !created) FS.truncate(node, 0);
+					flags &= -131713;
+					var stream = FS.createStream({
+						node,
+						path: FS.getPath(node),
+						flags,
+						seekable: true,
+						position: 0,
+						stream_ops: node.stream_ops,
+						ungotten: [],
+						error: false
+					});
+					if (stream.stream_ops.open) stream.stream_ops.open(stream);
+					if (created) FS.chmod(node, mode & 511);
+					return stream;
+				},
+				close(stream) {
+					if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+					if (stream.getdents) stream.getdents = null;
+					try {
+						if (stream.stream_ops.close) stream.stream_ops.close(stream);
+					} catch (e) {
+						throw e;
+					} finally {
+						FS.closeStream(stream.fd);
+					}
+					stream.fd = null;
+				},
+				isClosed(stream) {
+					return stream.fd === null;
+				},
+				llseek(stream, offset, whence) {
+					if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+					if (!stream.seekable || !stream.stream_ops.llseek) throw new FS.ErrnoError(70);
+					if (whence != 0 && whence != 1 && whence != 2) throw new FS.ErrnoError(28);
+					stream.position = stream.stream_ops.llseek(stream, offset, whence);
+					stream.ungotten = [];
+					return stream.position;
+				},
+				read(stream, buffer, offset, length, position) {
+					if (length < 0 || position < 0) throw new FS.ErrnoError(28);
+					if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+					if ((stream.flags & 2097155) === 1) throw new FS.ErrnoError(8);
+					if (FS.isDir(stream.node.mode)) throw new FS.ErrnoError(31);
+					if (!stream.stream_ops.read) throw new FS.ErrnoError(28);
+					var seeking = typeof position != "undefined";
+					if (!seeking) position = stream.position;
+					else if (!stream.seekable) throw new FS.ErrnoError(70);
+					var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+					if (!seeking) stream.position += bytesRead;
+					return bytesRead;
+				},
+				write(stream, buffer, offset, length, position, canOwn) {
+					if (length < 0 || position < 0) throw new FS.ErrnoError(28);
+					if (FS.isClosed(stream)) throw new FS.ErrnoError(8);
+					if ((stream.flags & 2097155) === 0) throw new FS.ErrnoError(8);
+					if (FS.isDir(stream.node.mode)) throw new FS.ErrnoError(31);
+					if (!stream.stream_ops.write) throw new FS.ErrnoError(28);
+					if (stream.seekable && stream.flags & 1024) FS.llseek(stream, 0, 2);
+					var seeking = typeof position != "undefined";
+					if (!seeking) position = stream.position;
+					else if (!stream.seekable) throw new FS.ErrnoError(70);
+					var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+					if (!seeking) stream.position += bytesWritten;
+					return bytesWritten;
+				},
+				mmap(stream, length, position, prot, flags) {
+					if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) throw new FS.ErrnoError(2);
+					if ((stream.flags & 2097155) === 1) throw new FS.ErrnoError(2);
+					if (!stream.stream_ops.mmap) throw new FS.ErrnoError(43);
+					if (!length) throw new FS.ErrnoError(28);
+					return stream.stream_ops.mmap(stream, length, position, prot, flags);
+				},
+				msync(stream, buffer, offset, length, mmapFlags) {
+					if (!stream.stream_ops.msync) return 0;
+					return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
+				},
+				ioctl(stream, cmd, arg) {
+					if (!stream.stream_ops.ioctl) throw new FS.ErrnoError(59);
+					return stream.stream_ops.ioctl(stream, cmd, arg);
+				},
+				readFile(path, opts = {}) {
+					opts.flags = opts.flags || 0;
+					opts.encoding = opts.encoding || "binary";
+					if (opts.encoding !== "utf8" && opts.encoding !== "binary") abort(`Invalid encoding type "${opts.encoding}"`);
+					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);
+					return buf;
+				},
+				writeFile(path, data, opts = {}) {
+					opts.flags = opts.flags || 577;
+					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");
+					FS.close(stream);
+				},
+				cwd: () => FS.currentPath,
+				chdir(path) {
+					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);
+					var errCode = FS.nodePermissions(lookup.node, "x");
+					if (errCode) throw new FS.ErrnoError(errCode);
+					FS.currentPath = lookup.path;
+				},
+				createDefaultDirectories() {
+					FS.mkdir("/tmp");
+					FS.mkdir("/home");
+					FS.mkdir("/home/web_user");
+				},
+				createDefaultDevices() {
+					FS.mkdir("/dev");
+					FS.registerDevice(FS.makedev(1, 3), {
+						read: () => 0,
+						write: (stream, buffer, offset, length, pos) => length,
+						llseek: () => 0
+					});
+					FS.mkdev("/dev/null", FS.makedev(1, 3));
+					TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+					TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+					FS.mkdev("/dev/tty", FS.makedev(5, 0));
+					FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+					var randomBuffer = new Uint8Array(1024), randomLeft = 0;
+					var randomByte = () => {
+						if (randomLeft === 0) {
+							randomFill(randomBuffer);
+							randomLeft = randomBuffer.byteLength;
+						}
+						return randomBuffer[--randomLeft];
+					};
+					FS.createDevice("/dev", "random", randomByte);
+					FS.createDevice("/dev", "urandom", randomByte);
+					FS.mkdir("/dev/shm");
+					FS.mkdir("/dev/shm/tmp");
+				},
+				createSpecialDirectories() {
+					FS.mkdir("/proc");
+					var proc_self = FS.mkdir("/proc/self");
+					FS.mkdir("/proc/self/fd");
+					FS.mount({ mount() {
+						var node = FS.createNode(proc_self, "fd", 16895, 73);
+						node.stream_ops = { llseek: MEMFS.stream_ops.llseek };
+						node.node_ops = {
+							lookup(parent, name) {
+								var fd = +name;
+								var stream = FS.getStreamChecked(fd);
+								var ret = {
+									parent: null,
+									mount: { mountpoint: "fake" },
+									node_ops: { readlink: () => stream.path },
+									id: fd + 1
+								};
+								ret.parent = ret;
+								return ret;
+							},
+							readdir() {
+								return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString());
+							}
+						};
+						return node;
+					} }, {}, "/proc/self/fd");
+				},
+				createStandardStreams(input, output, error) {
+					if (input) FS.createDevice("/dev", "stdin", input);
+					else FS.symlink("/dev/tty", "/dev/stdin");
+					if (output) FS.createDevice("/dev", "stdout", null, output);
+					else FS.symlink("/dev/tty", "/dev/stdout");
+					if (error) FS.createDevice("/dev", "stderr", null, error);
+					else FS.symlink("/dev/tty1", "/dev/stderr");
+					FS.open("/dev/stdin", 0);
+					FS.open("/dev/stdout", 1);
+					FS.open("/dev/stderr", 1);
+				},
+				staticInit() {
+					FS.nameTable = new Array(4096);
+					FS.mount(MEMFS, {}, "/");
+					FS.createDefaultDirectories();
+					FS.createDefaultDevices();
+					FS.createSpecialDirectories();
+					FS.filesystems = { MEMFS };
+				},
+				init(input, output, error) {
+					FS.initialized = true;
+					input ??= Module["stdin"];
+					output ??= Module["stdout"];
+					error ??= Module["stderr"];
+					FS.createStandardStreams(input, output, error);
+				},
+				quit() {
+					FS.initialized = false;
+					for (var stream of FS.streams) if (stream) FS.close(stream);
+				},
+				findObject(path, dontResolveLastLink) {
+					var ret = FS.analyzePath(path, dontResolveLastLink);
+					if (!ret.exists) return null;
+					return ret.object;
+				},
+				analyzePath(path, dontResolveLastLink) {
+					try {
+						var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+						path = lookup.path;
+					} catch (e) {}
+					var ret = {
+						isRoot: false,
+						exists: false,
+						error: 0,
+						name: null,
+						path: null,
+						object: null,
+						parentExists: false,
+						parentPath: null,
+						parentObject: null
+					};
+					try {
+						var lookup = FS.lookupPath(path, { parent: true });
+						ret.parentExists = true;
+						ret.parentPath = lookup.path;
+						ret.parentObject = lookup.node;
+						ret.name = PATH.basename(path);
+						lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+						ret.exists = true;
+						ret.path = lookup.path;
+						ret.object = lookup.node;
+						ret.name = lookup.node.name;
+						ret.isRoot = lookup.path === "/";
+					} catch (e) {
+						ret.error = e.errno;
+					}
+					return ret;
+				},
+				createPath(parent, path, canRead, canWrite) {
+					parent = typeof parent == "string" ? parent : FS.getPath(parent);
+					var parts = path.split("/").reverse();
+					while (parts.length) {
+						var part = parts.pop();
+						if (!part) continue;
+						var current = PATH.join2(parent, part);
+						try {
+							FS.mkdir(current);
+						} catch (e) {
+							if (e.errno != 20) throw e;
+						}
+						parent = current;
+					}
+					return current;
+				},
+				createFile(parent, name, properties, canRead, canWrite) {
+					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) {
+					var path = name;
+					if (parent) {
+						parent = typeof parent == "string" ? parent : FS.getPath(parent);
+						path = name ? PATH.join2(parent, name) : parent;
+					}
+					var mode = FS_getMode(canRead, canWrite);
+					var node = FS.create(path, mode);
+					if (data) {
+						if (typeof data == "string") {
+							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);
+						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) {
+					var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+					var mode = FS_getMode(!!input, !!output);
+					FS.createDevice.major ??= 64;
+					var dev = FS.makedev(FS.createDevice.major++, 0);
+					FS.registerDevice(dev, {
+						open(stream) {
+							stream.seekable = false;
+						},
+						close(stream) {
+							if (output?.buffer?.length) output(10);
+						},
+						read(stream, buffer, offset, length, pos) {
+							var bytesRead = 0;
+							for (var i = 0; i < length; i++) {
+								var result;
+								try {
+									result = input();
+								} catch (e) {
+									throw new FS.ErrnoError(29);
+								}
+								if (result === void 0 && bytesRead === 0) throw new FS.ErrnoError(6);
+								if (result === null || result === void 0) break;
+								bytesRead++;
+								buffer[offset + i] = result;
+							}
+							if (bytesRead) stream.node.atime = Date.now();
+							return bytesRead;
+						},
+						write(stream, buffer, offset, length, pos) {
+							for (var i = 0; i < length; i++) try {
+								output(buffer[offset + i]);
+							} catch (e) {
+								throw new FS.ErrnoError(29);
+							}
+							if (length) stream.node.mtime = stream.node.ctime = Date.now();
+							return i;
+						}
+					});
+					return FS.mkdev(path, mode, dev);
+				},
+				forceLoadFile(obj) {
+					if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+					if (globalThis.XMLHttpRequest) abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+					else try {
+						obj.contents = readBinary(obj.url);
+					} catch (e) {
+						throw new FS.ErrnoError(29);
+					}
+				},
+				createLazyFile(parent, name, url, canRead, canWrite) {
+					class LazyUint8Array {
+						lengthKnown = false;
+						chunks = [];
+						get(idx) {
+							if (idx > this.length - 1 || idx < 0) return;
+							var chunkOffset = idx % this.chunkSize;
+							var chunkNum = idx / this.chunkSize | 0;
+							return this.getter(chunkNum)[chunkOffset];
+						}
+						setDataGetter(getter) {
+							this.getter = getter;
+						}
+						cacheLength() {
+							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);
+							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;
+							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$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 lazyArray = this;
+							lazyArray.setDataGetter((chunkNum) => {
+								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!");
+								return lazyArray.chunks[chunkNum];
+							});
+							if (usesGzip || !datalength) {
+								chunkSize = datalength = 1;
+								datalength = this.getter(0).length;
+								chunkSize = datalength;
+								out("LazyFiles on gzip forces download of the whole file when length is accessed");
+							}
+							this._length = datalength;
+							this._chunkSize = chunkSize;
+							this.lengthKnown = true;
+						}
+						get length() {
+							if (!this.lengthKnown) this.cacheLength();
+							return this._length;
+						}
+						get chunkSize() {
+							if (!this.lengthKnown) this.cacheLength();
+							return this._chunkSize;
+						}
+					}
+					if (globalThis.XMLHttpRequest) {
+						if (!ENVIRONMENT_IS_WORKER) abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
+						var properties = {
+							isDevice: false,
+							contents: new LazyUint8Array()
+						};
+					} else var properties = {
+						isDevice: false,
+						url
+					};
+					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: function() {
+						return this.contents.length;
+					} } });
+					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) {
+						var contents = stream.node.contents;
+						if (position >= contents.length) return 0;
+						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;
+					}
+					stream_ops.read = (stream, buffer, offset, length, position) => {
+						FS.forceLoadFile(node);
+						return writeChunks(stream, buffer, offset, length, position);
+					};
+					stream_ops.mmap = (stream, length, position, prot, flags) => {
+						FS.forceLoadFile(node);
+						var ptr = mmapAlloc(length);
+						if (!ptr) throw new FS.ErrnoError(48);
+						writeChunks(stream, HEAP8, ptr, length, position);
+						return {
+							ptr,
+							allocated: true
+						};
+					};
+					node.stream_ops = stream_ops;
+					return node;
+				}
+			};
+			var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+				ptr >>>= 0;
+				return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+			};
+			var SYSCALLS = {
+				calculateAt(dirfd, path, allowEmpty) {
+					if (PATH.isAbs(path)) return path;
+					var dir;
+					if (dirfd === -100) dir = FS.cwd();
+					else dir = SYSCALLS.getStreamFromFD(dirfd).path;
+					if (path.length == 0) {
+						if (!allowEmpty) throw new FS.ErrnoError(44);
+						return dir;
+					}
+					return dir + "/" + path;
+				},
+				writeStat(buf, stat) {
+					HEAPU32[buf >>> 2 >>> 0] = stat.dev;
+					HEAPU32[buf + 4 >>> 2 >>> 0] = stat.mode;
+					HEAPU32[buf + 8 >>> 2 >>> 0] = stat.nlink;
+					HEAPU32[buf + 12 >>> 2 >>> 0] = stat.uid;
+					HEAPU32[buf + 16 >>> 2 >>> 0] = stat.gid;
+					HEAPU32[buf + 20 >>> 2 >>> 0] = stat.rdev;
+					HEAP64[buf + 24 >>> 3 >>> 0] = BigInt(stat.size);
+					HEAP32[buf + 32 >>> 2 >>> 0] = 4096;
+					HEAP32[buf + 36 >>> 2 >>> 0] = stat.blocks;
+					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));
+					HEAPU32[buf + 64 >>> 2 >>> 0] = mtime % 1e3 * 1e3 * 1e3;
+					HEAP64[buf + 72 >>> 3 >>> 0] = BigInt(Math.floor(ctime / 1e3));
+					HEAPU32[buf + 80 >>> 2 >>> 0] = ctime % 1e3 * 1e3 * 1e3;
+					HEAP64[buf + 88 >>> 3 >>> 0] = BigInt(stat.ino);
+					return 0;
+				},
+				writeStatFs(buf, stats) {
+					HEAPU32[buf + 4 >>> 2 >>> 0] = stats.bsize;
+					HEAPU32[buf + 60 >>> 2 >>> 0] = stats.bsize;
+					HEAP64[buf + 8 >>> 3 >>> 0] = BigInt(stats.blocks);
+					HEAP64[buf + 16 >>> 3 >>> 0] = BigInt(stats.bfree);
+					HEAP64[buf + 24 >>> 3 >>> 0] = BigInt(stats.bavail);
+					HEAP64[buf + 32 >>> 3 >>> 0] = BigInt(stats.files);
+					HEAP64[buf + 40 >>> 3 >>> 0] = BigInt(stats.ffree);
+					HEAPU32[buf + 48 >>> 2 >>> 0] = stats.fsid;
+					HEAPU32[buf + 64 >>> 2 >>> 0] = stats.flags;
+					HEAPU32[buf + 56 >>> 2 >>> 0] = stats.namelen;
+				},
+				doMsync(addr, stream, len, flags, offset) {
+					if (!FS.isFile(stream.node.mode)) throw new FS.ErrnoError(43);
+					if (flags & 2) return 0;
+					var buffer = HEAPU8.slice(addr, addr + len);
+					FS.msync(stream, buffer, offset, len, flags);
+				},
+				getStreamFromFD(fd) {
+					return FS.getStreamChecked(fd);
+				},
+				varargs: void 0,
+				getStr(ptr) {
+					return UTF8ToString(ptr);
+				}
+			};
+			var INT53_MAX = 9007199254740992;
+			var INT53_MIN = -9007199254740992;
+			var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+			function ___syscall_fcntl64(fd, cmd, varargs) {
+				varargs >>>= 0;
+				SYSCALLS.varargs = varargs;
+				try {
+					var stream = SYSCALLS.getStreamFromFD(fd);
+					switch (cmd) {
+						case 0:
+							var arg = syscallGetVarargI();
+							if (arg < 0) return -28;
+							while (FS.streams[arg]) arg++;
+							return FS.dupStream(stream, arg).fd;
+						case 1:
+						case 2: return 0;
+						case 3: return stream.flags;
+						case 4:
+							var arg = syscallGetVarargI();
+							stream.flags |= arg;
+							return 0;
+						case 12:
+							var arg = syscallGetVarargP();
+							var offset = 0;
+							HEAP16[arg + offset >>> 1 >>> 0] = 2;
+							return 0;
+						case 13:
+						case 14: return 0;
+					}
+					return -28;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			function ___syscall_fstat64(fd, buf) {
+				buf >>>= 0;
+				try {
+					return SYSCALLS.writeStat(buf, FS.fstat(fd));
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			function ___syscall_ioctl(fd, op, varargs) {
+				varargs >>>= 0;
+				SYSCALLS.varargs = varargs;
+				try {
+					var stream = SYSCALLS.getStreamFromFD(fd);
+					switch (op) {
+						case 21509:
+							if (!stream.tty) return -59;
+							return 0;
+						case 21505:
+							if (!stream.tty) return -59;
+							if (stream.tty.ops.ioctl_tcgets) {
+								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;
+								HEAP32[argp + 8 >>> 2 >>> 0] = termios.c_cflag || 0;
+								HEAP32[argp + 12 >>> 2 >>> 0] = termios.c_lflag || 0;
+								for (var i = 0; i < 32; i++) HEAP8[argp + i + 17 >>> 0] = termios.c_cc[i] || 0;
+								return 0;
+							}
+							return 0;
+						case 21510:
+						case 21511:
+						case 21512:
+							if (!stream.tty) return -59;
+							return 0;
+						case 21506:
+						case 21507:
+						case 21508:
+							if (!stream.tty) return -59;
+							if (stream.tty.ops.ioctl_tcsets) {
+								var argp = syscallGetVarargP();
+								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,
+									c_oflag,
+									c_cflag,
+									c_lflag,
+									c_cc
+								});
+							}
+							return 0;
+						case 21519:
+							if (!stream.tty) return -59;
+							var argp = syscallGetVarargP();
+							HEAP32[argp >>> 2 >>> 0] = 0;
+							return 0;
+						case 21520:
+							if (!stream.tty) return -59;
+							return -28;
+						case 21537:
+						case 21531:
+							var argp = syscallGetVarargP();
+							return FS.ioctl(stream, op, argp);
+						case 21523:
+							if (!stream.tty) return -59;
+							if (stream.tty.ops.ioctl_tiocgwinsz) {
+								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:
+							if (!stream.tty) return -59;
+							return 0;
+						case 21515:
+							if (!stream.tty) return -59;
+							return 0;
+						default: return -28;
+					}
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			function ___syscall_newfstatat(dirfd, path, buf, flags) {
+				path >>>= 0;
+				buf >>>= 0;
+				try {
+					path = SYSCALLS.getStr(path);
+					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));
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			function ___syscall_openat(dirfd, path, flags, varargs) {
+				path >>>= 0;
+				varargs >>>= 0;
+				SYSCALLS.varargs = varargs;
+				try {
+					path = SYSCALLS.getStr(path);
+					path = SYSCALLS.calculateAt(dirfd, path);
+					var mode = varargs ? syscallGetVarargI() : 0;
+					return FS.open(path, flags, mode).fd;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			var __abort_js = () => abort("");
+			var AsciiToString = (ptr) => {
+				ptr >>>= 0;
+				var str = "";
+				while (1) {
+					var ch = HEAPU8[ptr++ >>> 0];
+					if (!ch) return str;
+					str += String.fromCharCode(ch);
+				}
+			};
+			var awaitingDependencies = {};
+			var registeredTypes = {};
+			var typeDependencies = {};
+			var BindingError = class BindingError$1 extends Error {
+				constructor(message) {
+					super(message);
+					this.name = "BindingError";
+				}
+			};
+			var throwBindingError = (message) => {
+				throw new BindingError(message);
+			};
+			function sharedRegisterType(rawType, registeredInstance, options = {}) {
+				var name = registeredInstance.name;
+				if (!rawType) throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+				if (registeredTypes.hasOwnProperty(rawType)) if (options.ignoreDuplicateRegistrations) return;
+				else throwBindingError(`Cannot register type '${name}' twice`);
+				registeredTypes[rawType] = registeredInstance;
+				delete typeDependencies[rawType];
+				if (awaitingDependencies.hasOwnProperty(rawType)) {
+					var callbacks = awaitingDependencies[rawType];
+					delete awaitingDependencies[rawType];
+					callbacks.forEach((cb) => cb());
+				}
+			}
+			function registerType(rawType, registeredInstance, options = {}) {
+				return sharedRegisterType(rawType, registeredInstance, options);
+			}
+			var integerReadValueFromPointer = (name, width, signed) => {
+				switch (width) {
+					case 1: return signed ? (pointer) => HEAP8[pointer >>> 0] : (pointer) => HEAPU8[pointer >>> 0];
+					case 2: return signed ? (pointer) => HEAP16[pointer >>> 1 >>> 0] : (pointer) => HEAPU16[pointer >>> 1 >>> 0];
+					case 4: return signed ? (pointer) => HEAP32[pointer >>> 2 >>> 0] : (pointer) => HEAPU32[pointer >>> 2 >>> 0];
+					case 8: return signed ? (pointer) => HEAP64[pointer >>> 3 >>> 0] : (pointer) => HEAPU64[pointer >>> 3 >>> 0];
+					default: throw new TypeError(`invalid integer width (${width}): ${name}`);
+				}
+			};
+			var __embind_register_bigint = function(primitiveType, name, size, minRange, maxRange) {
+				primitiveType >>>= 0;
+				name >>>= 0;
+				size >>>= 0;
+				name = AsciiToString(name);
+				const isUnsignedType = minRange === 0n;
+				let fromWireType = (value) => value;
+				if (isUnsignedType) {
+					const bitSize = size * 8;
+					fromWireType = (value) => BigInt.asUintN(bitSize, value);
+					maxRange = fromWireType(maxRange);
+				}
+				registerType(primitiveType, {
+					name,
+					fromWireType,
+					toWireType: (destructors, value) => {
+						if (typeof value == "number") value = BigInt(value);
+						return value;
+					},
+					readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType),
+					destructorFunction: null
+				});
+			};
+			function __embind_register_bool(rawType, name, trueValue, falseValue) {
+				rawType >>>= 0;
+				name >>>= 0;
+				name = AsciiToString(name);
+				registerType(rawType, {
+					name,
+					fromWireType: function(wt) {
+						return !!wt;
+					},
+					toWireType: function(destructors, o) {
+						return o ? trueValue : falseValue;
+					},
+					readValueFromPointer: function(pointer) {
+						return this.fromWireType(HEAPU8[pointer >>> 0]);
+					},
+					destructorFunction: null
+				});
+			}
+			var shallowCopyInternalPointer = (o) => ({
+				count: o.count,
+				deleteScheduled: o.deleteScheduled,
+				preservePointerOnDelete: o.preservePointerOnDelete,
+				ptr: o.ptr,
+				ptrType: o.ptrType,
+				smartPtr: o.smartPtr,
+				smartPtrType: o.smartPtrType
+			});
+			var throwInstanceAlreadyDeleted = (obj) => {
+				function getInstanceTypeName(handle) {
+					return handle.$$.ptrType.registeredClass.name;
+				}
+				throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+			};
+			var finalizationRegistry = false;
+			var detachFinalizer = (handle) => {};
+			var runDestructor = ($$) => {
+				if ($$.smartPtr) $$.smartPtrType.rawDestructor($$.smartPtr);
+				else $$.ptrType.registeredClass.rawDestructor($$.ptr);
+			};
+			var releaseClassHandle = ($$) => {
+				$$.count.value -= 1;
+				if (0 === $$.count.value) runDestructor($$);
+			};
+			var attachFinalizer = (handle) => {
+				if (!globalThis.FinalizationRegistry) {
+					attachFinalizer = (handle$1) => handle$1;
+					return handle;
+				}
+				finalizationRegistry = new FinalizationRegistry((info) => {
+					releaseClassHandle(info.$$);
+				});
+				attachFinalizer = (handle$1) => {
+					var $$ = handle$1.$$;
+					if (!!$$.smartPtr) {
+						var info = { $$ };
+						finalizationRegistry.register(handle$1, info, handle$1);
+					}
+					return handle$1;
+				};
+				detachFinalizer = (handle$1) => finalizationRegistry.unregister(handle$1);
+				return attachFinalizer(handle);
+			};
+			var deletionQueue = [];
+			var flushPendingDeletes = () => {
+				while (deletionQueue.length) {
+					var obj = deletionQueue.pop();
+					obj.$$.deleteScheduled = false;
+					obj["delete"]();
+				}
+			};
+			var delayFunction;
+			var init_ClassHandle = () => {
+				let proto = ClassHandle.prototype;
+				Object.assign(proto, {
+					isAliasOf(other) {
+						if (!(this instanceof ClassHandle)) return false;
+						if (!(other instanceof ClassHandle)) return false;
+						var leftClass = this.$$.ptrType.registeredClass;
+						var left = this.$$.ptr;
+						other.$$ = other.$$;
+						var rightClass = other.$$.ptrType.registeredClass;
+						var right = other.$$.ptr;
+						while (leftClass.baseClass) {
+							left = leftClass.upcast(left);
+							leftClass = leftClass.baseClass;
+						}
+						while (rightClass.baseClass) {
+							right = rightClass.upcast(right);
+							rightClass = rightClass.baseClass;
+						}
+						return leftClass === rightClass && left === right;
+					},
+					clone() {
+						if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+						if (this.$$.preservePointerOnDelete) {
+							this.$$.count.value += 1;
+							return this;
+						} else {
+							var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
+							clone.$$.count.value += 1;
+							clone.$$.deleteScheduled = false;
+							return clone;
+						}
+					},
+					delete() {
+						if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+						if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) throwBindingError("Object already scheduled for deletion");
+						detachFinalizer(this);
+						releaseClassHandle(this.$$);
+						if (!this.$$.preservePointerOnDelete) {
+							this.$$.smartPtr = void 0;
+							this.$$.ptr = void 0;
+						}
+					},
+					isDeleted() {
+						return !this.$$.ptr;
+					},
+					deleteLater() {
+						if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+						if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) throwBindingError("Object already scheduled for deletion");
+						deletionQueue.push(this);
+						if (deletionQueue.length === 1 && delayFunction) delayFunction(flushPendingDeletes);
+						this.$$.deleteScheduled = true;
+						return this;
+					}
+				});
+				const symbolDispose = Symbol.dispose;
+				if (symbolDispose) proto[symbolDispose] = proto["delete"];
+			};
+			function ClassHandle() {}
+			var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
+			var registeredPointers = {};
+			var ensureOverloadTable = (proto, methodName, humanName) => {
+				if (void 0 === proto[methodName].overloadTable) {
+					var prevFunc = proto[methodName];
+					proto[methodName] = function(...args) {
+						if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
+						return proto[methodName].overloadTable[args.length].apply(this, args);
+					};
+					proto[methodName].overloadTable = [];
+					proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+				}
+			};
+			var exposePublicSymbol = (name, value, numArguments) => {
+				if (Module.hasOwnProperty(name)) {
+					if (void 0 === numArguments || void 0 !== Module[name].overloadTable && void 0 !== Module[name].overloadTable[numArguments]) throwBindingError(`Cannot register public name '${name}' twice`);
+					ensureOverloadTable(Module, name, name);
+					if (Module[name].overloadTable.hasOwnProperty(numArguments)) throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
+					Module[name].overloadTable[numArguments] = value;
+				} else {
+					Module[name] = value;
+					Module[name].argCount = numArguments;
+				}
+			};
+			var char_0 = 48;
+			var char_9 = 57;
+			var makeLegalFunctionName = (name) => {
+				name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+				var f = name.charCodeAt(0);
+				if (f >= char_0 && f <= char_9) return `_${name}`;
+				return name;
+			};
+			function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
+				this.name = name;
+				this.constructor = constructor;
+				this.instancePrototype = instancePrototype;
+				this.rawDestructor = rawDestructor;
+				this.baseClass = baseClass;
+				this.getActualType = getActualType;
+				this.upcast = upcast;
+				this.downcast = downcast;
+				this.pureVirtualFunctions = [];
+			}
+			var upcastPointer = (ptr, ptrClass, desiredClass) => {
+				while (ptrClass !== desiredClass) {
+					if (!ptrClass.upcast) throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
+					ptr = ptrClass.upcast(ptr);
+					ptrClass = ptrClass.baseClass;
+				}
+				return ptr;
+			};
+			var embindRepr = (v) => {
+				if (v === null) return "null";
+				var t = typeof v;
+				if (t === "object" || t === "array" || t === "function") return v.toString();
+				else return "" + v;
+			};
+			function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+				if (handle === null) {
+					if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+					return 0;
+				}
+				if (!handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+				if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+				var handleClass = handle.$$.ptrType.registeredClass;
+				return upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+			}
+			function genericPointerToWireType(destructors, handle) {
+				var ptr;
+				if (handle === null) {
+					if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+					if (this.isSmartPointer) {
+						ptr = this.rawConstructor();
+						if (destructors !== null) destructors.push(this.rawDestructor, ptr);
+						return ptr;
+					} else return 0;
+				}
+				if (!handle || !handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+				if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+				if (!this.isConst && handle.$$.ptrType.isConst) throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+				var handleClass = handle.$$.ptrType.registeredClass;
+				ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+				if (this.isSmartPointer) {
+					if (void 0 === handle.$$.smartPtr) throwBindingError("Passing raw pointer to smart pointer is illegal");
+					switch (this.sharingPolicy) {
+						case 0:
+							if (handle.$$.smartPtrType === this) ptr = handle.$$.smartPtr;
+							else throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+							break;
+						case 1:
+							ptr = handle.$$.smartPtr;
+							break;
+						case 2:
+							if (handle.$$.smartPtrType === this) ptr = handle.$$.smartPtr;
+							else {
+								var clonedHandle = handle["clone"]();
+								ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle["delete"]()));
+								if (destructors !== null) destructors.push(this.rawDestructor, ptr);
+							}
+							break;
+						default: throwBindingError("Unsupported sharing policy");
+					}
+				}
+				return ptr;
+			}
+			function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+				if (handle === null) {
+					if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+					return 0;
+				}
+				if (!handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+				if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+				if (handle.$$.ptrType.isConst) throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`);
+				var handleClass = handle.$$.ptrType.registeredClass;
+				return upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+			}
+			function readPointer(pointer) {
+				return this.fromWireType(HEAPU32[pointer >>> 2 >>> 0]);
+			}
+			var downcastPointer = (ptr, ptrClass, desiredClass) => {
+				if (ptrClass === desiredClass) return ptr;
+				if (void 0 === desiredClass.baseClass) return null;
+				var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+				if (rv === null) return null;
+				return desiredClass.downcast(rv);
+			};
+			var registeredInstances = {};
+			var getBasestPointer = (class_, ptr) => {
+				if (ptr === void 0) throwBindingError("ptr should not be undefined");
+				while (class_.baseClass) {
+					ptr = class_.upcast(ptr);
+					class_ = class_.baseClass;
+				}
+				return ptr;
+			};
+			var getInheritedInstance = (class_, ptr) => {
+				ptr = getBasestPointer(class_, ptr);
+				return registeredInstances[ptr];
+			};
+			var InternalError = class InternalError$1 extends Error {
+				constructor(message) {
+					super(message);
+					this.name = "InternalError";
+				}
+			};
+			var throwInternalError = (message) => {
+				throw new InternalError(message);
+			};
+			var makeClassHandle = (prototype, record) => {
+				if (!record.ptrType || !record.ptr) throwInternalError("makeClassHandle requires ptr and ptrType");
+				if (!!record.smartPtrType !== !!record.smartPtr) throwInternalError("Both smartPtrType and smartPtr must be specified");
+				record.count = { value: 1 };
+				return attachFinalizer(Object.create(prototype, { $$: {
+					value: record,
+					writable: true
+				} }));
+			};
+			function RegisteredPointer_fromWireType(ptr) {
+				var rawPointer = this.getPointee(ptr);
+				if (!rawPointer) {
+					this.destructor(ptr);
+					return null;
+				}
+				var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+				if (void 0 !== registeredInstance) if (0 === registeredInstance.$$.count.value) {
+					registeredInstance.$$.ptr = rawPointer;
+					registeredInstance.$$.smartPtr = ptr;
+					return registeredInstance["clone"]();
+				} else {
+					var rv = registeredInstance["clone"]();
+					this.destructor(ptr);
+					return rv;
+				}
+				function makeDefaultHandle() {
+					if (this.isSmartPointer) return makeClassHandle(this.registeredClass.instancePrototype, {
+						ptrType: this.pointeeType,
+						ptr: rawPointer,
+						smartPtrType: this,
+						smartPtr: ptr
+					});
+					else return makeClassHandle(this.registeredClass.instancePrototype, {
+						ptrType: this,
+						ptr
+					});
+				}
+				var registeredPointerRecord = registeredPointers[this.registeredClass.getActualType(rawPointer)];
+				if (!registeredPointerRecord) return makeDefaultHandle.call(this);
+				var toType;
+				if (this.isConst) toType = registeredPointerRecord.constPointerType;
+				else toType = registeredPointerRecord.pointerType;
+				var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
+				if (dp === null) return makeDefaultHandle.call(this);
+				if (this.isSmartPointer) return makeClassHandle(toType.registeredClass.instancePrototype, {
+					ptrType: toType,
+					ptr: dp,
+					smartPtrType: this,
+					smartPtr: ptr
+				});
+				else return makeClassHandle(toType.registeredClass.instancePrototype, {
+					ptrType: toType,
+					ptr: dp
+				});
+			}
+			var init_RegisteredPointer = () => {
+				Object.assign(RegisteredPointer.prototype, {
+					getPointee(ptr) {
+						if (this.rawGetPointee) ptr = this.rawGetPointee(ptr);
+						return ptr;
+					},
+					destructor(ptr) {
+						this.rawDestructor?.(ptr);
+					},
+					readValueFromPointer: readPointer,
+					fromWireType: RegisteredPointer_fromWireType
+				});
+			};
+			function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+				this.name = name;
+				this.registeredClass = registeredClass;
+				this.isReference = isReference;
+				this.isConst = isConst;
+				this.isSmartPointer = isSmartPointer;
+				this.pointeeType = pointeeType;
+				this.sharingPolicy = sharingPolicy;
+				this.rawGetPointee = rawGetPointee;
+				this.rawConstructor = rawConstructor;
+				this.rawShare = rawShare;
+				this.rawDestructor = rawDestructor;
+				if (!isSmartPointer && registeredClass.baseClass === void 0) if (isConst) {
+					this.toWireType = constNoSmartPtrRawPointerToWireType;
+					this.destructorFunction = null;
+				} else {
+					this.toWireType = nonConstNoSmartPtrRawPointerToWireType;
+					this.destructorFunction = null;
+				}
+				else this.toWireType = genericPointerToWireType;
+			}
+			var replacePublicSymbol = (name, value, numArguments) => {
+				if (!Module.hasOwnProperty(name)) throwInternalError("Replacing nonexistent public symbol");
+				if (void 0 !== Module[name].overloadTable && void 0 !== numArguments) Module[name].overloadTable[numArguments] = value;
+				else {
+					Module[name] = value;
+					Module[name].argCount = numArguments;
+				}
+			};
+			var wasmTableMirror = [];
+			var getWasmTableEntry = (funcPtr) => {
+				var func = wasmTableMirror[funcPtr];
+				if (!func) wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+				return func;
+			};
+			var dynCall = (sig, ptr, args = [], promising = false) => {
+				var rtn = getWasmTableEntry(ptr)(...args);
+				function convert(rtn$1) {
+					return sig[0] == "p" ? rtn$1 >>> 0 : rtn$1;
+				}
+				return convert(rtn);
+			};
+			var getDynCaller = (sig, ptr, promising = false) => (...args) => dynCall(sig, ptr, args, promising);
+			var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
+				signature = AsciiToString(signature);
+				function makeDynCaller() {
+					if (signature.includes("p")) return getDynCaller(signature, rawFunction, isAsync);
+					return getWasmTableEntry(rawFunction);
+				}
+				var fp = makeDynCaller();
+				if (typeof fp != "function") throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
+				return fp;
+			};
+			class UnboundTypeError extends Error {}
+			var getTypeName = (type) => {
+				var ptr = ___getTypeName(type);
+				var rv = AsciiToString(ptr);
+				_free(ptr);
+				return rv;
+			};
+			var throwUnboundTypeError = (message, types) => {
+				var unboundTypes = [];
+				var seen = {};
+				function visit(type) {
+					if (seen[type]) return;
+					if (registeredTypes[type]) return;
+					if (typeDependencies[type]) {
+						typeDependencies[type].forEach(visit);
+						return;
+					}
+					unboundTypes.push(type);
+					seen[type] = true;
+				}
+				types.forEach(visit);
+				throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
+			};
+			var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+				myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
+				function onComplete(typeConverters$1) {
+					var myTypeConverters = getTypeConverters(typeConverters$1);
+					if (myTypeConverters.length !== myTypes.length) throwInternalError("Mismatched type converter count");
+					for (var i = 0; i < myTypes.length; ++i) registerType(myTypes[i], myTypeConverters[i]);
+				}
+				var typeConverters = new Array(dependentTypes.length);
+				var unregisteredTypes = [];
+				var registered = 0;
+				for (let [i, dt] of dependentTypes.entries()) if (registeredTypes.hasOwnProperty(dt)) typeConverters[i] = registeredTypes[dt];
+				else {
+					unregisteredTypes.push(dt);
+					if (!awaitingDependencies.hasOwnProperty(dt)) awaitingDependencies[dt] = [];
+					awaitingDependencies[dt].push(() => {
+						typeConverters[i] = registeredTypes[dt];
+						++registered;
+						if (registered === unregisteredTypes.length) onComplete(typeConverters);
+					});
+				}
+				if (0 === unregisteredTypes.length) onComplete(typeConverters);
+			};
+			function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
+				rawType >>>= 0;
+				rawPointerType >>>= 0;
+				rawConstPointerType >>>= 0;
+				baseClassRawType >>>= 0;
+				getActualTypeSignature >>>= 0;
+				getActualType >>>= 0;
+				upcastSignature >>>= 0;
+				upcast >>>= 0;
+				downcastSignature >>>= 0;
+				downcast >>>= 0;
+				name >>>= 0;
+				destructorSignature >>>= 0;
+				rawDestructor >>>= 0;
+				name = AsciiToString(name);
+				getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+				upcast &&= embind__requireFunction(upcastSignature, upcast);
+				downcast &&= embind__requireFunction(downcastSignature, downcast);
+				rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+				var legalFunctionName = makeLegalFunctionName(name);
+				exposePublicSymbol(legalFunctionName, function() {
+					throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]);
+				});
+				whenDependentTypesAreResolved([
+					rawType,
+					rawPointerType,
+					rawConstPointerType
+				], baseClassRawType ? [baseClassRawType] : [], (base) => {
+					base = base[0];
+					var baseClass;
+					var basePrototype;
+					if (baseClassRawType) {
+						baseClass = base.registeredClass;
+						basePrototype = baseClass.instancePrototype;
+					} else basePrototype = ClassHandle.prototype;
+					var constructor = createNamedFunction(name, function(...args) {
+						if (Object.getPrototypeOf(this) !== instancePrototype) throw new BindingError(`Use 'new' to construct ${name}`);
+						if (void 0 === registeredClass.constructor_body) throw new BindingError(`${name} has no accessible constructor`);
+						var body = registeredClass.constructor_body[args.length];
+						if (void 0 === body) throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
+						return body.apply(this, args);
+					});
+					var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } });
+					constructor.prototype = instancePrototype;
+					var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+					if (registeredClass.baseClass) {
+						registeredClass.baseClass.__derivedClasses ??= [];
+						registeredClass.baseClass.__derivedClasses.push(registeredClass);
+					}
+					var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
+					var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
+					var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
+					registeredPointers[rawType] = {
+						pointerType: pointerConverter,
+						constPointerType: constPointerConverter
+					};
+					replacePublicSymbol(legalFunctionName, constructor);
+					return [
+						referenceConverter,
+						pointerConverter,
+						constPointerConverter
+					];
+				});
+			}
+			var heap32VectorToArray = (count, firstElement) => {
+				var array = [];
+				for (var i = 0; i < count; i++) array.push(HEAPU32[firstElement + i * 4 >>> 2 >>> 0]);
+				return array;
+			};
+			var runDestructors = (destructors) => {
+				while (destructors.length) {
+					var ptr = destructors.pop();
+					destructors.pop()(ptr);
+				}
+			};
+			function usesDestructorStack(argTypes) {
+				for (var i = 1; i < argTypes.length; ++i) if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) return true;
+				return false;
+			}
+			function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+				var needsDestructorStack = usesDestructorStack(argTypes);
+				var argCount = argTypes.length - 2;
+				var argsList = [];
+				var argsListWired = ["fn"];
+				if (isClassMethodFunc) argsListWired.push("thisWired");
+				for (var i = 0; i < argCount; ++i) {
+					argsList.push(`arg${i}`);
+					argsListWired.push(`arg${i}Wired`);
+				}
+				argsList = argsList.join(",");
+				argsListWired = argsListWired.join(",");
+				var invokerFnBody = `return function (${argsList}) {\n`;
+				if (needsDestructorStack) invokerFnBody += "var destructors = [];\n";
+				var dtorStack = needsDestructorStack ? "destructors" : "null";
+				var args1 = [
+					"humanName",
+					"throwBindingError",
+					"invoker",
+					"fn",
+					"runDestructors",
+					"fromRetWire",
+					"toClassParamWire"
+				];
+				if (isClassMethodFunc) invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`;
+				for (var i = 0; i < argCount; ++i) {
+					var argName = `toArg${i}Wire`;
+					invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`;
+					args1.push(argName);
+				}
+				invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`;
+				if (needsDestructorStack) invokerFnBody += "runDestructors(destructors);\n";
+				else for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+					var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+					if (argTypes[i].destructorFunction !== null) {
+						invokerFnBody += `${paramName}_dtor(${paramName});\n`;
+						args1.push(`${paramName}_dtor`);
+					}
+				}
+				if (returns) invokerFnBody += "var ret = fromRetWire(rv);\nreturn ret;\n";
+				invokerFnBody += "}\n";
+				return new Function(args1, invokerFnBody);
+			}
+			function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
+				var argCount = argTypes.length;
+				if (argCount < 2) throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+				var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+				var needsDestructorStack = usesDestructorStack(argTypes);
+				var returns = !argTypes[0].isVoid;
+				var retType = argTypes[0];
+				var instType = argTypes[1];
+				var closureArgs = [
+					humanName,
+					throwBindingError,
+					cppInvokerFunc,
+					cppTargetFunc,
+					runDestructors,
+					retType.fromWireType.bind(retType),
+					instType?.toWireType.bind(instType)
+				];
+				for (var i = 2; i < argCount; ++i) {
+					var argType = argTypes[i];
+					closureArgs.push(argType.toWireType.bind(argType));
+				}
+				if (!needsDestructorStack) {
+					for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) if (argTypes[i].destructorFunction !== null) closureArgs.push(argTypes[i].destructorFunction);
+				}
+				return createNamedFunction(humanName, createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync)(...closureArgs));
+			}
+			var __embind_register_class_constructor = function(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+				rawClassType >>>= 0;
+				rawArgTypesAddr >>>= 0;
+				invokerSignature >>>= 0;
+				invoker >>>= 0;
+				rawConstructor >>>= 0;
+				var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+				invoker = embind__requireFunction(invokerSignature, invoker);
+				whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+					classType = classType[0];
+					var humanName = `constructor ${classType.name}`;
+					if (void 0 === classType.registeredClass.constructor_body) classType.registeredClass.constructor_body = [];
+					if (void 0 !== classType.registeredClass.constructor_body[argCount - 1]) throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+					classType.registeredClass.constructor_body[argCount - 1] = () => {
+						throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes);
+					};
+					whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+						argTypes.splice(1, 0, null);
+						classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+						return [];
+					});
+					return [];
+				});
+			};
+			var getFunctionName = (signature) => {
+				signature = signature.trim();
+				const argsIndex = signature.indexOf("(");
+				if (argsIndex === -1) return signature;
+				return signature.slice(0, argsIndex);
+			};
+			var __embind_register_class_function = function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual, isAsync, isNonnullReturn) {
+				rawClassType >>>= 0;
+				methodName >>>= 0;
+				rawArgTypesAddr >>>= 0;
+				invokerSignature >>>= 0;
+				rawInvoker >>>= 0;
+				context >>>= 0;
+				var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+				methodName = AsciiToString(methodName);
+				methodName = getFunctionName(methodName);
+				rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync);
+				whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+					classType = classType[0];
+					var humanName = `${classType.name}.${methodName}`;
+					if (methodName.startsWith("@@")) methodName = Symbol[methodName.substring(2)];
+					if (isPureVirtual) classType.registeredClass.pureVirtualFunctions.push(methodName);
+					function unboundTypesHandler() {
+						throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes);
+					}
+					var proto = classType.registeredClass.instancePrototype;
+					var method = proto[methodName];
+					if (void 0 === method || void 0 === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
+						unboundTypesHandler.argCount = argCount - 2;
+						unboundTypesHandler.className = classType.name;
+						proto[methodName] = unboundTypesHandler;
+					} else {
+						ensureOverloadTable(proto, methodName, humanName);
+						proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+					}
+					whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+						var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync);
+						if (void 0 === proto[methodName].overloadTable) {
+							memberFunction.argCount = argCount - 2;
+							proto[methodName] = memberFunction;
+						} else proto[methodName].overloadTable[argCount - 2] = memberFunction;
+						return [];
+					});
+					return [];
+				});
+			};
+			var emval_freelist = [];
+			var emval_handles = [
+				0,
+				1,
+				,
+				1,
+				null,
+				1,
+				true,
+				1,
+				false,
+				1
+			];
+			function __emval_decref(handle) {
+				handle >>>= 0;
+				if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+					emval_handles[handle] = void 0;
+					emval_freelist.push(handle);
+				}
+			}
+			var Emval = {
+				toValue: (handle) => {
+					if (!handle) throwBindingError(`Cannot use deleted val. handle = ${handle}`);
+					return emval_handles[handle];
+				},
+				toHandle: (value) => {
+					switch (value) {
+						case void 0: return 2;
+						case null: return 4;
+						case true: return 6;
+						case false: return 8;
+						default: {
+							const handle = emval_freelist.pop() || emval_handles.length;
+							emval_handles[handle] = value;
+							emval_handles[handle + 1] = 1;
+							return handle;
+						}
+					}
+				}
+			};
+			var EmValType = {
+				name: "emscripten::val",
+				fromWireType: (handle) => {
+					var rv = Emval.toValue(handle);
+					__emval_decref(handle);
+					return rv;
+				},
+				toWireType: (destructors, value) => Emval.toHandle(value),
+				readValueFromPointer: readPointer,
+				destructorFunction: null
+			};
+			function __embind_register_emval(rawType) {
+				rawType >>>= 0;
+				return registerType(rawType, EmValType);
+			}
+			var floatReadValueFromPointer = (name, width) => {
+				switch (width) {
+					case 4: return function(pointer) {
+						return this.fromWireType(HEAPF32[pointer >>> 2 >>> 0]);
+					};
+					case 8: return function(pointer) {
+						return this.fromWireType(HEAPF64[pointer >>> 3 >>> 0]);
+					};
+					default: throw new TypeError(`invalid float width (${width}): ${name}`);
+				}
+			};
+			var __embind_register_float = function(rawType, name, size) {
+				rawType >>>= 0;
+				name >>>= 0;
+				size >>>= 0;
+				name = AsciiToString(name);
+				registerType(rawType, {
+					name,
+					fromWireType: (value) => value,
+					toWireType: (destructors, value) => value,
+					readValueFromPointer: floatReadValueFromPointer(name, size),
+					destructorFunction: null
+				});
+			};
+			function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) {
+				name >>>= 0;
+				rawArgTypesAddr >>>= 0;
+				signature >>>= 0;
+				rawInvoker >>>= 0;
+				fn >>>= 0;
+				var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+				name = AsciiToString(name);
+				name = getFunctionName(name);
+				rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync);
+				exposePublicSymbol(name, function() {
+					throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
+				}, argCount - 1);
+				whenDependentTypesAreResolved([], argTypes, (argTypes$1) => {
+					var invokerArgsArray = [argTypes$1[0], null].concat(argTypes$1.slice(1));
+					replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1);
+					return [];
+				});
+			}
+			var __embind_register_integer = function(primitiveType, name, size, minRange, maxRange) {
+				primitiveType >>>= 0;
+				name >>>= 0;
+				size >>>= 0;
+				name = AsciiToString(name);
+				const isUnsignedType = minRange === 0;
+				let fromWireType = (value) => value;
+				if (isUnsignedType) {
+					var bitshift = 32 - 8 * size;
+					fromWireType = (value) => value << bitshift >>> bitshift;
+					maxRange = fromWireType(maxRange);
+				}
+				registerType(primitiveType, {
+					name,
+					fromWireType,
+					toWireType: (destructors, value) => value,
+					readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0),
+					destructorFunction: null
+				});
+			};
+			var installIndexedIterator = (proto, sizeMethodName, getMethodName) => {
+				const makeIterator = (size, getValue) => {
+					let index = 0;
+					return {
+						next() {
+							if (index >= size) return { done: true };
+							const current = index;
+							index++;
+							return {
+								value: getValue(current),
+								done: false
+							};
+						},
+						[Symbol.iterator]() {
+							return this;
+						}
+					};
+				};
+				if (!proto[Symbol.iterator]) proto[Symbol.iterator] = function() {
+					return makeIterator(this[sizeMethodName](), (i) => this[getMethodName](i));
+				};
+			};
+			var __embind_register_iterable = function(rawClassType, rawElementType, sizeMethodName, getMethodName) {
+				rawClassType >>>= 0;
+				rawElementType >>>= 0;
+				sizeMethodName >>>= 0;
+				getMethodName >>>= 0;
+				sizeMethodName = AsciiToString(sizeMethodName);
+				getMethodName = AsciiToString(getMethodName);
+				whenDependentTypesAreResolved([], [rawClassType, rawElementType], (types) => {
+					const classType = types[0];
+					installIndexedIterator(classType.registeredClass.instancePrototype, sizeMethodName, getMethodName);
+					return [];
+				});
+			};
+			function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+				rawType >>>= 0;
+				name >>>= 0;
+				var TA = [
+					Int8Array,
+					Uint8Array,
+					Int16Array,
+					Uint16Array,
+					Int32Array,
+					Uint32Array,
+					Float32Array,
+					Float64Array,
+					BigInt64Array,
+					BigUint64Array
+				][dataTypeIndex];
+				function decodeMemoryView(handle) {
+					var size = HEAPU32[handle >>> 2 >>> 0];
+					var data = HEAPU32[handle + 4 >>> 2 >>> 0];
+					return new TA(HEAP8.buffer, data, size);
+				}
+				name = AsciiToString(name);
+				registerType(rawType, {
+					name,
+					fromWireType: decodeMemoryView,
+					readValueFromPointer: decodeMemoryView
+				}, { ignoreDuplicateRegistrations: true });
+			}
+			var EmValOptionalType = Object.assign({ optional: true }, EmValType);
+			function __embind_register_optional(rawOptionalType, rawType) {
+				rawOptionalType >>>= 0;
+				rawType >>>= 0;
+				registerType(rawOptionalType, EmValOptionalType);
+			}
+			var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+			function __embind_register_std_string(rawType, name) {
+				rawType >>>= 0;
+				name >>>= 0;
+				name = AsciiToString(name);
+				var stdStringIsUTF8 = true;
+				registerType(rawType, {
+					name,
+					fromWireType(value) {
+						var length = HEAPU32[value >>> 2 >>> 0];
+						var payload = value + 4;
+						var str;
+						if (stdStringIsUTF8) str = UTF8ToString(payload, length, true);
+						else {
+							str = "";
+							for (var i = 0; i < length; ++i) str += String.fromCharCode(HEAPU8[payload + i >>> 0]);
+						}
+						_free(value);
+						return str;
+					},
+					toWireType(destructors, value) {
+						if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+						var length;
+						var valueIsOfTypeString = typeof value == "string";
+						if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) throwBindingError("Cannot pass non-string to std::string");
+						if (stdStringIsUTF8 && valueIsOfTypeString) length = lengthBytesUTF8(value);
+						else length = value.length;
+						var base = _malloc(4 + length + 1);
+						var ptr = base + 4;
+						HEAPU32[base >>> 2 >>> 0] = length;
+						if (valueIsOfTypeString) if (stdStringIsUTF8) stringToUTF8(value, ptr, length + 1);
+						else for (var i = 0; i < length; ++i) {
+							var charCode = value.charCodeAt(i);
+							if (charCode > 255) {
+								_free(base);
+								throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+							}
+							HEAPU8[ptr + i >>> 0] = charCode;
+						}
+						else HEAPU8.set(value, ptr >>> 0);
+						if (destructors !== null) destructors.push(_free, base);
+						return base;
+					},
+					readValueFromPointer: readPointer,
+					destructorFunction(ptr) {
+						_free(ptr);
+					}
+				});
+			}
+			var UTF16Decoder = globalThis.TextDecoder ? new TextDecoder("utf-16le") : void 0;
+			var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => {
+				var idx = ptr >>> 1;
+				var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul);
+				if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx >>> 0, endIdx >>> 0));
+				var str = "";
+				for (var i = idx; i < endIdx; ++i) {
+					var codeUnit = HEAPU16[i >>> 0];
+					str += String.fromCharCode(codeUnit);
+				}
+				return str;
+			};
+			var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+				maxBytesToWrite ??= 2147483647;
+				if (maxBytesToWrite < 2) return 0;
+				maxBytesToWrite -= 2;
+				var startPtr = outPtr;
+				var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+				for (var i = 0; i < numCharsToWrite; ++i) {
+					var codeUnit = str.charCodeAt(i);
+					HEAP16[outPtr >>> 1 >>> 0] = codeUnit;
+					outPtr += 2;
+				}
+				HEAP16[outPtr >>> 1 >>> 0] = 0;
+				return outPtr - startPtr;
+			};
+			var lengthBytesUTF16 = (str) => str.length * 2;
+			var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => {
+				var str = "";
+				var startIdx = ptr >>> 2;
+				for (var i = 0; !(i >= maxBytesToRead / 4); i++) {
+					var utf32 = HEAPU32[startIdx + i >>> 0];
+					if (!utf32 && !ignoreNul) break;
+					str += String.fromCodePoint(utf32);
+				}
+				return str;
+			};
+			var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+				outPtr >>>= 0;
+				maxBytesToWrite ??= 2147483647;
+				if (maxBytesToWrite < 4) return 0;
+				var startPtr = outPtr;
+				var endPtr = startPtr + maxBytesToWrite - 4;
+				for (var i = 0; i < str.length; ++i) {
+					var codePoint = str.codePointAt(i);
+					if (codePoint > 65535) i++;
+					HEAP32[outPtr >>> 2 >>> 0] = codePoint;
+					outPtr += 4;
+					if (outPtr + 4 > endPtr) break;
+				}
+				HEAP32[outPtr >>> 2 >>> 0] = 0;
+				return outPtr - startPtr;
+			};
+			var lengthBytesUTF32 = (str) => {
+				var len = 0;
+				for (var i = 0; i < str.length; ++i) {
+					if (str.codePointAt(i) > 65535) i++;
+					len += 4;
+				}
+				return len;
+			};
+			function __embind_register_std_wstring(rawType, charSize, name) {
+				rawType >>>= 0;
+				charSize >>>= 0;
+				name >>>= 0;
+				name = AsciiToString(name);
+				var decodeString, encodeString, lengthBytesUTF;
+				if (charSize === 2) {
+					decodeString = UTF16ToString;
+					encodeString = stringToUTF16;
+					lengthBytesUTF = lengthBytesUTF16;
+				} else {
+					decodeString = UTF32ToString;
+					encodeString = stringToUTF32;
+					lengthBytesUTF = lengthBytesUTF32;
+				}
+				registerType(rawType, {
+					name,
+					fromWireType: (value) => {
+						var length = HEAPU32[value >>> 2 >>> 0];
+						var str = decodeString(value + 4, length * charSize, true);
+						_free(value);
+						return str;
+					},
+					toWireType: (destructors, value) => {
+						if (!(typeof value == "string")) throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
+						var length = lengthBytesUTF(value);
+						var ptr = _malloc(4 + length + charSize);
+						HEAPU32[ptr >>> 2 >>> 0] = length / charSize;
+						encodeString(value, ptr + 4, length + charSize);
+						if (destructors !== null) destructors.push(_free, ptr);
+						return ptr;
+					},
+					readValueFromPointer: readPointer,
+					destructorFunction(ptr) {
+						_free(ptr);
+					}
+				});
+			}
+			var __embind_register_void = function(rawType, name) {
+				rawType >>>= 0;
+				name >>>= 0;
+				name = AsciiToString(name);
+				registerType(rawType, {
+					isVoid: true,
+					name,
+					fromWireType: () => void 0,
+					toWireType: (destructors, o) => void 0
+				});
+			};
+			var emval_methodCallers = [];
+			var emval_addMethodCaller = (caller) => {
+				var id = emval_methodCallers.length;
+				emval_methodCallers.push(caller);
+				return id;
+			};
+			var requireRegisteredType = (rawType, humanName) => {
+				var impl = registeredTypes[rawType];
+				if (void 0 === impl) throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+				return impl;
+			};
+			var emval_lookupTypes = (argCount, argTypes) => {
+				var a = new Array(argCount);
+				for (var i = 0; i < argCount; ++i) a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >>> 2 >>> 0], `parameter ${i}`);
+				return a;
+			};
+			var emval_returnValue = (toReturnWire, destructorsRef, handle) => {
+				var destructors = [];
+				var result = toReturnWire(destructors, handle);
+				if (destructors.length) HEAPU32[destructorsRef >>> 2 >>> 0] = Emval.toHandle(destructors);
+				return result;
+			};
+			var emval_symbols = {};
+			var getStringOrSymbol = (address) => {
+				var symbol = emval_symbols[address];
+				if (symbol === void 0) return AsciiToString(address);
+				return symbol;
+			};
+			var __emval_create_invoker = function(argCount, argTypesPtr, kind) {
+				argTypesPtr >>>= 0;
+				var GenericWireTypeSize = 8;
+				var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr);
+				var toReturnWire = retType.toWireType.bind(retType);
+				var argFromPtr = argTypes.map((type) => type.readValueFromPointer.bind(type));
+				argCount--;
+				var captures = { toValue: Emval.toValue };
+				var args = argFromPtr.map((argFromPtr$1, i) => {
+					var captureName = `argFromPtr${i}`;
+					captures[captureName] = argFromPtr$1;
+					return `${captureName}(args${i ? "+" + i * GenericWireTypeSize : ""})`;
+				});
+				var functionBody;
+				switch (kind) {
+					case 0:
+						functionBody = "toValue(handle)";
+						break;
+					case 2:
+						functionBody = "new (toValue(handle))";
+						break;
+					case 3:
+						functionBody = "";
+						break;
+					case 1:
+						captures["getStringOrSymbol"] = getStringOrSymbol;
+						functionBody = "toValue(handle)[getStringOrSymbol(methodName)]";
+						break;
+				}
+				functionBody += `(${args})`;
+				if (!retType.isVoid) {
+					captures["toReturnWire"] = toReturnWire;
+					captures["emval_returnValue"] = emval_returnValue;
+					functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`;
+				}
+				functionBody = `return function (handle, methodName, destructorsRef, args) {\n${functionBody}\n}`;
+				var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures));
+				return emval_addMethodCaller(createNamedFunction(`methodCaller<(${argTypes.map((t) => t.name)}) => ${retType.name}>`, invokerFunction));
+			};
+			function __emval_get_global(name) {
+				name >>>= 0;
+				if (!name) return Emval.toHandle(globalThis);
+				name = getStringOrSymbol(name);
+				return Emval.toHandle(globalThis[name]);
+			}
+			function __emval_get_module_property(name) {
+				name >>>= 0;
+				name = getStringOrSymbol(name);
+				return Emval.toHandle(Module[name]);
+			}
+			function __emval_get_property(handle, key) {
+				handle >>>= 0;
+				key >>>= 0;
+				handle = Emval.toValue(handle);
+				key = Emval.toValue(key);
+				return Emval.toHandle(handle[key]);
+			}
+			function __emval_incref(handle) {
+				handle >>>= 0;
+				if (handle > 9) emval_handles[handle + 1] += 1;
+			}
+			function __emval_instanceof(object, constructor) {
+				object >>>= 0;
+				constructor >>>= 0;
+				object = Emval.toValue(object);
+				constructor = Emval.toValue(constructor);
+				return object instanceof constructor;
+			}
+			function __emval_invoke(caller, handle, methodName, destructorsRef, args) {
+				caller >>>= 0;
+				handle >>>= 0;
+				methodName >>>= 0;
+				destructorsRef >>>= 0;
+				args >>>= 0;
+				return emval_methodCallers[caller](handle, methodName, destructorsRef, args);
+			}
+			function __emval_new_array() {
+				return Emval.toHandle([]);
+			}
+			function __emval_new_cstring(v) {
+				v >>>= 0;
+				return Emval.toHandle(getStringOrSymbol(v));
+			}
+			function __emval_new_object() {
+				return Emval.toHandle({});
+			}
+			function __emval_run_destructors(handle) {
+				handle >>>= 0;
+				runDestructors(Emval.toValue(handle));
+				__emval_decref(handle);
+			}
+			function __emval_set_property(handle, key, value) {
+				handle >>>= 0;
+				key >>>= 0;
+				value >>>= 0;
+				handle = Emval.toValue(handle);
+				key = Emval.toValue(key);
+				value = Emval.toValue(value);
+				handle[key] = value;
+			}
+			function __emval_typeof(handle) {
+				handle >>>= 0;
+				handle = Emval.toValue(handle);
+				return Emval.toHandle(typeof handle);
+			}
+			var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+			var MONTH_DAYS_LEAP_CUMULATIVE = [
+				0,
+				31,
+				60,
+				91,
+				121,
+				152,
+				182,
+				213,
+				244,
+				274,
+				305,
+				335
+			];
+			var MONTH_DAYS_REGULAR_CUMULATIVE = [
+				0,
+				31,
+				59,
+				90,
+				120,
+				151,
+				181,
+				212,
+				243,
+				273,
+				304,
+				334
+			];
+			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;
+				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();
+				HEAP32[tmPtr + 12 >>> 2 >>> 0] = date.getDate();
+				HEAP32[tmPtr + 16 >>> 2 >>> 0] = date.getMonth();
+				HEAP32[tmPtr + 20 >>> 2 >>> 0] = date.getFullYear() - 1900;
+				HEAP32[tmPtr + 24 >>> 2 >>> 0] = date.getDay();
+				var yday = ydayFromDate(date) | 0;
+				HEAP32[tmPtr + 28 >>> 2 >>> 0] = yday;
+				HEAP32[tmPtr + 36 >>> 2 >>> 0] = -(date.getTimezoneOffset() * 60);
+				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) {
+				len >>>= 0;
+				offset = bigintToI53Checked(offset);
+				allocated >>>= 0;
+				addr >>>= 0;
+				try {
+					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;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return -e.errno;
+				}
+			}
+			function __munmap_js(addr, len, prot, flags, fd, offset) {
+				addr >>>= 0;
+				len >>>= 0;
+				offset = bigintToI53Checked(offset);
+				try {
+					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;
+				}
+			}
+			var __tzset_js = function(timezone, daylight, std_name, dst_name) {
+				timezone >>>= 0;
+				daylight >>>= 0;
+				std_name >>>= 0;
+				dst_name >>>= 0;
+				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);
+				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")}`;
+				};
+				var winterName = extractZone(winterOffset);
+				var summerName = extractZone(summerOffset);
+				if (summerOffset < winterOffset) {
+					stringToUTF8(winterName, std_name, 17);
+					stringToUTF8(summerName, dst_name, 17);
+				} else {
+					stringToUTF8(winterName, dst_name, 17);
+					stringToUTF8(summerName, std_name, 17);
+				}
+			};
+			var _emscripten_get_now = () => performance.now();
+			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;
+				var now;
+				if (clk_id === 0) now = _emscripten_date_now();
+				else if (nowIsMonotonic) now = _emscripten_get_now();
+				else return 52;
+				var nsec = Math.round(now * 1e3 * 1e3);
+				HEAP64[ptime >>> 3 >>> 0] = BigInt(nsec);
+				return 0;
+			}
+			var getHeapMax = () => 4294901760;
+			var growMemory = (size) => {
+				var pages = (size - wasmMemory.buffer.byteLength + 65535) / 65536 | 0;
+				try {
+					wasmMemory.grow(pages);
+					updateMemoryViews();
+					return 1;
+				} catch (e) {}
+			};
+			function _emscripten_resize_heap(requestedSize) {
+				requestedSize >>>= 0;
+				var oldSize = HEAPU8.length;
+				var maxHeapSize = getHeapMax();
+				if (requestedSize > maxHeapSize) return false;
+				for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+					var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+					overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+					if (growMemory(Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)))) return true;
+				}
+				return false;
+			}
+			var ENV = {};
+			var getExecutableName = () => thisProgram || "./this.program";
+			var getEnvStrings = () => {
+				if (!getEnvStrings.strings) {
+					var env = {
+						USER: "web_user",
+						LOGNAME: "web_user",
+						PATH: "/",
+						PWD: "/",
+						HOME: "/home/web_user",
+						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];
+					var strings = [];
+					for (var x in env) strings.push(`${x}=${env[x]}`);
+					getEnvStrings.strings = strings;
+				}
+				return getEnvStrings.strings;
+			};
+			function _environ_get(__environ, environ_buf) {
+				__environ >>>= 0;
+				environ_buf >>>= 0;
+				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;
+				}
+				return 0;
+			}
+			function _environ_sizes_get(penviron_count, penviron_buf_size) {
+				penviron_count >>>= 0;
+				penviron_buf_size >>>= 0;
+				var strings = getEnvStrings();
+				HEAPU32[penviron_count >>> 2 >>> 0] = strings.length;
+				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 {
+					var stream = SYSCALLS.getStreamFromFD(fd);
+					FS.close(stream);
+					return 0;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return e.errno;
+				}
+			}
+			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;
+					var curr = FS.read(stream, HEAP8, ptr, len, offset);
+					if (curr < 0) return -1;
+					ret += curr;
+					if (curr < len) break;
+					if (typeof offset != "undefined") offset += curr;
+				}
+				return ret;
+			};
+			function _fd_read(fd, iov, iovcnt, pnum) {
+				iov >>>= 0;
+				iovcnt >>>= 0;
+				pnum >>>= 0;
+				try {
+					var num = doReadv(SYSCALLS.getStreamFromFD(fd), iov, iovcnt);
+					HEAPU32[pnum >>> 2 >>> 0] = num;
+					return 0;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return e.errno;
+				}
+			}
+			function _fd_seek(fd, offset, whence, newOffset) {
+				offset = bigintToI53Checked(offset);
+				newOffset >>>= 0;
+				try {
+					if (isNaN(offset)) return 61;
+					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;
+					return 0;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return e.errno;
+				}
+			}
+			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;
+					var curr = FS.write(stream, HEAP8, ptr, len, offset);
+					if (curr < 0) return -1;
+					ret += curr;
+					if (curr < len) break;
+					if (typeof offset != "undefined") offset += curr;
+				}
+				return ret;
+			};
+			function _fd_write(fd, iov, iovcnt, pnum) {
+				iov >>>= 0;
+				iovcnt >>>= 0;
+				pnum >>>= 0;
+				try {
+					var num = doWritev(SYSCALLS.getStreamFromFD(fd), iov, iovcnt);
+					HEAPU32[pnum >>> 2 >>> 0] = num;
+					return 0;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return e.errno;
+				}
+			}
+			function _random_get(buffer, size) {
+				buffer >>>= 0;
+				size >>>= 0;
+				try {
+					randomFill(HEAPU8.subarray(buffer >>> 0, buffer + size >>> 0));
+					return 0;
+				} catch (e) {
+					if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+					return e.errno;
+				}
+			}
+			FS.createPreloadedFile = FS_createPreloadedFile;
+			FS.preloadFile = FS_preloadFile;
+			FS.staticInit();
+			init_ClassHandle();
+			init_RegisteredPointer();
+			if (Module["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()();
+			}
+			var ___getTypeName, _malloc, _free, _emscripten_builtin_memalign, _emscripten_stack_get_end, ___trap, _emscripten_stack_init, wasmMemory, wasmTable;
+			function assignWasmExports(wasmExports$1) {
+				___getTypeName = wasmExports$1["Z"];
+				_malloc = wasmExports$1["$"];
+				_free = wasmExports$1["aa"];
+				_emscripten_builtin_memalign = wasmExports$1["ba"];
+				_emscripten_stack_get_end = wasmExports$1["ca"];
+				___trap = wasmExports$1["da"];
+				_emscripten_stack_init = wasmExports$1["ea"];
+				wasmMemory = wasmExports$1["X"];
+				wasmTable = wasmExports$1["_"];
+			}
+			var wasmImports = {
+				r: ___syscall_fcntl64,
+				Q: ___syscall_fstat64,
+				R: ___syscall_ioctl,
+				P: ___syscall_newfstatat,
+				B: ___syscall_openat,
+				F: __abort_js,
+				E: __embind_register_bigint,
+				V: __embind_register_bool,
+				l: __embind_register_class,
+				p: __embind_register_class_constructor,
+				a: __embind_register_class_function,
+				T: __embind_register_emval,
+				D: __embind_register_float,
+				f: __embind_register_function,
+				k: __embind_register_integer,
+				x: __embind_register_iterable,
+				h: __embind_register_memory_view,
+				y: __embind_register_optional,
+				U: __embind_register_std_string,
+				t: __embind_register_std_wstring,
+				W: __embind_register_void,
+				d: __emval_create_invoker,
+				b: __emval_decref,
+				u: __emval_get_global,
+				m: __emval_get_module_property,
+				j: __emval_get_property,
+				g: __emval_incref,
+				o: __emval_instanceof,
+				e: __emval_invoke,
+				v: __emval_new_array,
+				i: __emval_new_cstring,
+				q: __emval_new_object,
+				c: __emval_run_destructors,
+				n: __emval_set_property,
+				w: __emval_typeof,
+				K: __localtime_js,
+				I: __mmap_js,
+				J: __munmap_js,
+				L: __tzset_js,
+				S: _clock_time_get,
+				C: _emscripten_date_now,
+				H: _emscripten_resize_heap,
+				N: _environ_get,
+				O: _environ_sizes_get,
+				s: _fd_close,
+				z: _fd_read,
+				M: _fd_seek,
+				A: _fd_write,
+				G: _random_get
+			};
+			function applySignatureConversions(wasmExports$1) {
+				wasmExports$1 = Object.assign({}, wasmExports$1);
+				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$1["Z"] = makeWrapper_pp(wasmExports$1["Z"]);
+				wasmExports$1["$"] = makeWrapper_pp(wasmExports$1["$"]);
+				wasmExports$1["ba"] = makeWrapper_ppp(wasmExports$1["ba"]);
+				wasmExports$1["ca"] = makeWrapper_p(wasmExports$1["ca"]);
+				wasmExports$1["emscripten_stack_get_base"] = makeWrapper_p(wasmExports$1["emscripten_stack_get_base"]);
+				wasmExports$1["_emscripten_stack_alloc"] = makeWrapper_pp(wasmExports$1["_emscripten_stack_alloc"]);
+				wasmExports$1["emscripten_stack_get_current"] = makeWrapper_p(wasmExports$1["emscripten_stack_get_current"]);
+				return wasmExports$1;
+			}
+			function stackCheckInit() {
+				_emscripten_stack_init();
+				writeStackCookie();
+			}
+			function run() {
+				if (runDependencies > 0) {
+					dependenciesFulfilled = run;
+					return;
+				}
+				stackCheckInit();
+				preRun();
+				if (runDependencies > 0) {
+					dependenciesFulfilled = run;
+					return;
+				}
+				function doRun() {
+					Module["calledRun"] = true;
+					if (ABORT) return;
+					initRuntime();
+					readyPromiseResolve?.(Module);
+					Module["onRuntimeInitialized"]?.();
+					postRun();
+				}
+				if (Module["setStatus"]) {
+					Module["setStatus"]("Running...");
+					setTimeout(() => {
+						setTimeout(() => Module["setStatus"](""), 1);
+						doRun();
+					}, 1);
+				} else doRun();
+				checkStackCookie();
+			}
+			var wasmExports = await createWasm();
+			run();
+			if (runtimeInitialized) moduleRtn = Module;
+			else moduleRtn = new Promise((resolve, reject) => {
+				readyPromiseResolve = resolve;
+				readyPromiseReject = reject;
+			});
+			return moduleRtn;
+		};
+	})();
+	if (typeof exports === "object" && typeof module === "object") {
+		module.exports = initRDKitModule$1;
+		module.exports.default = initRDKitModule$1;
+	} else if (typeof define === "function" && define["amd"]) define([], () => initRDKitModule$1);
+}));
+
+//#endregion
+//#region MinimalLib/dist/RDKit_minimal.wasm?url
+var import_RDKit_minimal = /* @__PURE__ */ __toESM(require_RDKit_minimal(), 1);
+var RDKit_minimal_default = "daf0220ca047b78d.wasm";
+
+//#endregion
+//#region src/mol-array.ts
+/**
+* An array of {@link Mol} instances with batch lifecycle management.
+*
+* Extends the native `Array` so all standard array methods (indexing,
+* iteration, `map`, `filter`, …) work out of the box.
+*
+* Call {@link delete} (or use the `using` keyword) to delete every `Mol`
+* in the array at once.
+*/
+var MolArray = class extends Array {
+	/** Deletes every Mol in this array */
+	delete() {
+		for (const mol of this) mol.delete();
+	}
+	/** Disposable support — allows use with the `using` keyword */
+	[Symbol.dispose]() {
+		this.delete();
+	}
+};
+/**
+* Builds a temporary WASM MolList from an array of Mol instances.
+* The caller is responsible for deleting the returned MolList.
+*
+* @internal
+*/
+function fromMolArraytoMolList(mols, module$1) {
+	const list = new module$1.MolList();
+	for (const mol of mols) list.append(mol.jsMol);
+	return list;
+}
+/**
+* Builds a temporary WASM MolList from an array of Mol instances.
+* The caller is responsible for deleting the returned MolList.
+*
+* @internal
+*/
+function fromStringArraytoMolList(mols, module$1, isQuery = false) {
+	const list = new module$1.MolList();
+	for (const s of mols) {
+		const mol = isQuery ? module$1.get_qmol(s) : module$1.get_mol(s);
+		if (!mol) continue;
+		list.append(mol);
+		mol.delete();
+	}
+	return list;
+}
+const isMolArray = (arr) => arr.length > 0 && arr[0] instanceof Mol;
+
+//#endregion
+//#region src/formats/cxsmiles.ts
+/**
+* Converts wrapper-level CX SMILES options to the raw JSON format expected
+* by the RDKit MinimalLib API.
+*/
+const buildCxSmilesRawOptions = (options) => {
+	const { fields: cxSmilesFields, restoreBondDirOption, ...smilesOpts } = options;
+	const raw = { ...smilesOpts };
+	if (cxSmilesFields !== void 0) if (cxSmilesFields.length === 0) raw.CX_NONE = true;
+	else for (const field of cxSmilesFields) raw[`CX_${field}`] = true;
+	if (restoreBondDirOption !== void 0) raw.restoreBondDirOption = restoreBondDirOption === "clear" ? "RestoreBondDirOptionClear" : "RestoreBondDirOptionTrue";
+	return raw;
+};
+
+//#endregion
+//#region src/mol.ts
+/**
+* A wrapper around RDKit's JSMol object providing a typed, camelCase API.
+*
+* @remarks
+* Mol instances are created via RDKit.getMol or RDKit.getQMol,
+* not directly by consumers. The underlying `jsMol` is accessible for advanced use cases.
+*
+* Implements `Disposable` for use with the `using` keyword:
+* ```ts
+* using mol = rdkit.getMol('c1ccccc1')!;
+* const svg = mol.getSvg();
+* // mol is automatically deleted when the scope exits
+* ```
+*/
+var Mol = class Mol {
+	#jsMol;
+	#module;
+	constructor(jsMol, module$1) {
+		this.#jsMol = jsMol;
+		this.#module = module$1;
+	}
+	/**
+	* The underlying JSMol object for direct access to the raw API.
+	* @throws If the molecule has been deleted.
+	*/
+	get jsMol() {
+		if (!this.#jsMol) throw new Error("Mol has been deleted");
+		return this.#jsMol;
+	}
+	/**
+	* Resolves a substructure query argument to a JSMol.
+	* If the query is a string, creates a temporary query molecule.
+	* @returns A tuple of [jsMol, shouldDelete] where shouldDelete indicates
+	*          whether the caller is responsible for deleting the JSMol.
+	*/
+	resolveQuery(query) {
+		if (query instanceof Mol) return [query.jsMol, false];
+		const qmol = this.#module.get_qmol(query);
+		if (!qmol) throw new Error(`Invalid SMARTS query: ${query}`);
+		return [qmol, true];
+	}
+	/** Returns the canonical SMILES string */
+	getSmiles(options) {
+		return options ? this.jsMol.get_smiles(JSON.stringify(options)) : this.jsMol.get_smiles();
+	}
+	/** Returns the Chemaxon Extended SMILES string */
+	getCxSmiles(options) {
+		if (!options) return this.jsMol.get_cxsmiles();
+		return this.jsMol.get_cxsmiles(JSON.stringify(buildCxSmilesRawOptions(options)));
+	}
+	/** Returns the SMARTS string */
+	getSmarts(options) {
+		return options ? this.jsMol.get_smarts(JSON.stringify(options)) : this.jsMol.get_smarts();
+	}
+	/** Returns the Chemaxon Extended SMARTS string */
+	getCxSmarts(options) {
+		if (!options) return this.jsMol.get_cxsmarts();
+		return this.jsMol.get_cxsmarts(JSON.stringify(buildCxSmilesRawOptions(options)));
+	}
+	/**
+	* Returns the V2000 Molfile string
+	* @param options - Molblock generation options
+	*/
+	getMolblock(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_molblock(JSON.stringify(options)) : mol.get_molblock();
+	}
+	/**
+	* Returns the V3000 Molfile string
+	* @param options - Molblock generation options
+	*/
+	getV2KMolblock(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_v2Kmolblock(JSON.stringify(options)) : mol.get_v2Kmolblock();
+	}
+	/**
+	* Returns the V3000 Molfile string
+	* @param options - Molblock generation options
+	*/
+	getV3KMolblock(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_v3Kmolblock(JSON.stringify(options)) : mol.get_v3Kmolblock();
+	}
+	/**
+	* Returns the InChI string
+	* @param args - Optional InChI CLI arguments
+	* @example mol.getInchi(["FixedH", "RecMet", "SaveOpt", "SUU", "SLUUD"])
+	*/
+	getInchi(args) {
+		const mol = this.jsMol;
+		return args ? mol.get_inchi(`-${args.join(" -")}`) : mol.get_inchi();
+	}
+	/**
+	* Returns the InChIKey string
+	* @param args - Optional InChI CLI arguments
+	* @example mol.getInchi(["FixedH", "RecMet", "SaveOpt", "SUU", "SLUUD"])
+	*/
+	getInchikey(args) {
+		const inchi = this.getInchi(args);
+		return this.#module.get_inchikey_for_inchi(inchi);
+	}
+	/** Returns the parsed JSON representation of the molecule */
+	getJson() {
+		return JSON.parse(this.jsMol.get_json());
+	}
+	/** Returns an unsigned integer array representation of the molecule */
+	getAsUint8Array() {
+		return this.jsMol.get_as_uint8array();
+	}
+	/**
+	* Returns an SVG depiction of the molecule
+	*
+	* @param options - Drawing options including dimensions and highlighting.
+	*   When omitted, uses RDKit defaults (250×200).
+	*
+	* @example
+	* // Default SVG
+	* const svg = mol.getSvg();
+	*
+	* // Custom size with atom indices
+	* const svg = mol.getSvg({ width: 400, height: 300, addAtomIndices: true });
+	*
+	* // With atom highlighting
+	* const svg = mol.getSvg({ atoms: [0, 1, 2], highlightColour: [1, 0, 0, 1] });
+	*/
+	getSvg(options) {
+		const mol = this.jsMol;
+		if (!options) return mol.get_svg();
+		return mol.get_svg_with_highlights(JSON.stringify(options));
+	}
+	/**
+	* Returns the first substructure match
+	*
+	* @param query - A Mol instance or a SMARTS string to use as query
+	* @returns The matched atom and bond indices
+	*/
+	getSubstructMatch(query) {
+		const mol = this.jsMol;
+		const [qmol, shouldDelete] = this.resolveQuery(query);
+		try {
+			const matchJson = mol.get_substruct_match(qmol);
+			if (matchJson === "{}") return {
+				atoms: [],
+				bonds: []
+			};
+			return JSON.parse(matchJson);
+		} finally {
+			if (shouldDelete) qmol.delete();
+		}
+	}
+	/**
+	* Returns all substructure matches
+	*
+	* @param query - A Mol instance or a SMARTS string to use as query
+	* @returns An array of matched atom and bond indices
+	*/
+	getSubstructMatches(query) {
+		const mol = this.jsMol;
+		const [qmol, shouldDelete] = this.resolveQuery(query);
+		try {
+			const matchesJson = mol.get_substruct_matches(qmol);
+			if (!matchesJson.startsWith("[")) return [];
+			return JSON.parse(matchesJson);
+		} finally {
+			if (shouldDelete) qmol.delete();
+		}
+	}
+	/** Returns molecular descriptors as a typed object */
+	getDescriptors() {
+		try {
+			return JSON.parse(this.jsMol.get_descriptors());
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Returns the Morgan fingerprint as a bit string
+	* @param options - Fingerprint options
+	*/
+	getMorganFp(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_morgan_fp(JSON.stringify(options)) : mol.get_morgan_fp();
+	}
+	/** Returns the pattern fingerprint as a bit string */
+	getPatternFp(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_pattern_fp(JSON.stringify(options)) : mol.get_pattern_fp();
+	}
+	/** Returns the topological torsion fingerprint as a bit string */
+	getTopologicalTorsionFp(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_topological_torsion_fp(JSON.stringify(options)) : mol.get_topological_torsion_fp();
+	}
+	/** Returns the RDKit fingerprint as a bit string */
+	getRdkitFp(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_rdkit_fp(JSON.stringify(options)) : mol.get_rdkit_fp();
+	}
+	/** Returns the atom pair fingerprint as a bit string */
+	getAtomPairFp(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_atom_pair_fp(JSON.stringify(options)) : mol.get_atom_pair_fp();
+	}
+	/** Returns the MACCS fingerprint as a bit string (fixed 167-bit) */
+	getMaccsFp() {
+		return this.jsMol.get_maccs_fp();
+	}
+	/** Returns the Morgan fingerprint as a Uint8Array */
+	getMorganFpAsUint8Array(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_morgan_fp_as_uint8array(JSON.stringify(options)) : mol.get_morgan_fp_as_uint8array();
+	}
+	/** Returns the pattern fingerprint as a Uint8Array */
+	getPatternFpAsUint8Array(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_pattern_fp_as_uint8array(JSON.stringify(options)) : mol.get_pattern_fp_as_uint8array();
+	}
+	/** Returns the topological torsion fingerprint as a Uint8Array */
+	getTopologicalTorsionFpAsUint8Array(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_topological_torsion_fp_as_uint8array(JSON.stringify(options)) : mol.get_topological_torsion_fp_as_uint8array();
+	}
+	/** Returns the RDKit fingerprint as a Uint8Array */
+	getRdkitFpAsUint8Array(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_rdkit_fp_as_uint8array(JSON.stringify(options)) : mol.get_rdkit_fp_as_uint8array();
+	}
+	/** Returns the atom pair fingerprint as a Uint8Array */
+	getAtomPairFpAsUint8Array(options) {
+		const mol = this.jsMol;
+		return options ? mol.get_atom_pair_fp_as_uint8array(JSON.stringify(options)) : mol.get_atom_pair_fp_as_uint8array();
+	}
+	/** Returns the MACCS fingerprint as a Uint8Array */
+	getMaccsFpAsUint8Array() {
+		return this.jsMol.get_maccs_fp_as_uint8array();
+	}
+	/**
+	* Checks whether the molecule has a given property
+	* @param key - Property name
+	*/
+	hasProp(key) {
+		return this.jsMol.has_prop(key);
+	}
+	/**
+	* Gets a property value from the molecule
+	* @param key - Property name
+	*/
+	getProp(key) {
+		return this.jsMol.get_prop(key);
+	}
+	/**
+	* Sets a property on the molecule
+	* @param key - Property name
+	* @param val - Property value
+	*/
+	setProp(key, val) {
+		return this.jsMol.set_prop(key, val);
+	}
+	/**
+	* Clears a property from the molecule
+	* @param key - Property name
+	*/
+	clearProp(key) {
+		return this.jsMol.clear_prop(key);
+	}
+	/**
+	* Returns the list of property names
+	* @param options - Filter options
+	*/
+	getPropList(options) {
+		const mol = this.jsMol;
+		const sl = options ? mol.get_prop_list(options.includePrivate ?? false, options.includeComputed ?? false) : mol.get_prop_list();
+		const result = [];
+		for (let i = 0; i < sl.size(); i++) result.push(sl.get(i));
+		sl.delete();
+		return result;
+	}
+	/** Returns true if the molecule's structure is valid */
+	isValid() {
+		return this.jsMol.is_valid();
+	}
+	/** Returns the number of atoms in the molecule */
+	getNumAtoms() {
+		return this.jsMol.get_num_atoms();
+	}
+	/** Returns the number of bonds in the molecule */
+	getNumBonds() {
+		return this.jsMol.get_num_bonds();
+	}
+	/** Returns 0 if no coords, 2 for 2D, 3 for 3D */
+	hasCoords() {
+		return this.jsMol.has_coords();
+	}
+	/** Returns stereo tags (CIP codes) for the molecule */
+	getStereoTags() {
+		return JSON.parse(this.jsMol.get_stereo_tags());
+	}
+	/** Returns the V2000 Molfile representation of the aromatic form */
+	getAromaticForm() {
+		return this.jsMol.get_aromatic_form();
+	}
+	/** Returns the V2000 Molfile representation of the Kekule form */
+	getKekuleForm() {
+		return this.jsMol.get_kekule_form();
+	}
+	/** Converts the molecule to aromatic form in place */
+	convertToAromaticForm() {
+		this.jsMol.convert_to_aromatic_form();
+	}
+	/** Converts the molecule to Kekule form in place */
+	convertToKekuleForm() {
+		this.jsMol.convert_to_kekule_form();
+	}
+	/**
+	* Returns a V2000 Molfile string with explicit hydrogens removed
+	* @param options - Options controlling which hydrogens to remove
+	*/
+	removeHs(options) {
+		const mol = this.jsMol;
+		return options ? mol.remove_hs(JSON.stringify(options)) : mol.remove_hs();
+	}
+	/**
+	* Removes explicit hydrogens from the molecule in place
+	* @param options - Options controlling which hydrogens to remove
+	*/
+	removeHsInPlace(options) {
+		const mol = this.jsMol;
+		return options ? mol.remove_hs_in_place(JSON.stringify(options)) : mol.remove_hs_in_place();
+	}
+	/** Returns a V2000 Molfile string with explicit hydrogens added */
+	addHs() {
+		return this.jsMol.add_hs();
+	}
+	/** Adds explicit hydrogens to the molecule in place */
+	addHsInPlace() {
+		return this.jsMol.add_hs_in_place();
+	}
+	combineWith(other, options) {
+		const mol = this.jsMol;
+		if (options) mol.combine_with(other.jsMol, JSON.stringify(options));
+		else this.jsMol.combine_with(other.jsMol);
+	}
+	zipWith(other, options) {
+		const mol = this.jsMol;
+		const newMol = options ? this.#module.molzip(mol, other.jsMol, JSON.stringify(options)) : this.#module.molzip(mol, other.jsMol);
+		if (!newMol || !newMol.is_valid()) return;
+		mol.delete();
+		this.#jsMol = newMol;
+	}
+	/**
+	* Generates new 2D coordinates for the molecule
+	* @param useCoordGen - Use the CoordGen algorithm
+	*/
+	setNewCoords(useCoordGen) {
+		const mol = this.jsMol;
+		return useCoordGen !== void 0 ? mol.set_new_coords(useCoordGen) : mol.set_new_coords();
+	}
+	/**
+	* Returns a V2000 Molfile string with newly generated coordinates
+	* @param useCoordGen - Use the CoordGen algorithm
+	*/
+	getNewCoords(useCoordGen) {
+		const mol = this.jsMol;
+		return useCoordGen !== void 0 ? mol.get_new_coords(useCoordGen) : mol.get_new_coords();
+	}
+	/**
+	* Aligns molecule coordinates with a template molecule
+	* @param template - Template molecule to align to
+	* @param options - Alignment options
+	*/
+	generateAlignedCoords(template, options) {
+		return this.jsMol.generate_aligned_coords(template.jsMol, JSON.stringify(options ?? {}));
+	}
+	/**
+	* Normalizes the depiction of the molecule
+	* @param options - Normalization options
+	*/
+	normalizeDepiction(options) {
+		const mol = this.jsMol;
+		if (!options) return mol.normalize_depiction();
+		const { canonicalize, scaleFactor } = options;
+		if (scaleFactor !== void 0 && canonicalize !== void 0) return mol.normalize_depiction(canonicalize, scaleFactor);
+		if (canonicalize !== void 0) return mol.normalize_depiction(canonicalize);
+		return mol.normalize_depiction();
+	}
+	/**
+	* Straightens the depiction of the molecule
+	* @param smallRotation - Only apply small rotations
+	*/
+	straightenDepiction(smallRotation) {
+		this.jsMol.straighten_depiction(smallRotation);
+	}
+	/**
+	* Condenses functional group abbreviations in the molecule
+	* @param options - Abbreviation options
+	*/
+	condenseAbbreviations(options) {
+		const mol = this.jsMol;
+		if (!options) return mol.condense_abbreviations();
+		const { maxCoverage, useLinkers } = options;
+		if (maxCoverage !== void 0 && useLinkers !== void 0) return mol.condense_abbreviations(maxCoverage, useLinkers);
+		return mol.condense_abbreviations();
+	}
+	drawToCanvas(canvas, options) {
+		const mol = this.jsMol;
+		if (options) mol.draw_to_canvas_with_highlights(canvas, JSON.stringify(options));
+		else mol.draw_to_canvas(canvas, -1, -1);
+	}
+	/**
+	* Returns the disconnected fragments of the molecule
+	* @warning The `mols` array contains new `Mol` instances that must be
+	* manually deleted by the caller to avoid memory leaks.
+	* @returns An object with atom/fragment mappings and a `MolArray` of fragments
+	*/
+	getFrags() {
+		const { mappings, molList } = this.jsMol.get_frags();
+		const parsed = JSON.parse(mappings);
+		const mols = new MolArray();
+		for (let i = 0; i < molList.size(); i++) {
+			const jsMol = molList.at(i);
+			if (jsMol) mols.push(new Mol(jsMol, this.#module));
+		}
+		molList.delete();
+		return {
+			mappings: {
+				atomToFrag: parsed.frags,
+				fragToAtoms: parsed.fragsMolAtomMapping
+			},
+			mols
+		};
+	}
+	/** Returns a copy of the molecule */
+	copy() {
+		return new Mol(this.jsMol.copy(), this.#module);
+	}
+	/**
+	* Deletes the underlying C++ molecule object from memory.
+	*
+	* @see {@link https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-management | Emscripten docs}
+	*/
+	delete() {
+		this.#jsMol?.delete();
+		this.#jsMol = null;
+	}
+	/** Disposable support — allows use with the `using` keyword */
+	[Symbol.dispose]() {
+		this.delete();
+	}
+};
+
+//#endregion
+//#region src/reaction.ts
+/**
+* A wrapper around RDKit's JSReaction object providing a typed, camelCase API.
+*
+* @remarks
+* Reaction instances are created via {@link RDKit.getRxn}, not directly by consumers.
+*
+* Implements `Disposable` for use with the `using` keyword:
+* ```ts
+* using rxn = rdkit.getRxn('[CH3:1][OH:2]>>[CH2:1]=[OH0:2]')!;
+* const products = rxn.runReactants(['CO']);
+* ```
+*/
+var Reaction = class {
+	#jsReaction;
+	#module;
+	constructor(jsReaction, module$1) {
+		this.#jsReaction = jsReaction;
+		this.#module = module$1;
+	}
+	/**
+	* The underlying JSReaction object for direct access to the raw API.
+	* @throws If the reaction has been deleted.
+	*/
+	get jsReaction() {
+		if (!this.#jsReaction) throw new Error("Reaction has been deleted");
+		return this.#jsReaction;
+	}
+	/**
+	* Runs the reaction on a set of reactants.
+	*
+	* Returns an array of product sets. Each product set is an array of `Mol`
+	* instances corresponding to one match between the reactants and the
+	* reaction definition.
+	*
+	* **WARNING:** The caller is responsible for deleting each returned `Mol`
+	* (via `.delete()` or `using`) to avoid memory leaks.
+	*
+	* @param reactants - An array of Mol instances or molecule strings
+	*   (SMILES, MolBlocks, etc.)
+	* @param maxProducts - Maximum number of product sets to return (default: 1000)
+	* @returns An array of product sets, where each set is an array of Mol instances
+	*/
+	runReactants(reactants, maxProducts = 1e3) {
+		let molList;
+		if (isMolArray(reactants)) molList = fromMolArraytoMolList(reactants, this.#module);
+		else molList = fromStringArraytoMolList(reactants, this.#module);
+		const products = this.jsReaction.run_reactants(molList, maxProducts);
+		molList.delete();
+		const result = [];
+		for (let i = 0; i < products.size(); i++) {
+			const productSet = products.get(i);
+			if (!productSet) continue;
+			const mols = new MolArray();
+			productSet.reset();
+			while (!productSet.at_end()) {
+				const jsMol = productSet.next();
+				if (!jsMol) break;
+				mols.push(new Mol(jsMol, this.#module));
+			}
+			productSet.delete();
+			result.push(mols);
+		}
+		products.delete();
+		return result;
+	}
+	/**
+	* Returns an SVG depiction of the reaction
+	*
+	* @param options - Drawing options including highlighting.
+	*   When omitted, uses RDKit defaults.
+	*/
+	getSvg(options) {
+		const rxn = this.jsReaction;
+		if (!options) return rxn.get_svg();
+		return rxn.get_svg_with_highlights(JSON.stringify(options));
+	}
+	/**
+	* Draws the reaction to an HTML5 canvas with highlighting options
+	* @param canvas - Target canvas element
+	* @param options - Drawing options including dimensions and highlighting
+	*/
+	drawToCanvas(canvas, options) {
+		const rxn = this.jsReaction;
+		if (!options) rxn.draw_to_canvas(canvas, -1, -1);
+		else rxn.draw_to_canvas_with_highlights(canvas, JSON.stringify(options));
+	}
+	/**
+	* Deletes the underlying C++ reaction object from memory.
+	*
+	* @see {@link https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-management | Emscripten docs}
+	*/
+	delete() {
+		this.#jsReaction?.delete();
+		this.#jsReaction = null;
+	}
+	/** Disposable support — allows use with the `using` keyword */
+	[Symbol.dispose]() {
+		this.delete();
+	}
+};
+
+//#endregion
+//#region src/rgd.ts
+/**
+* Performs R-Group Decomposition on a set of molecules against one or more cores.
+*
+* This is a one-shot helper that handles all the boilerplate of the raw RDKit
+* RGD API: creating the decomposition object, adding molecules, processing,
+* extracting rows, and cleaning up intermediate objects.
+*
+* **WARNING:** The caller is responsible for deleting each `Mol` in the
+* returned rows (via `.delete()` or `using`) to avoid memory leaks.
+*
+* @param core - Core structure(s): a SMARTS string, an array of SMARTS strings,
+*   a Mol instance, or an array of Mol instances
+* @param molecules - Molecules to decompose: an array of SMILES strings or Mol instances
+* @param options - R-Group decomposition options
+* @param module - The RDKit WASM module
+* @returns An array of rows, one per molecule. Each row maps R-group labels
+*   (`Core`, `R1`, `R2`, …) to Mol instances.
+*/
+function decomposeRGroups(core, molecules, options, module$1) {
+	let resolvedCore;
+	let deleteCore = false;
+	if (typeof core === "string") {
+		const qmol = module$1.get_qmol(core);
+		if (!qmol || !qmol.is_valid()) return null;
+		resolvedCore = qmol;
+		deleteCore = true;
+	} else if (core instanceof Mol) resolvedCore = core.jsMol;
+	else if (isMolArray(core)) {
+		resolvedCore = fromMolArraytoMolList(core, module$1);
+		deleteCore = true;
+	} else {
+		resolvedCore = fromStringArraytoMolList(core, module$1, true);
+		deleteCore = true;
+	}
+	const rgd = module$1.get_rgd(resolvedCore, JSON.stringify(options ?? {}));
+	if (isMolArray(molecules)) for (const mol of molecules) rgd.add(mol.jsMol);
+	else for (const s of molecules) {
+		const jsMol = module$1.get_mol(s);
+		if (jsMol && jsMol.is_valid()) rgd.add(jsMol);
+		jsMol?.delete();
+	}
+	rgd.process();
+	const result = rgd.get_rgroups_as_rows().map((row) => {
+		const wrappedRow = {};
+		for (const [label, jsMol] of Object.entries(row)) wrappedRow[label] = new Mol(jsMol, module$1);
+		return wrappedRow;
+	});
+	rgd.delete();
+	if (deleteCore) resolvedCore.delete();
+	return result;
+}
+
+//#endregion
+//#region src/init.ts
+/**
+* Resolves the WASM URL for the current environment.
+* In browsers, uses `import.meta.url` to resolve the WASM filename relative
+* to the JS bundle's location — works regardless of where the page is served.
+* In Node.js (e.g. vitest), the `?url` import returns a root-relative path
+* like `/src/minimalib/RDKit_minimal.wasm` which needs to be joined with cwd.
+*/
+function resolveWasmUrl() {
+	const url = RDKit_minimal_default;
+	if (typeof process !== "undefined" && process.versions != null && process.versions.node != null && url.startsWith("/") && !url.startsWith("//")) return process.cwd() + url;
+	return new URL(url, import.meta.url).href;
+}
+/**
+* Initializes the RDKit WASM module and returns a typed wrapper.
+*
+* @param options - Initialization options
+* @returns A promise that resolves to the RDKit wrapper
+*
+* @example
+* ```ts
+* const rdkit = await initRDKit();
+* const mol = rdkit.getMol('c1ccccc1');
+* ```
+*/
+async function initRDKit(options) {
+	const mod = await (0, import_RDKit_minimal.default)({ locateFile: options?.locateFile ?? (() => resolveWasmUrl()) });
+	return {
+		getMol(input, opts) {
+			const jsMol = opts ? mod.get_mol(input, JSON.stringify(opts)) : mod.get_mol(input);
+			if (!jsMol || !jsMol.is_valid()) {
+				jsMol?.delete();
+				return null;
+			}
+			return new Mol(jsMol, mod);
+		},
+		getQMol(input) {
+			const jsMol = mod.get_qmol(input);
+			if (!jsMol) return null;
+			return new Mol(jsMol, mod);
+		},
+		getMCS(mols, options$1) {
+			let molList;
+			if (isMolArray(mols)) molList = fromMolArraytoMolList(mols, mod);
+			else molList = fromStringArraytoMolList(mols, mod);
+			const json = options$1 ? mod.get_mcs_as_json(molList, JSON.stringify(options$1)) : mod.get_mcs_as_json(molList);
+			molList.delete();
+			const parsed = JSON.parse(json);
+			let cachedQmol;
+			return {
+				...parsed,
+				get qmol() {
+					if (cachedQmol !== void 0) return cachedQmol;
+					const s = Array.isArray(parsed.smarts) ? parsed.smarts[0] : parsed.smarts;
+					if (!s) {
+						cachedQmol = null;
+						return null;
+					}
+					const jsMol = mod.get_qmol(s);
+					cachedQmol = jsMol ? new Mol(jsMol, mod) : null;
+					return cachedQmol;
+				}
+			};
+		},
+		getRxn(input, options$1) {
+			try {
+				const jsRxn = options$1 ? mod.get_rxn(input, JSON.stringify(options$1)) : mod.get_rxn(input);
+				if (!jsRxn) return null;
+				return new Reaction(jsRxn, mod);
+			} catch {
+				return null;
+			}
+		},
+		getRGD(core, molecules, options$1) {
+			return decomposeRGroups(core, molecules, options$1, mod);
+		},
+		molzip(mol1, mol2) {
+			const jsMol = mod.molzip(mol1.jsMol, mol2.jsMol);
+			if (!jsMol) return null;
+			return new Mol(jsMol, mod);
+		},
+		get version() {
+			return mod.version();
+		},
+		get module() {
+			return mod;
+		}
+	};
+}
+
+//#endregion
+export { Mol, MolArray, Reaction, initRDKit };