nolo-cli 0.33.0-alpha.21 → 0.33.0-alpha.23

package/emscripten-module-XM7NDJQA.js

@@ -0,0 +1,4536 @@
+import "./chunk-4VNS5WPM.js";
+
+// node_modules/@jitl/quickjs-wasmfile-debug-sync/dist/emscripten-module.mjs
+async function QuickJSRaw(moduleArg = {}) {
+  var moduleRtn;
+  (function() {
+    function humanReadableVersionToPacked(str) {
+      str = str.split("-")[0];
+      var vers = str.split(".").slice(0, 3);
+      while (vers.length < 3) vers.push("00");
+      vers = vers.map((n, i, arr) => n.padStart(2, "0"));
+      return vers.join("");
+    }
+    var packedVersionToHumanReadable = (n) => [n / 1e4 | 0, (n / 100 | 0) % 100, n % 100].join(".");
+    var TARGET_NOT_SUPPORTED = 2147483647;
+    var currentNodeVersion = typeof process !== "undefined" && process.versions?.node ? humanReadableVersionToPacked(process.versions.node) : TARGET_NOT_SUPPORTED;
+    if (currentNodeVersion < 16e4) {
+      throw new Error(`This emscripten-generated code requires node v${packedVersionToHumanReadable(16e4)} (detected v${packedVersionToHumanReadable(currentNodeVersion)})`);
+    }
+    var userAgent = typeof navigator !== "undefined" && navigator.userAgent;
+    if (!userAgent) {
+      return;
+    }
+    var currentSafariVersion = userAgent.includes("Safari/") && !userAgent.includes("Chrome/") && userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/) ? humanReadableVersionToPacked(userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)[1]) : TARGET_NOT_SUPPORTED;
+    if (currentSafariVersion < 15e4) {
+      throw new Error(`This emscripten-generated code requires Safari v${packedVersionToHumanReadable(15e4)} (detected v${currentSafariVersion})`);
+    }
+    var currentFirefoxVersion = userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/) ? parseFloat(userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
+    if (currentFirefoxVersion < 79) {
+      throw new Error(`This emscripten-generated code requires Firefox v79 (detected v${currentFirefoxVersion})`);
+    }
+    var currentChromeVersion = userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/) ? parseFloat(userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)[1]) : TARGET_NOT_SUPPORTED;
+    if (currentChromeVersion < 85) {
+      throw new Error(`This emscripten-generated code requires Chrome v85 (detected v${currentChromeVersion})`);
+    }
+  })();
+  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 ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+  if (ENVIRONMENT_IS_NODE) {
+    const { createRequire } = await import("node:module");
+    var require2 = createRequire(import.meta.url);
+  }
+  function quickjsEmscriptenInit(debugLog) {
+    const log = debugLog || function() {
+    };
+    const extension = { log };
+    for (const init of quickjsEmscriptenInit.inits) {
+      init(extension);
+    }
+    Module["quickJSEmscriptenExtensions"] = extension;
+    return extension;
+  }
+  quickjsEmscriptenInit.inits = [];
+  Module["quickjsEmscriptenInit"] = quickjsEmscriptenInit;
+  quickjsEmscriptenInit.inits.push((extension) => {
+    if (typeof receiveSourceMapJSON !== "undefined") {
+      extension["receiveSourceMapJSON"] = (data) => {
+        if (typeof wasmSourceMap === "undefined") {
+          extension.log("receiveSourceMapJSON: received", data);
+          return receiveSourceMapJSON(data);
+        } else {
+          extension.log("receiveSourceMapJSON: already have data:", wasmSourceMap, "ignoring", data);
+        }
+      };
+    }
+  });
+  quickjsEmscriptenInit.inits.push((extension) => {
+    if (typeof WasmOffsetConverter !== "undefined") {
+      extension["WasmOffsetConverter"] = WasmOffsetConverter;
+      try {
+        extension["existingWasmOffsetConverter"] = wasmOffsetConverter;
+        extension["receiveWasmOffsetConverter"] = function(wasmBinary2, wasmModule) {
+          if (!wasmOffsetConverter) {
+            extension.log("wasmOffsetConverter set");
+            wasmOffsetConverter = new WasmOffsetConverter(wasmBinary2, wasmModule);
+          } else {
+            extension.log("wasmOffsetConverter already set, ignored");
+          }
+        };
+      } catch (error) {
+        extension["receiveWasmOffsetConverter"] = function() {
+          extension.log("wasmOffsetConverter variable not defined, this is a no-op");
+        };
+      }
+    }
+  });
+  quickjsEmscriptenInit.inits.push((extension) => {
+    extension["getWasmMemory"] = function() {
+      return wasmMemory;
+    };
+  });
+  var arguments_ = [];
+  var thisProgram = "./this.program";
+  var quit_ = (status, toThrow) => {
+    throw toThrow;
+  };
+  var _scriptName = import.meta.url;
+  var scriptDirectory = "";
+  function locateFile(path) {
+    if (Module["locateFile"]) {
+      return Module["locateFile"](path, scriptDirectory);
+    }
+    return scriptDirectory + path;
+  }
+  var readAsync, readBinary;
+  if (ENVIRONMENT_IS_NODE) {
+    const isNode = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+    if (!isNode) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
+    var fs = require2("node:fs");
+    if (_scriptName.startsWith("file:")) {
+      scriptDirectory = require2("node:path").dirname(require2("node:url").fileURLToPath(_scriptName)) + "/";
+    }
+    readBinary = (filename) => {
+      filename = isFileURI(filename) ? new URL(filename) : filename;
+      var ret = fs.readFileSync(filename);
+      assert(Buffer.isBuffer(ret));
+      return ret;
+    };
+    readAsync = async (filename, binary = true) => {
+      filename = isFileURI(filename) ? new URL(filename) : filename;
+      var ret = fs.readFileSync(filename, binary ? void 0 : "utf8");
+      assert(binary ? Buffer.isBuffer(ret) : typeof ret == "string");
+      return ret;
+    };
+    if (process.argv.length > 1) {
+      thisProgram = process.argv[1].replace(/\\/g, "/");
+    }
+    arguments_ = process.argv.slice(2);
+    quit_ = (status, toThrow) => {
+      process.exitCode = status;
+      throw toThrow;
+    };
+  } else if (ENVIRONMENT_IS_SHELL) {
+  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+    try {
+      scriptDirectory = new URL(".", _scriptName).href;
+    } catch {
+    }
+    if (!(globalThis.window || globalThis.WorkerGlobalScope)) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
+    {
+      if (ENVIRONMENT_IS_WORKER) {
+        readBinary = (url) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, false);
+          xhr.responseType = "arraybuffer";
+          xhr.send(null);
+          return new Uint8Array(
+            /** @type{!ArrayBuffer} */
+            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);
+      };
+    }
+  } else {
+    throw new Error("environment detection error");
+  }
+  var out = console.log.bind(console);
+  var err = console.error.bind(console);
+  var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
+  var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
+  var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
+  var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";
+  var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";
+  var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";
+  var OPFS = "OPFS is no longer included by default; build with -lopfs.js";
+  var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
+  assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.");
+  var wasmBinary;
+  if (!globalThis.WebAssembly) {
+    err("no native wasm support detected");
+  }
+  var ABORT = false;
+  var EXITSTATUS;
+  function assert(condition, text) {
+    if (!condition) {
+      abort("Assertion failed" + (text ? ": " + text : ""));
+    }
+  }
+  var isFileURI = (filename) => filename.startsWith("file://");
+  function writeStackCookie() {
+    var max = _emscripten_stack_get_end();
+    assert((max & 3) == 0);
+    if (max == 0) {
+      max += 4;
+    }
+    HEAPU32[max >> 2] = 34821223;
+    HEAPU32[max + 4 >> 2] = 2310721022;
+    HEAPU32[0 >> 2] = 1668509029;
+  }
+  function checkStackCookie() {
+    if (ABORT) return;
+    var max = _emscripten_stack_get_end();
+    if (max == 0) {
+      max += 4;
+    }
+    var cookie1 = HEAPU32[max >> 2];
+    var cookie2 = HEAPU32[max + 4 >> 2];
+    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 >> 2] != 1668509029) {
+      abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
+    }
+  }
+  var runtimeDebug = true;
+  function dbg(...args) {
+    if (!runtimeDebug && typeof runtimeDebug != "undefined") return;
+    console.warn(...args);
+  }
+  (() => {
+    var h16 = new Int16Array(1);
+    var h8 = new Int8Array(h16.buffer);
+    h16[0] = 25459;
+    if (h8[0] !== 115 || h8[1] !== 99) abort("Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)");
+  })();
+  function consumedModuleProp(prop) {
+    if (!Object.getOwnPropertyDescriptor(Module, prop)) {
+      Object.defineProperty(Module, prop, {
+        configurable: true,
+        set() {
+          abort(`Attempt to set \`Module.${prop}\` after it has already been processed.  This can happen, for example, when code is injected via '--post-js' rather than '--pre-js'`);
+        }
+      });
+    }
+  }
+  function makeInvalidEarlyAccess(name) {
+    return () => assert(false, `call to '${name}' via reference taken before Wasm module initialization`);
+  }
+  function ignoredModuleProp(prop) {
+    if (Object.getOwnPropertyDescriptor(Module, prop)) {
+      abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
+    }
+  }
+  function isExportedByForceFilesystem(name) {
+    return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_preloadFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
+    name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
+  }
+  function missingLibrarySymbol(sym) {
+    unexportedRuntimeSymbol(sym);
+  }
+  function unexportedRuntimeSymbol(sym) {
+    if (!Object.getOwnPropertyDescriptor(Module, sym)) {
+      Object.defineProperty(Module, sym, {
+        configurable: true,
+        get() {
+          var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
+          if (isExportedByForceFilesystem(sym)) {
+            msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
+          }
+          abort(msg);
+        }
+      });
+    }
+  }
+  var readyPromiseResolve, readyPromiseReject;
+  var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+  var HEAP64, HEAPU64;
+  var runtimeInitialized = false;
+  var runtimeExited = false;
+  function updateMemoryViews() {
+    var b = wasmMemory.buffer;
+    Module["HEAP8"] = HEAP8 = new Int8Array(b);
+    HEAP16 = new Int16Array(b);
+    Module["HEAPU8"] = 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 initMemory() {
+    if (Module["wasmMemory"]) {
+      wasmMemory = Module["wasmMemory"];
+    } else {
+      var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
+      assert(INITIAL_MEMORY >= 5242880, "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY + "! (STACK_SIZE=5242880)");
+      wasmMemory = new WebAssembly.Memory({
+        "initial": INITIAL_MEMORY / 65536,
+        // In theory we should not need to emit the maximum if we want "unlimited"
+        // or 4GB of memory, but VMs error on that atm, see
+        // https://github.com/emscripten-core/emscripten/issues/14130
+        // And in the pthreads case we definitely need to emit a maximum. So
+        // always emit one.
+        "maximum": 32768
+      });
+    }
+    updateMemoryViews();
+  }
+  assert(
+    globalThis.Int32Array && globalThis.Float64Array && Int32Array.prototype.subarray && Int32Array.prototype.set,
+    "JS engine does not provide full typed array support"
+  );
+  function preRun() {
+    if (Module["preRun"]) {
+      if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+      while (Module["preRun"].length) {
+        addOnPreRun(Module["preRun"].shift());
+      }
+    }
+    consumedModuleProp("preRun");
+    callRuntimeCallbacks(onPreRuns);
+  }
+  function initRuntime() {
+    assert(!runtimeInitialized);
+    runtimeInitialized = true;
+    checkStackCookie();
+    if (!Module["noFSInit"] && !FS.initialized) FS.init();
+    TTY.init();
+    wasmExports["__wasm_call_ctors"]();
+    FS.ignorePermissions = false;
+  }
+  function exitRuntime() {
+    assert(!runtimeExited);
+    checkStackCookie();
+    ___funcs_on_exit();
+    FS.quit();
+    TTY.shutdown();
+    runtimeExited = true;
+  }
+  function postRun() {
+    checkStackCookie();
+    if (Module["postRun"]) {
+      if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+      while (Module["postRun"].length) {
+        addOnPostRun(Module["postRun"].shift());
+      }
+    }
+    consumedModuleProp("postRun");
+    callRuntimeCallbacks(onPostRuns);
+  }
+  function abort(what) {
+    Module["onAbort"]?.(what);
+    what = "Aborted(" + what + ")";
+    err(what);
+    ABORT = true;
+    var e = new WebAssembly.RuntimeError(what);
+    readyPromiseReject?.(e);
+    throw e;
+  }
+  function createExportWrapper(name, nargs) {
+    return (...args) => {
+      assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
+      assert(!runtimeExited, `native function \`${name}\` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)`);
+      var f = wasmExports[name];
+      assert(f, `exported native function \`${name}\` not found`);
+      assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
+      return f(...args);
+    };
+  }
+  var wasmBinaryFile;
+  function findWasmBinary() {
+    if (Module["locateFile"]) {
+      return locateFile("emscripten-module.wasm");
+    }
+    return new URL("emscripten-module.wasm", import.meta.url).href;
+  }
+  function getBinarySync(file) {
+    if (file == wasmBinaryFile && wasmBinary) {
+      return new Uint8Array(wasmBinary);
+    }
+    if (readBinary) {
+      return readBinary(file);
+    }
+    throw "both async and sync fetching of the wasm failed";
+  }
+  async function getWasmBinary(binaryFile) {
+    if (!wasmBinary) {
+      try {
+        var response = await readAsync(binaryFile);
+        return new Uint8Array(response);
+      } catch {
+      }
+    }
+    return getBinarySync(binaryFile);
+  }
+  async function instantiateArrayBuffer(binaryFile, imports) {
+    try {
+      var binary = await getWasmBinary(binaryFile);
+      var instance = await WebAssembly.instantiate(binary, imports);
+      return instance;
+    } catch (reason) {
+      err(`failed to asynchronously prepare wasm: ${reason}`);
+      if (isFileURI(binaryFile)) {
+        err(`warning: Loading from a file URI (${binaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
+      }
+      abort(reason);
+    }
+  }
+  async function instantiateAsync(binary, binaryFile, imports) {
+    if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+      try {
+        var response = fetch(binaryFile, { credentials: "same-origin" });
+        var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+        return instantiationResult;
+      } catch (reason) {
+        err(`wasm streaming compile failed: ${reason}`);
+        err("falling back to ArrayBuffer instantiation");
+      }
+      ;
+    }
+    return instantiateArrayBuffer(binaryFile, imports);
+  }
+  function getWasmImports() {
+    var imports = {
+      "env": wasmImports,
+      "wasi_snapshot_preview1": wasmImports
+    };
+    return imports;
+  }
+  async function createWasm() {
+    function receiveInstance(instance, module) {
+      wasmExports = instance.exports;
+      assignWasmExports(wasmExports);
+      return wasmExports;
+    }
+    var trueModule = Module;
+    function receiveInstantiationResult(result2) {
+      assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
+      trueModule = null;
+      return receiveInstance(result2["instance"]);
+    }
+    var info = getWasmImports();
+    if (Module["instantiateWasm"]) {
+      return new Promise((resolve, reject) => {
+        try {
+          Module["instantiateWasm"](info, (inst, mod) => {
+            resolve(receiveInstance(inst, mod));
+          });
+        } catch (e) {
+          err(`Module.instantiateWasm callback failed with error: ${e}`);
+          reject(e);
+        }
+      });
+    }
+    wasmBinaryFile ??= findWasmBinary();
+    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+    var exports = receiveInstantiationResult(result);
+    return exports;
+  }
+  class ExitStatus {
+    name = "ExitStatus";
+    constructor(status) {
+      this.message = `Program terminated with exit(${status})`;
+      this.status = status;
+    }
+  }
+  var callRuntimeCallbacks = (callbacks) => {
+    while (callbacks.length > 0) {
+      callbacks.shift()(Module);
+    }
+  };
+  var onPostRuns = [];
+  var addOnPostRun = (cb) => onPostRuns.push(cb);
+  var onPreRuns = [];
+  var addOnPreRun = (cb) => onPreRuns.push(cb);
+  function getValue(ptr, type = "i8") {
+    if (type.endsWith("*")) type = "*";
+    switch (type) {
+      case "i1":
+        return HEAP8[ptr];
+      case "i8":
+        return HEAP8[ptr];
+      case "i16":
+        return HEAP16[ptr >> 1];
+      case "i32":
+        return HEAP32[ptr >> 2];
+      case "i64":
+        return HEAP64[ptr >> 3];
+      case "float":
+        return HEAPF32[ptr >> 2];
+      case "double":
+        return HEAPF64[ptr >> 3];
+      case "*":
+        return HEAPU32[ptr >> 2];
+      default:
+        abort(`invalid type for getValue: ${type}`);
+    }
+  }
+  var noExitRuntime = false;
+  var ptrToString = (ptr) => {
+    assert(typeof ptr === "number", `ptrToString expects a number, got ${typeof ptr}`);
+    ptr >>>= 0;
+    return "0x" + ptr.toString(16).padStart(8, "0");
+  };
+  function setValue(ptr, value, type = "i8") {
+    if (type.endsWith("*")) type = "*";
+    switch (type) {
+      case "i1":
+        HEAP8[ptr] = value;
+        break;
+      case "i8":
+        HEAP8[ptr] = value;
+        break;
+      case "i16":
+        HEAP16[ptr >> 1] = value;
+        break;
+      case "i32":
+        HEAP32[ptr >> 2] = value;
+        break;
+      case "i64":
+        HEAP64[ptr >> 3] = BigInt(value);
+        break;
+      case "float":
+        HEAPF32[ptr >> 2] = value;
+        break;
+      case "double":
+        HEAPF64[ptr >> 3] = value;
+        break;
+      case "*":
+        HEAPU32[ptr >> 2] = value;
+        break;
+      default:
+        abort(`invalid type for setValue: ${type}`);
+    }
+  }
+  var stackRestore = (val) => __emscripten_stack_restore(val);
+  var stackSave = () => _emscripten_stack_get_current();
+  var warnOnce = (text) => {
+    warnOnce.shown ||= {};
+    if (!warnOnce.shown[text]) {
+      warnOnce.shown[text] = 1;
+      if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
+      err(text);
+    }
+  };
+  var wasmMemory;
+  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) => {
+    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 {
+        if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
+        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 UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+    assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
+    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+  };
+  var ___assert_fail = (condition, filename, line, func) => abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
+  var PATH = {
+    isAbs: (path) => path.charAt(0) === "/",
+    splitPath: (filename) => {
+      var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+      return splitPathRe.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 = require2("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 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) => {
+    assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
+    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++] = u;
+      } else if (u <= 2047) {
+        if (outIdx + 1 >= endIdx) break;
+        heap[outIdx++] = 192 | u >> 6;
+        heap[outIdx++] = 128 | u & 63;
+      } else if (u <= 65535) {
+        if (outIdx + 2 >= endIdx) break;
+        heap[outIdx++] = 224 | u >> 12;
+        heap[outIdx++] = 128 | u >> 6 & 63;
+        heap[outIdx++] = 128 | u & 63;
+      } else {
+        if (outIdx + 3 >= endIdx) break;
+        if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
+        heap[outIdx++] = 240 | u >> 18;
+        heap[outIdx++] = 128 | u >> 12 & 63;
+        heap[outIdx++] = 128 | u >> 6 & 63;
+        heap[outIdx++] = 128 | u & 63;
+        i++;
+      }
+    }
+    heap[outIdx] = 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";
+        }
+      } else {
+      }
+      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) => {
+    assert(alignment, "alignment argument is required");
+    return 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;
+      var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+      newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
+      if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
+      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) {
+        throw new FS.ErrnoError(44);
+      },
+      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) {
+        var node = FS.lookupNode(parent, name);
+        for (var i in node.contents) {
+          throw new FS.ErrnoError(55);
+        }
+        delete parent.contents[name];
+        parent.ctime = parent.mtime = Date.now();
+      },
+      readdir(node) {
+        return [".", "..", ...Object.keys(node.contents)];
+      },
+      symlink(parent, newname, oldpath) {
+        var node = MEMFS.createNode(parent, newname, 511 | 40960, 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);
+        assert(size >= 0);
+        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) {
+        assert(!(buffer instanceof ArrayBuffer));
+        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) {
+            assert(position === 0, "canOwn must imply no weird position inside the file");
+            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);
+          }
+        }
+        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 flagModes = {
+      "r": 0,
+      "r+": 2,
+      "w": 512 | 64 | 1,
+      "w+": 512 | 64 | 2,
+      "a": 1024 | 64 | 1,
+      "a+": 1024 | 64 | 2
+    };
+    var flags = flagModes[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 |= 292 | 73;
+    if (canWrite) mode |= 146;
+    return mode;
+  };
+  var strError = (errno) => UTF8ToString(_strerror(errno));
+  var ERRNO_CODES = {
+    "EPERM": 63,
+    "ENOENT": 44,
+    "ESRCH": 71,
+    "EINTR": 27,
+    "EIO": 29,
+    "ENXIO": 60,
+    "E2BIG": 1,
+    "ENOEXEC": 45,
+    "EBADF": 8,
+    "ECHILD": 12,
+    "EAGAIN": 6,
+    "EWOULDBLOCK": 6,
+    "ENOMEM": 48,
+    "EACCES": 2,
+    "EFAULT": 21,
+    "ENOTBLK": 105,
+    "EBUSY": 10,
+    "EEXIST": 20,
+    "EXDEV": 75,
+    "ENODEV": 43,
+    "ENOTDIR": 54,
+    "EISDIR": 31,
+    "EINVAL": 28,
+    "ENFILE": 41,
+    "EMFILE": 33,
+    "ENOTTY": 59,
+    "ETXTBSY": 74,
+    "EFBIG": 22,
+    "ENOSPC": 51,
+    "ESPIPE": 70,
+    "EROFS": 69,
+    "EMLINK": 34,
+    "EPIPE": 64,
+    "EDOM": 18,
+    "ERANGE": 68,
+    "ENOMSG": 49,
+    "EIDRM": 24,
+    "ECHRNG": 106,
+    "EL2NSYNC": 156,
+    "EL3HLT": 107,
+    "EL3RST": 108,
+    "ELNRNG": 109,
+    "EUNATCH": 110,
+    "ENOCSI": 111,
+    "EL2HLT": 112,
+    "EDEADLK": 16,
+    "ENOLCK": 46,
+    "EBADE": 113,
+    "EBADR": 114,
+    "EXFULL": 115,
+    "ENOANO": 104,
+    "EBADRQC": 103,
+    "EBADSLT": 102,
+    "EDEADLOCK": 16,
+    "EBFONT": 101,
+    "ENOSTR": 100,
+    "ENODATA": 116,
+    "ETIME": 117,
+    "ENOSR": 118,
+    "ENONET": 119,
+    "ENOPKG": 120,
+    "EREMOTE": 121,
+    "ENOLINK": 47,
+    "EADV": 122,
+    "ESRMNT": 123,
+    "ECOMM": 124,
+    "EPROTO": 65,
+    "EMULTIHOP": 36,
+    "EDOTDOT": 125,
+    "EBADMSG": 9,
+    "ENOTUNIQ": 126,
+    "EBADFD": 127,
+    "EREMCHG": 128,
+    "ELIBACC": 129,
+    "ELIBBAD": 130,
+    "ELIBSCN": 131,
+    "ELIBMAX": 132,
+    "ELIBEXEC": 133,
+    "ENOSYS": 52,
+    "ENOTEMPTY": 55,
+    "ENAMETOOLONG": 37,
+    "ELOOP": 32,
+    "EOPNOTSUPP": 138,
+    "EPFNOSUPPORT": 139,
+    "ECONNRESET": 15,
+    "ENOBUFS": 42,
+    "EAFNOSUPPORT": 5,
+    "EPROTOTYPE": 67,
+    "ENOTSOCK": 57,
+    "ENOPROTOOPT": 50,
+    "ESHUTDOWN": 140,
+    "ECONNREFUSED": 14,
+    "EADDRINUSE": 3,
+    "ECONNABORTED": 13,
+    "ENETUNREACH": 40,
+    "ENETDOWN": 38,
+    "ETIMEDOUT": 73,
+    "EHOSTDOWN": 142,
+    "EHOSTUNREACH": 23,
+    "EINPROGRESS": 26,
+    "EALREADY": 7,
+    "EDESTADDRREQ": 17,
+    "EMSGSIZE": 35,
+    "EPROTONOSUPPORT": 66,
+    "ESOCKTNOSUPPORT": 137,
+    "EADDRNOTAVAIL": 4,
+    "ENETRESET": 39,
+    "EISCONN": 30,
+    "ENOTCONN": 53,
+    "ETOOMANYREFS": 141,
+    "EUSERS": 136,
+    "EDQUOT": 19,
+    "ESTALE": 72,
+    "ENOTSUP": 138,
+    "ENOMEDIUM": 148,
+    "EILSEQ": 25,
+    "EOVERFLOW": 61,
+    "ECANCELED": 11,
+    "ENOTRECOVERABLE": 56,
+    "EOWNERDEAD": 62,
+    "ESTRPIPE": 135
+  };
+  var asyncLoad = async (url) => {
+    var arrayBuffer = await readAsync(url);
+    assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
+    return new Uint8Array(arrayBuffer);
+  };
+  var FS_createDataFile = (...args) => FS.createDataFile(...args);
+  var getUniqueRunDependency = (id) => {
+    var orig = id;
+    while (1) {
+      if (!runDependencyTracking[id]) return id;
+      id = orig + Math.random();
+    }
+  };
+  var runDependencies = 0;
+  var dependenciesFulfilled = null;
+  var runDependencyTracking = {};
+  var runDependencyWatcher = null;
+  var removeRunDependency = (id) => {
+    runDependencies--;
+    Module["monitorRunDependencies"]?.(runDependencies);
+    assert(id, "removeRunDependency requires an ID");
+    assert(runDependencyTracking[id]);
+    delete runDependencyTracking[id];
+    if (runDependencies == 0) {
+      if (runDependencyWatcher !== null) {
+        clearInterval(runDependencyWatcher);
+        runDependencyWatcher = null;
+      }
+      if (dependenciesFulfilled) {
+        var callback = dependenciesFulfilled;
+        dependenciesFulfilled = null;
+        callback();
+      }
+    }
+  };
+  var addRunDependency = (id) => {
+    runDependencies++;
+    Module["monitorRunDependencies"]?.(runDependencies);
+    assert(id, "addRunDependency requires an ID");
+    assert(!runDependencyTracking[id]);
+    runDependencyTracking[id] = 1;
+    if (runDependencyWatcher === null && globalThis.setInterval) {
+      runDependencyWatcher = setInterval(() => {
+        if (ABORT) {
+          clearInterval(runDependencyWatcher);
+          runDependencyWatcher = null;
+          return;
+        }
+        var shown = false;
+        for (var dep in runDependencyTracking) {
+          if (!shown) {
+            shown = true;
+            err("still waiting on run dependencies:");
+          }
+          err(`dependency: ${dep}`);
+        }
+        if (shown) {
+          err("(end of list)");
+        }
+      }, 1e4);
+      runDependencyWatcher.unref?.();
+    }
+  };
+  var preloadPlugins = [];
+  var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
+    if (typeof Browser != "undefined") Browser.init();
+    for (var plugin of preloadPlugins) {
+      if (plugin["canHandle"](fullname)) {
+        assert(plugin["handle"].constructor.name === "AsyncFunction", "Filesystem plugin handlers must be async functions (See #24914)");
+        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 extends Error {
+      name = "ErrnoError";
+      // We set the `name` property to be able to identify `FS.ErrnoError`
+      // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway.
+      // - when using PROXYFS, an error can come from an underlying FS
+      // as different FS objects have their own FS.ErrnoError each,
+      // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs.
+      // we'll use the reliable test `err.name == "ErrnoError"` instead
+      constructor(errno) {
+        super(runtimeInitialized ? strError(errno) : "");
+        this.errno = errno;
+        for (var key in ERRNO_CODES) {
+          if (ERRNO_CODES[key] === errno) {
+            this.code = key;
+            break;
+          }
+        }
+      }
+    },
+    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 = 292 | 73;
+      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) {
+      assert(typeof parent == "object");
+      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 {
+        var node = 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 & (512 | 64)) {
+          return 31;
+        }
+      }
+      return FS.nodePermissions(node, mode);
+    },
+    checkOpExists(op, err2) {
+      if (!op) {
+        throw new FS.ErrnoError(err2);
+      }
+      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) {
+      assert(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) {
+        var device = FS.getDevice(stream.node.rdev);
+        stream.stream_ops = device.stream_ops;
+        stream.stream_ops.open?.(stream);
+      },
+      llseek() {
+        throw new FS.ErrnoError(70);
+      }
+    },
+    major: (dev) => dev >> 8,
+    minor: (dev) => dev & 255,
+    makedev: (ma, mi) => ma << 8 | mi,
+    registerDevice(dev, ops) {
+      FS.devices[dev] = { stream_ops: ops };
+    },
+    getDevice: (dev) => FS.devices[dev],
+    getMounts(mount) {
+      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) {
+        assert(FS.syncFSRequests > 0);
+        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) {
+      if (typeof type == "string") {
+        throw type;
+      }
+      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);
+      assert(idx !== -1);
+      node.mount.mounts.splice(idx, 1);
+    },
+    lookup(parent, name) {
+      return parent.node_ops.lookup(parent, name);
+    },
+    mknod(path, mode, dev) {
+      var lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.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 &= 511 | 512;
+      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 lookup = FS.lookupPath(newpath, { parent: true });
+      var parent = lookup.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, old_dir, new_dir;
+      lookup = FS.lookupPath(old_path, { parent: true });
+      old_dir = lookup.node;
+      lookup = FS.lookupPath(new_path, { parent: true });
+      new_dir = lookup.node;
+      if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
+      if (old_dir.mount !== new_dir.mount) {
+        throw new FS.ErrnoError(75);
+      }
+      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 lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.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 lookup = FS.lookupPath(path, { follow: true });
+      var node = lookup.node;
+      var readdir = FS.checkOpExists(node.node_ops.readdir, 54);
+      return readdir(node);
+    },
+    unlink(path) {
+      var lookup = FS.lookupPath(path, { parent: true });
+      var parent = lookup.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 lookup = FS.lookupPath(path);
+      var link = lookup.node;
+      if (!link) {
+        throw new FS.ErrnoError(44);
+      }
+      if (!link.node_ops.readlink) {
+        throw new FS.ErrnoError(28);
+      }
+      return link.node_ops.readlink(link);
+    },
+    stat(path, dontFollow) {
+      var lookup = FS.lookupPath(path, { follow: !dontFollow });
+      var node = lookup.node;
+      var getattr = FS.checkOpExists(node.node_ops.getattr, 63);
+      return getattr(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 & ~4095,
+        ctime: Date.now(),
+        dontFollow
+      });
+    },
+    chmod(path, mode, dontFollow) {
+      var node;
+      if (typeof path == "string") {
+        var lookup = FS.lookupPath(path, { follow: !dontFollow });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      FS.doChmod(null, node, mode, dontFollow);
+    },
+    lchmod(path, mode) {
+      FS.chmod(path, mode, true);
+    },
+    fchmod(fd, mode) {
+      var stream = FS.getStreamChecked(fd);
+      FS.doChmod(stream, stream.node, mode, false);
+    },
+    doChown(stream, node, dontFollow) {
+      FS.doSetAttr(stream, node, {
+        timestamp: Date.now(),
+        dontFollow
+        // we ignore the uid / gid for now
+      });
+    },
+    chown(path, uid, gid, dontFollow) {
+      var node;
+      if (typeof path == "string") {
+        var lookup = FS.lookupPath(path, { follow: !dontFollow });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      FS.doChown(null, node, dontFollow);
+    },
+    lchown(path, uid, gid) {
+      FS.chown(path, uid, gid, true);
+    },
+    fchown(fd, uid, gid) {
+      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") {
+        var lookup = FS.lookupPath(path, { follow: true });
+        node = lookup.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 lookup = FS.lookupPath(path, { follow: true });
+      var node = lookup.node;
+      var setattr = FS.checkOpExists(node.node_ops.setattr, 63);
+      setattr(node, {
+        atime,
+        mtime
+      });
+    },
+    open(path, flags, mode = 438) {
+      if (path === "") {
+        throw new FS.ErrnoError(44);
+      }
+      flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+      if (flags & 64) {
+        mode = mode & 4095 | 32768;
+      } else {
+        mode = 0;
+      }
+      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 &= ~512;
+      }
+      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 &= ~(128 | 512 | 131072);
+      var stream = FS.createStream({
+        node,
+        path: FS.getPath(node),
+        // we want the absolute path to the node
+        flags,
+        seekable: true,
+        position: 0,
+        stream_ops: node.stream_ops,
+        // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+        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) {
+      assert(offset >= 0);
+      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) {
+      assert(offset >= 0);
+      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) {
+      assert(offset >= 0);
+      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 stat = FS.stat(path);
+      var length = stat.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");
+      }
+      var stdin = FS.open("/dev/stdin", 0);
+      var stdout = FS.open("/dev/stdout", 1);
+      var stderr = FS.open("/dev/stderr", 1);
+      assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`);
+      assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`);
+      assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`);
+    },
+    staticInit() {
+      FS.nameTable = new Array(4096);
+      FS.mount(MEMFS, {}, "/");
+      FS.createDefaultDirectories();
+      FS.createDefaultDevices();
+      FS.createSpecialDirectories();
+      FS.filesystems = {
+        "MEMFS": MEMFS
+      };
+    },
+    init(input, output, error) {
+      assert(!FS.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
+      FS.initialized = true;
+      input ??= Module["stdin"];
+      output ??= Module["stdout"];
+      error ??= Module["stderr"];
+      FS.createStandardStreams(input, output, error);
+    },
+    quit() {
+      FS.initialized = false;
+      _fflush(0);
+      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 = [];
+        // Loaded chunks. Index is the chunk number
+        get(idx) {
+          if (idx > this.length - 1 || idx < 0) {
+            return void 0;
+          }
+          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 xhr2 = new XMLHttpRequest();
+            xhr2.open("GET", url, false);
+            if (datalength !== chunkSize) xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
+            xhr2.responseType = "arraybuffer";
+            if (xhr2.overrideMimeType) {
+              xhr2.overrideMimeType("text/plain; charset=x-user-defined");
+            }
+            xhr2.send(null);
+            if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304)) abort("Couldn't load " + url + ". Status: " + xhr2.status);
+            if (xhr2.response !== void 0) {
+              return new Uint8Array(
+                /** @type{Array<number>} */
+                xhr2.response || []
+              );
+            }
+            return intArrayFromString(xhr2.responseText || "", true);
+          };
+          var lazyArray2 = this;
+          lazyArray2.setDataGetter((chunkNum) => {
+            var start = chunkNum * chunkSize;
+            var end = (chunkNum + 1) * chunkSize - 1;
+            end = Math.min(end, datalength - 1);
+            if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
+              lazyArray2.chunks[chunkNum] = doXHR(start, end);
+            }
+            if (typeof lazyArray2.chunks[chunkNum] == "undefined") abort("doXHR failed!");
+            return lazyArray2.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 lazyArray = new LazyUint8Array();
+        var properties = { isDevice: false, contents: lazyArray };
+      } 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);
+        assert(size >= 0);
+        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;
+    },
+    absolutePath() {
+      abort("FS.absolutePath has been removed; use PATH_FS.resolve instead");
+    },
+    createFolder() {
+      abort("FS.createFolder has been removed; use FS.mkdir instead");
+    },
+    createLink() {
+      abort("FS.createLink has been removed; use FS.symlink instead");
+    },
+    joinPath() {
+      abort("FS.joinPath has been removed; use PATH.join instead");
+    },
+    mmapAlloc() {
+      abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc");
+    },
+    standardizePath() {
+      abort("FS.standardizePath has been removed; use PATH.normalize instead");
+    }
+  };
+  var SYSCALLS = {
+    calculateAt(dirfd, path, allowEmpty) {
+      if (PATH.isAbs(path)) {
+        return path;
+      }
+      var dir;
+      if (dirfd === -100) {
+        dir = FS.cwd();
+      } else {
+        var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+        dir = dirstream.path;
+      }
+      if (path.length == 0) {
+        if (!allowEmpty) {
+          throw new FS.ErrnoError(44);
+          ;
+        }
+        return dir;
+      }
+      return dir + "/" + path;
+    },
+    writeStat(buf, stat) {
+      HEAPU32[buf >> 2] = stat.dev;
+      HEAPU32[buf + 4 >> 2] = stat.mode;
+      HEAPU32[buf + 8 >> 2] = stat.nlink;
+      HEAPU32[buf + 12 >> 2] = stat.uid;
+      HEAPU32[buf + 16 >> 2] = stat.gid;
+      HEAPU32[buf + 20 >> 2] = stat.rdev;
+      HEAP64[buf + 24 >> 3] = BigInt(stat.size);
+      HEAP32[buf + 32 >> 2] = 4096;
+      HEAP32[buf + 36 >> 2] = stat.blocks;
+      var atime = stat.atime.getTime();
+      var mtime = stat.mtime.getTime();
+      var ctime = stat.ctime.getTime();
+      HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3));
+      HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3;
+      HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3));
+      HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3;
+      HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3));
+      HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3;
+      HEAP64[buf + 88 >> 3] = BigInt(stat.ino);
+      return 0;
+    },
+    writeStatFs(buf, stats) {
+      HEAPU32[buf + 4 >> 2] = stats.bsize;
+      HEAPU32[buf + 60 >> 2] = stats.bsize;
+      HEAP64[buf + 8 >> 3] = BigInt(stats.blocks);
+      HEAP64[buf + 16 >> 3] = BigInt(stats.bfree);
+      HEAP64[buf + 24 >> 3] = BigInt(stats.bavail);
+      HEAP64[buf + 32 >> 3] = BigInt(stats.files);
+      HEAP64[buf + 40 >> 3] = BigInt(stats.ffree);
+      HEAPU32[buf + 48 >> 2] = stats.fsid;
+      HEAPU32[buf + 64 >> 2] = stats.flags;
+      HEAPU32[buf + 56 >> 2] = 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) {
+      var stream = FS.getStreamChecked(fd);
+      return stream;
+    },
+    varargs: void 0,
+    getStr(ptr) {
+      var ret = UTF8ToString(ptr);
+      return ret;
+    }
+  };
+  function ___syscall_dup(fd) {
+    try {
+      var old = SYSCALLS.getStreamFromFD(fd);
+      return FS.dupStream(old).fd;
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return -e.errno;
+    }
+  }
+  function ___syscall_fstat64(fd, buf) {
+    try {
+      return SYSCALLS.writeStat(buf, FS.fstat(fd));
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return -e.errno;
+    }
+  }
+  function ___syscall_lstat64(path, buf) {
+    try {
+      path = SYSCALLS.getStr(path);
+      return SYSCALLS.writeStat(buf, FS.lstat(path));
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return -e.errno;
+    }
+  }
+  function ___syscall_mkdirat(dirfd, path, mode) {
+    try {
+      path = SYSCALLS.getStr(path);
+      path = SYSCALLS.calculateAt(dirfd, path);
+      FS.mkdir(path, mode, 0);
+      return 0;
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return -e.errno;
+    }
+  }
+  function ___syscall_newfstatat(dirfd, path, buf, flags) {
+    try {
+      path = SYSCALLS.getStr(path);
+      var nofollow = flags & 256;
+      var allowEmpty = flags & 4096;
+      flags = flags & ~6400;
+      assert(!flags, `unknown flags in __syscall_newfstatat: ${flags}`);
+      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;
+    }
+  }
+  var syscallGetVarargI = () => {
+    assert(SYSCALLS.varargs != void 0);
+    var ret = HEAP32[+SYSCALLS.varargs >> 2];
+    SYSCALLS.varargs += 4;
+    return ret;
+  };
+  function ___syscall_openat(dirfd, path, flags, varargs) {
+    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;
+    }
+  }
+  function ___syscall_stat64(path, buf) {
+    try {
+      path = SYSCALLS.getStr(path);
+      return SYSCALLS.writeStat(buf, FS.stat(path));
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return -e.errno;
+    }
+  }
+  var __abort_js = () => abort("native code called abort()");
+  var getExecutableName = () => thisProgram || "./this.program";
+  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
+    assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
+    return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+  };
+  var __emscripten_get_progname = (str, len) => stringToUTF8(getExecutableName(), str, len);
+  var stringToNewUTF8 = (str) => {
+    var size = lengthBytesUTF8(str) + 1;
+    var ret = _malloc(size);
+    if (ret) stringToUTF8(str, ret, size);
+    return ret;
+  };
+  var __emscripten_sanitizer_get_option = (name) => stringToNewUTF8(Module[UTF8ToString(name)] || "");
+  var __emscripten_sanitizer_use_colors = () => {
+    var setting = Module["printWithColors"];
+    if (setting !== void 0) {
+      return setting;
+    }
+    return ENVIRONMENT_IS_NODE && process.stderr.isTTY;
+  };
+  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) => {
+    var leap = isLeapYear(date.getFullYear());
+    var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
+    var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
+    return yday;
+  };
+  var INT53_MAX = 9007199254740992;
+  var INT53_MIN = -9007199254740992;
+  var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+  function __localtime_js(time, tmPtr) {
+    time = bigintToI53Checked(time);
+    var date = new Date(time * 1e3);
+    HEAP32[tmPtr >> 2] = date.getSeconds();
+    HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
+    HEAP32[tmPtr + 8 >> 2] = date.getHours();
+    HEAP32[tmPtr + 12 >> 2] = date.getDate();
+    HEAP32[tmPtr + 16 >> 2] = date.getMonth();
+    HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
+    HEAP32[tmPtr + 24 >> 2] = date.getDay();
+    var yday = ydayFromDate(date) | 0;
+    HEAP32[tmPtr + 28 >> 2] = yday;
+    HEAP32[tmPtr + 36 >> 2] = -(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] = dst;
+    ;
+  }
+  function __mmap_js(len, prot, flags, fd, offset, allocated, addr) {
+    offset = bigintToI53Checked(offset);
+    try {
+      assert(!isNaN(offset));
+      var stream = SYSCALLS.getStreamFromFD(fd);
+      var res = FS.mmap(stream, len, offset, prot, flags);
+      var ptr = res.ptr;
+      HEAP32[allocated >> 2] = res.allocated;
+      HEAPU32[addr >> 2] = 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) {
+    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 = (timezone, daylight, std_name, dst_name) => {
+    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] = stdTimezoneOffset * 60;
+    HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+    var extractZone = (timezoneOffset) => {
+      var sign = timezoneOffset >= 0 ? "-" : "+";
+      var absOffset = Math.abs(timezoneOffset);
+      var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
+      var minutes = String(absOffset % 60).padStart(2, "0");
+      return `UTC${sign}${hours}${minutes}`;
+    };
+    var winterName = extractZone(winterOffset);
+    var summerName = extractZone(summerOffset);
+    assert(winterName);
+    assert(summerName);
+    assert(lengthBytesUTF8(winterName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${winterName})`);
+    assert(lengthBytesUTF8(summerName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${summerName})`);
+    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);
+    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] = BigInt(nsec);
+    return 0;
+    ;
+  }
+  var getHeapMax = () => (
+    // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+    // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+    // for any code that deals with heap sizes, which would require special
+    // casing all heap size related code to treat 0 specially.
+    2147483648
+  );
+  var _emscripten_get_heap_max = () => getHeapMax();
+  var UNWIND_CACHE = {};
+  var convertPCtoSourceLocation = (pc) => {
+    if (UNWIND_CACHE.last_get_source_pc == pc) return UNWIND_CACHE.last_source;
+    var match;
+    var source;
+    if (wasmSourceMap) {
+      source = wasmSourceMap.lookup(pc);
+    }
+    if (!source) {
+      var frame = UNWIND_CACHE[pc];
+      if (!frame) return null;
+      if (match = /\((.*):(\d+):(\d+)\)$/.exec(frame)) {
+        source = { file: match[1], line: match[2], column: match[3] };
+      } else if (match = /@(.*):(\d+):(\d+)/.exec(frame)) {
+        source = { file: match[1], line: match[2], column: match[3] };
+      }
+    }
+    UNWIND_CACHE.last_get_source_pc = pc;
+    UNWIND_CACHE.last_source = source;
+    return source;
+  };
+  var _emscripten_pc_get_column = (pc) => {
+    var result = convertPCtoSourceLocation(pc);
+    return result ? result.column || 0 : 0;
+  };
+  var noLeakCheck = (func) => {
+    if (runtimeInitialized) ___lsan_disable();
+    try {
+      return func();
+    } finally {
+      if (runtimeInitialized) ___lsan_enable();
+    }
+  };
+  var _emscripten_pc_get_file = (pc) => noLeakCheck(() => {
+    var result = convertPCtoSourceLocation(pc);
+    if (!result) return 0;
+    _free(_emscripten_pc_get_file.ret ?? 0);
+    _emscripten_pc_get_file.ret = stringToNewUTF8(result.file);
+    return _emscripten_pc_get_file.ret;
+  });
+  var convertFrameToPC = (frame) => {
+    var match;
+    if (match = /\bwasm-function\[\d+\]:(0x[0-9a-f]+)/.exec(frame)) {
+      return +match[1];
+    } else if (match = /\bwasm-function\[(\d+)\]:(\d+)/.exec(frame)) {
+      warnOnce("legacy backtrace format detected, this version of v8 is no longer supported by the emscripten backtrace mechanism");
+    } else if (match = /:(\d+):\d+(?:\)|$)/.exec(frame)) {
+      return 2147483648 | +match[1];
+    }
+    return 0;
+  };
+  var saveInUnwindCache = (callstack) => {
+    for (var line of callstack) {
+      var pc = convertFrameToPC(line);
+      if (pc) {
+        UNWIND_CACHE[pc] = line;
+      }
+    }
+  };
+  var jsStackTrace = () => new Error().stack.toString();
+  var _emscripten_stack_snapshot = () => {
+    var callstack = jsStackTrace().split("\n");
+    if (callstack[0] == "Error") {
+      callstack.shift();
+    }
+    saveInUnwindCache(callstack);
+    UNWIND_CACHE.last_addr = convertFrameToPC(callstack[3]);
+    UNWIND_CACHE.last_stack = callstack;
+    return UNWIND_CACHE.last_addr;
+  };
+  var _emscripten_pc_get_function = (pc) => noLeakCheck(() => {
+    var frame = UNWIND_CACHE[pc];
+    if (!frame) return 0;
+    var name;
+    var match;
+    if (match = /^\s+at .*\.wasm\.(.*) \(.*\)$/.exec(frame)) {
+      name = match[1];
+    } else if (match = /^\s+at (.*) \(.*\)$/.exec(frame)) {
+      name = match[1];
+    } else if (match = /^(.+?)@/.exec(frame)) {
+      name = match[1];
+    } else {
+      return 0;
+    }
+    _free(_emscripten_pc_get_function.ret ?? 0);
+    _emscripten_pc_get_function.ret = stringToNewUTF8(name);
+    return _emscripten_pc_get_function.ret;
+  });
+  var _emscripten_pc_get_line = (pc) => {
+    var result = convertPCtoSourceLocation(pc);
+    return result ? result.line : 0;
+  };
+  var growMemory = (size) => {
+    var oldHeapSize = wasmMemory.buffer.byteLength;
+    var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+    try {
+      wasmMemory.grow(pages);
+      updateMemoryViews();
+      return 1;
+    } catch (e) {
+      err(`growMemory: Attempted to grow heap from ${oldHeapSize} bytes to ${size} bytes, but got error: ${e}`);
+    }
+  };
+  var _emscripten_resize_heap = (requestedSize) => {
+    var oldSize = HEAPU8.length;
+    requestedSize >>>= 0;
+    assert(requestedSize > oldSize);
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) {
+      err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
+      return false;
+    }
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+      var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+      var replacement = growMemory(newSize);
+      if (replacement) {
+        return true;
+      }
+    }
+    err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
+    return false;
+  };
+  var _emscripten_stack_unwind_buffer = (addr, buffer, count) => {
+    var stack;
+    if (UNWIND_CACHE.last_addr == addr) {
+      stack = UNWIND_CACHE.last_stack;
+    } else {
+      stack = jsStackTrace().split("\n");
+      if (stack[0] == "Error") {
+        stack.shift();
+      }
+      saveInUnwindCache(stack);
+    }
+    var offset = 3;
+    while (stack[offset] && convertFrameToPC(stack[offset]) != addr) {
+      ++offset;
+    }
+    for (var i = 0; i < count && stack[i + offset]; ++i) {
+      HEAP32[buffer + i * 4 >> 2] = convertFrameToPC(stack[i + offset]);
+    }
+    return i;
+  };
+  var ENV = {};
+  var getEnvStrings = () => {
+    if (!getEnvStrings.strings) {
+      var lang = (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8";
+      var env = {
+        "USER": "web_user",
+        "LOGNAME": "web_user",
+        "PATH": "/",
+        "PWD": "/",
+        "HOME": "/home/web_user",
+        "LANG": lang,
+        "_": getExecutableName()
+      };
+      for (var x in ENV) {
+        if (ENV[x] === void 0) delete env[x];
+        else env[x] = ENV[x];
+      }
+      var strings = [];
+      for (var x in env) {
+        strings.push(`${x}=${env[x]}`);
+      }
+      getEnvStrings.strings = strings;
+    }
+    return getEnvStrings.strings;
+  };
+  var _environ_get = (__environ, environ_buf) => {
+    var bufSize = 0;
+    var envp = 0;
+    for (var string of getEnvStrings()) {
+      var ptr = environ_buf + bufSize;
+      HEAPU32[__environ + envp >> 2] = ptr;
+      bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+      envp += 4;
+    }
+    return 0;
+  };
+  var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+    var strings = getEnvStrings();
+    HEAPU32[penviron_count >> 2] = strings.length;
+    var bufSize = 0;
+    for (var string of strings) {
+      bufSize += lengthBytesUTF8(string) + 1;
+    }
+    HEAPU32[penviron_buf_size >> 2] = 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];
+      var len = HEAPU32[iov + 4 >> 2];
+      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) {
+    try {
+      var stream = SYSCALLS.getStreamFromFD(fd);
+      var num = doReadv(stream, iov, iovcnt);
+      HEAPU32[pnum >> 2] = 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);
+    try {
+      if (isNaN(offset)) return 61;
+      var stream = SYSCALLS.getStreamFromFD(fd);
+      FS.llseek(stream, offset, whence);
+      HEAP64[newOffset >> 3] = 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];
+      var len = HEAPU32[iov + 4 >> 2];
+      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) {
+    try {
+      var stream = SYSCALLS.getStreamFromFD(fd);
+      var num = doWritev(stream, iov, iovcnt);
+      HEAPU32[pnum >> 2] = num;
+      return 0;
+    } catch (e) {
+      if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+      return e.errno;
+    }
+  }
+  var runtimeKeepaliveCounter = 0;
+  var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+  var _proc_exit = (code) => {
+    EXITSTATUS = code;
+    if (!keepRuntimeAlive()) {
+      Module["onExit"]?.(code);
+      ABORT = true;
+    }
+    quit_(code, new ExitStatus(code));
+  };
+  var getCFunc = (ident) => {
+    var func = Module["_" + ident];
+    assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
+    return func;
+  };
+  var writeArrayToMemory = (array, buffer) => {
+    assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
+    HEAP8.set(array, buffer);
+  };
+  var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+  var stringToUTF8OnStack = (str) => {
+    var size = lengthBytesUTF8(str) + 1;
+    var ret = stackAlloc(size);
+    stringToUTF8(str, ret, size);
+    return ret;
+  };
+  var ccall = (ident, returnType, argTypes, args, opts) => {
+    var toC = {
+      "string": (str) => {
+        var ret2 = 0;
+        if (str !== null && str !== void 0 && str !== 0) {
+          ret2 = stringToUTF8OnStack(str);
+        }
+        return ret2;
+      },
+      "array": (arr) => {
+        var ret2 = stackAlloc(arr.length);
+        writeArrayToMemory(arr, ret2);
+        return ret2;
+      }
+    };
+    function convertReturnValue(ret2) {
+      if (returnType === "string") {
+        return UTF8ToString(ret2);
+      }
+      if (returnType === "boolean") return Boolean(ret2);
+      return ret2;
+    }
+    var func = getCFunc(ident);
+    var cArgs = [];
+    var stack = 0;
+    assert(returnType !== "array", 'Return type should not be "array".');
+    if (args) {
+      for (var i = 0; i < args.length; i++) {
+        var converter = toC[argTypes[i]];
+        if (converter) {
+          if (stack === 0) stack = stackSave();
+          cArgs[i] = converter(args[i]);
+        } else {
+          cArgs[i] = args[i];
+        }
+      }
+    }
+    var ret = func(...cArgs);
+    function onDone(ret2) {
+      if (stack !== 0) stackRestore(stack);
+      return convertReturnValue(ret2);
+    }
+    ret = onDone(ret);
+    return ret;
+  };
+  var cwrap = (ident, returnType, argTypes, opts) => {
+    return (...args) => ccall(ident, returnType, argTypes, args, opts);
+  };
+  FS.createPreloadedFile = FS_createPreloadedFile;
+  FS.preloadFile = FS_preloadFile;
+  FS.staticInit();
+  ;
+  {
+    initMemory();
+    if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+    if (Module["preloadPlugins"]) preloadPlugins = Module["preloadPlugins"];
+    if (Module["print"]) out = Module["print"];
+    if (Module["printErr"]) err = Module["printErr"];
+    if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+    checkIncomingModuleAPI();
+    if (Module["arguments"]) arguments_ = Module["arguments"];
+    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+    assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
+    assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
+    assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
+    assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
+    assert(typeof Module["read"] == "undefined", "Module.read option was removed");
+    assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
+    assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
+    assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");
+    assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
+    assert(typeof Module["ENVIRONMENT"] == "undefined", "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
+    assert(typeof Module["STACK_SIZE"] == "undefined", "STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time");
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].shift()();
+      }
+    }
+    consumedModuleProp("preInit");
+  }
+  Module["cwrap"] = cwrap;
+  Module["UTF8ToString"] = UTF8ToString;
+  Module["stringToUTF8"] = stringToUTF8;
+  Module["lengthBytesUTF8"] = lengthBytesUTF8;
+  var missingLibrarySymbols = [
+    "writeI53ToI64",
+    "writeI53ToI64Clamped",
+    "writeI53ToI64Signaling",
+    "writeI53ToU64Clamped",
+    "writeI53ToU64Signaling",
+    "readI53FromI64",
+    "readI53FromU64",
+    "convertI32PairToI53",
+    "convertI32PairToI53Checked",
+    "convertU32PairToI53",
+    "getTempRet0",
+    "setTempRet0",
+    "createNamedFunction",
+    "exitJS",
+    "withStackSave",
+    "inetPton4",
+    "inetNtop4",
+    "inetPton6",
+    "inetNtop6",
+    "readSockaddr",
+    "writeSockaddr",
+    "readEmAsmArgs",
+    "jstoi_q",
+    "autoResumeAudioContext",
+    "getDynCaller",
+    "dynCall",
+    "handleException",
+    "runtimeKeepalivePush",
+    "runtimeKeepalivePop",
+    "callUserCallback",
+    "maybeExit",
+    "asmjsMangle",
+    "HandleAllocator",
+    "addOnInit",
+    "addOnPostCtor",
+    "addOnPreMain",
+    "addOnExit",
+    "STACK_SIZE",
+    "STACK_ALIGN",
+    "POINTER_SIZE",
+    "ASSERTIONS",
+    "convertJsFunctionToWasm",
+    "getEmptyTableSlot",
+    "updateTableMap",
+    "getFunctionAddress",
+    "addFunction",
+    "removeFunction",
+    "intArrayToString",
+    "AsciiToString",
+    "stringToAscii",
+    "UTF16ToString",
+    "stringToUTF16",
+    "lengthBytesUTF16",
+    "UTF32ToString",
+    "stringToUTF32",
+    "lengthBytesUTF32",
+    "registerKeyEventCallback",
+    "maybeCStringToJsString",
+    "findEventTarget",
+    "getBoundingClientRect",
+    "fillMouseEventData",
+    "registerMouseEventCallback",
+    "registerWheelEventCallback",
+    "registerUiEventCallback",
+    "registerFocusEventCallback",
+    "fillDeviceOrientationEventData",
+    "registerDeviceOrientationEventCallback",
+    "fillDeviceMotionEventData",
+    "registerDeviceMotionEventCallback",
+    "screenOrientation",
+    "fillOrientationChangeEventData",
+    "registerOrientationChangeEventCallback",
+    "fillFullscreenChangeEventData",
+    "registerFullscreenChangeEventCallback",
+    "JSEvents_requestFullscreen",
+    "JSEvents_resizeCanvasForFullscreen",
+    "registerRestoreOldStyle",
+    "hideEverythingExceptGivenElement",
+    "restoreHiddenElements",
+    "setLetterbox",
+    "softFullscreenResizeWebGLRenderTarget",
+    "doRequestFullscreen",
+    "fillPointerlockChangeEventData",
+    "registerPointerlockChangeEventCallback",
+    "registerPointerlockErrorEventCallback",
+    "requestPointerLock",
+    "fillVisibilityChangeEventData",
+    "registerVisibilityChangeEventCallback",
+    "registerTouchEventCallback",
+    "fillGamepadEventData",
+    "registerGamepadEventCallback",
+    "registerBeforeUnloadEventCallback",
+    "fillBatteryEventData",
+    "registerBatteryEventCallback",
+    "setCanvasElementSize",
+    "getCanvasElementSize",
+    "getCallstack",
+    "wasiRightsToMuslOFlags",
+    "wasiOFlagsToMuslOFlags",
+    "safeSetTimeout",
+    "setImmediateWrapped",
+    "safeRequestAnimationFrame",
+    "clearImmediateWrapped",
+    "registerPostMainLoop",
+    "registerPreMainLoop",
+    "getPromise",
+    "makePromise",
+    "idsToPromises",
+    "makePromiseCallback",
+    "Browser_asyncPrepareDataCounter",
+    "arraySum",
+    "addDays",
+    "getSocketFromFD",
+    "getSocketAddress",
+    "FS_mkdirTree",
+    "_setNetworkCallback",
+    "ALLOC_NORMAL",
+    "ALLOC_STACK",
+    "allocate",
+    "writeStringToMemory",
+    "writeAsciiToMemory",
+    "allocateUTF8",
+    "allocateUTF8OnStack",
+    "stackTrace",
+    "getNativeTypeSize"
+  ];
+  missingLibrarySymbols.forEach(missingLibrarySymbol);
+  var unexportedSymbols = [
+    "run",
+    "out",
+    "err",
+    "callMain",
+    "abort",
+    "wasmExports",
+    "HEAPF32",
+    "HEAPF64",
+    "HEAP16",
+    "HEAPU16",
+    "HEAP32",
+    "HEAPU32",
+    "HEAP64",
+    "HEAPU64",
+    "WasmSourceMap",
+    "writeStackCookie",
+    "checkStackCookie",
+    "INT53_MAX",
+    "INT53_MIN",
+    "bigintToI53Checked",
+    "stackSave",
+    "stackRestore",
+    "stackAlloc",
+    "ptrToString",
+    "zeroMemory",
+    "getHeapMax",
+    "growMemory",
+    "ENV",
+    "ERRNO_CODES",
+    "strError",
+    "DNS",
+    "Protocols",
+    "Sockets",
+    "timers",
+    "warnOnce",
+    "noLeakCheck",
+    "readEmAsmArgsArray",
+    "getExecutableName",
+    "keepRuntimeAlive",
+    "asyncLoad",
+    "alignMemory",
+    "mmapAlloc",
+    "wasmTable",
+    "wasmMemory",
+    "getUniqueRunDependency",
+    "noExitRuntime",
+    "addRunDependency",
+    "removeRunDependency",
+    "addOnPreRun",
+    "addOnPostRun",
+    "ccall",
+    "freeTableIndexes",
+    "functionsInTableMap",
+    "setValue",
+    "getValue",
+    "PATH",
+    "PATH_FS",
+    "UTF8Decoder",
+    "UTF8ArrayToString",
+    "stringToUTF8Array",
+    "intArrayFromString",
+    "UTF16Decoder",
+    "stringToNewUTF8",
+    "stringToUTF8OnStack",
+    "writeArrayToMemory",
+    "JSEvents",
+    "specialHTMLTargets",
+    "findCanvasEventTarget",
+    "currentFullscreenStrategy",
+    "restoreOldWindowedStyle",
+    "jsStackTrace",
+    "UNWIND_CACHE",
+    "convertPCtoSourceLocation",
+    "ExitStatus",
+    "getEnvStrings",
+    "checkWasiClock",
+    "doReadv",
+    "doWritev",
+    "initRandomFill",
+    "randomFill",
+    "emSetImmediate",
+    "emClearImmediate_deps",
+    "emClearImmediate",
+    "promiseMap",
+    "Browser",
+    "requestFullscreen",
+    "requestFullScreen",
+    "setCanvasSize",
+    "getUserMedia",
+    "createContext",
+    "getPreloadedImageData__data",
+    "wget",
+    "MONTH_DAYS_REGULAR",
+    "MONTH_DAYS_LEAP",
+    "MONTH_DAYS_REGULAR_CUMULATIVE",
+    "MONTH_DAYS_LEAP_CUMULATIVE",
+    "isLeapYear",
+    "ydayFromDate",
+    "SYSCALLS",
+    "preloadPlugins",
+    "FS_createPreloadedFile",
+    "FS_preloadFile",
+    "FS_modeStringToFlags",
+    "FS_getMode",
+    "FS_stdin_getChar_buffer",
+    "FS_stdin_getChar",
+    "FS_unlink",
+    "FS_createPath",
+    "FS_createDevice",
+    "FS_readFile",
+    "FS",
+    "FS_root",
+    "FS_mounts",
+    "FS_devices",
+    "FS_streams",
+    "FS_nextInode",
+    "FS_nameTable",
+    "FS_currentPath",
+    "FS_initialized",
+    "FS_ignorePermissions",
+    "FS_filesystems",
+    "FS_syncFSRequests",
+    "FS_lookupPath",
+    "FS_getPath",
+    "FS_hashName",
+    "FS_hashAddNode",
+    "FS_hashRemoveNode",
+    "FS_lookupNode",
+    "FS_createNode",
+    "FS_destroyNode",
+    "FS_isRoot",
+    "FS_isMountpoint",
+    "FS_isFile",
+    "FS_isDir",
+    "FS_isLink",
+    "FS_isChrdev",
+    "FS_isBlkdev",
+    "FS_isFIFO",
+    "FS_isSocket",
+    "FS_flagsToPermissionString",
+    "FS_nodePermissions",
+    "FS_mayLookup",
+    "FS_mayCreate",
+    "FS_mayDelete",
+    "FS_mayOpen",
+    "FS_checkOpExists",
+    "FS_nextfd",
+    "FS_getStreamChecked",
+    "FS_getStream",
+    "FS_createStream",
+    "FS_closeStream",
+    "FS_dupStream",
+    "FS_doSetAttr",
+    "FS_chrdev_stream_ops",
+    "FS_major",
+    "FS_minor",
+    "FS_makedev",
+    "FS_registerDevice",
+    "FS_getDevice",
+    "FS_getMounts",
+    "FS_syncfs",
+    "FS_mount",
+    "FS_unmount",
+    "FS_lookup",
+    "FS_mknod",
+    "FS_statfs",
+    "FS_statfsStream",
+    "FS_statfsNode",
+    "FS_create",
+    "FS_mkdir",
+    "FS_mkdev",
+    "FS_symlink",
+    "FS_rename",
+    "FS_rmdir",
+    "FS_readdir",
+    "FS_readlink",
+    "FS_stat",
+    "FS_fstat",
+    "FS_lstat",
+    "FS_doChmod",
+    "FS_chmod",
+    "FS_lchmod",
+    "FS_fchmod",
+    "FS_doChown",
+    "FS_chown",
+    "FS_lchown",
+    "FS_fchown",
+    "FS_doTruncate",
+    "FS_truncate",
+    "FS_ftruncate",
+    "FS_utime",
+    "FS_open",
+    "FS_close",
+    "FS_isClosed",
+    "FS_llseek",
+    "FS_read",
+    "FS_write",
+    "FS_mmap",
+    "FS_msync",
+    "FS_ioctl",
+    "FS_writeFile",
+    "FS_cwd",
+    "FS_chdir",
+    "FS_createDefaultDirectories",
+    "FS_createDefaultDevices",
+    "FS_createSpecialDirectories",
+    "FS_createStandardStreams",
+    "FS_staticInit",
+    "FS_init",
+    "FS_quit",
+    "FS_findObject",
+    "FS_analyzePath",
+    "FS_createFile",
+    "FS_createDataFile",
+    "FS_forceLoadFile",
+    "FS_createLazyFile",
+    "FS_absolutePath",
+    "FS_createFolder",
+    "FS_createLink",
+    "FS_joinPath",
+    "FS_mmapAlloc",
+    "FS_standardizePath",
+    "MEMFS",
+    "TTY",
+    "PIPEFS",
+    "SOCKFS",
+    "print",
+    "printErr",
+    "jstoi_s"
+  ];
+  unexportedSymbols.forEach(unexportedRuntimeSymbol);
+  function checkIncomingModuleAPI() {
+    ignoredModuleProp("fetchSettings");
+    ignoredModuleProp("logReadFiles");
+    ignoredModuleProp("loadSplitModule");
+  }
+  function qts_host_ref_free(rt, id) {
+    const asyncify = void 0;
+    Module["callbacks"]["freeHostRef"](asyncify, rt, id);
+  }
+  function qts_host_call_function(ctx, this_ptr, argc, argv, host_ref_id) {
+    const asyncify = void 0;
+    return Module["callbacks"]["callFunction"](asyncify, ctx, this_ptr, argc, argv, host_ref_id);
+  }
+  function qts_host_interrupt_handler(rt) {
+    const asyncify = void 0;
+    return Module["callbacks"]["shouldInterrupt"](asyncify, rt);
+  }
+  function qts_host_load_module_source(rt, ctx, module_name) {
+    const asyncify = void 0;
+    const moduleNameString = UTF8ToString(module_name);
+    return Module["callbacks"]["loadModuleSource"](asyncify, rt, ctx, moduleNameString);
+  }
+  function qts_host_normalize_module(rt, ctx, module_base_name, module_name) {
+    const asyncify = void 0;
+    const moduleBaseNameString = UTF8ToString(module_base_name);
+    const moduleNameString = UTF8ToString(module_name);
+    return Module["callbacks"]["normalizeModule"](asyncify, rt, ctx, moduleBaseNameString, moduleNameString);
+  }
+  var _malloc = Module["_malloc"] = makeInvalidEarlyAccess("_malloc");
+  var _QTS_Throw = Module["_QTS_Throw"] = makeInvalidEarlyAccess("_QTS_Throw");
+  var _QTS_NewError = Module["_QTS_NewError"] = makeInvalidEarlyAccess("_QTS_NewError");
+  var _QTS_RuntimeSetMemoryLimit = Module["_QTS_RuntimeSetMemoryLimit"] = makeInvalidEarlyAccess("_QTS_RuntimeSetMemoryLimit");
+  var _QTS_RuntimeComputeMemoryUsage = Module["_QTS_RuntimeComputeMemoryUsage"] = makeInvalidEarlyAccess("_QTS_RuntimeComputeMemoryUsage");
+  var _QTS_RuntimeDumpMemoryUsage = Module["_QTS_RuntimeDumpMemoryUsage"] = makeInvalidEarlyAccess("_QTS_RuntimeDumpMemoryUsage");
+  var _QTS_RecoverableLeakCheck = Module["_QTS_RecoverableLeakCheck"] = makeInvalidEarlyAccess("_QTS_RecoverableLeakCheck");
+  var _QTS_BuildIsSanitizeLeak = Module["_QTS_BuildIsSanitizeLeak"] = makeInvalidEarlyAccess("_QTS_BuildIsSanitizeLeak");
+  var _QTS_RuntimeSetMaxStackSize = Module["_QTS_RuntimeSetMaxStackSize"] = makeInvalidEarlyAccess("_QTS_RuntimeSetMaxStackSize");
+  var _QTS_GetUndefined = Module["_QTS_GetUndefined"] = makeInvalidEarlyAccess("_QTS_GetUndefined");
+  var _QTS_GetNull = Module["_QTS_GetNull"] = makeInvalidEarlyAccess("_QTS_GetNull");
+  var _QTS_GetFalse = Module["_QTS_GetFalse"] = makeInvalidEarlyAccess("_QTS_GetFalse");
+  var _QTS_GetTrue = Module["_QTS_GetTrue"] = makeInvalidEarlyAccess("_QTS_GetTrue");
+  var _QTS_NewHostRef = Module["_QTS_NewHostRef"] = makeInvalidEarlyAccess("_QTS_NewHostRef");
+  var _QTS_GetHostRefId = Module["_QTS_GetHostRefId"] = makeInvalidEarlyAccess("_QTS_GetHostRefId");
+  var _QTS_NewRuntime = Module["_QTS_NewRuntime"] = makeInvalidEarlyAccess("_QTS_NewRuntime");
+  var _QTS_FreeRuntime = Module["_QTS_FreeRuntime"] = makeInvalidEarlyAccess("_QTS_FreeRuntime");
+  var _free = Module["_free"] = makeInvalidEarlyAccess("_free");
+  var _QTS_NewContext = Module["_QTS_NewContext"] = makeInvalidEarlyAccess("_QTS_NewContext");
+  var _QTS_FreeContext = Module["_QTS_FreeContext"] = makeInvalidEarlyAccess("_QTS_FreeContext");
+  var _QTS_FreeValuePointer = Module["_QTS_FreeValuePointer"] = makeInvalidEarlyAccess("_QTS_FreeValuePointer");
+  var _QTS_FreeValuePointerRuntime = Module["_QTS_FreeValuePointerRuntime"] = makeInvalidEarlyAccess("_QTS_FreeValuePointerRuntime");
+  var _QTS_FreeVoidPointer = Module["_QTS_FreeVoidPointer"] = makeInvalidEarlyAccess("_QTS_FreeVoidPointer");
+  var _QTS_FreeCString = Module["_QTS_FreeCString"] = makeInvalidEarlyAccess("_QTS_FreeCString");
+  var _QTS_DupValuePointer = Module["_QTS_DupValuePointer"] = makeInvalidEarlyAccess("_QTS_DupValuePointer");
+  var _QTS_NewObject = Module["_QTS_NewObject"] = makeInvalidEarlyAccess("_QTS_NewObject");
+  var _QTS_NewObjectProto = Module["_QTS_NewObjectProto"] = makeInvalidEarlyAccess("_QTS_NewObjectProto");
+  var _QTS_NewArray = Module["_QTS_NewArray"] = makeInvalidEarlyAccess("_QTS_NewArray");
+  var _QTS_NewArrayBuffer = Module["_QTS_NewArrayBuffer"] = makeInvalidEarlyAccess("_QTS_NewArrayBuffer");
+  var _QTS_NewFloat64 = Module["_QTS_NewFloat64"] = makeInvalidEarlyAccess("_QTS_NewFloat64");
+  var _QTS_GetFloat64 = Module["_QTS_GetFloat64"] = makeInvalidEarlyAccess("_QTS_GetFloat64");
+  var _QTS_NewString = Module["_QTS_NewString"] = makeInvalidEarlyAccess("_QTS_NewString");
+  var _QTS_GetString = Module["_QTS_GetString"] = makeInvalidEarlyAccess("_QTS_GetString");
+  var _QTS_GetArrayBuffer = Module["_QTS_GetArrayBuffer"] = makeInvalidEarlyAccess("_QTS_GetArrayBuffer");
+  var _QTS_GetArrayBufferLength = Module["_QTS_GetArrayBufferLength"] = makeInvalidEarlyAccess("_QTS_GetArrayBufferLength");
+  var _QTS_NewSymbol = Module["_QTS_NewSymbol"] = makeInvalidEarlyAccess("_QTS_NewSymbol");
+  var _QTS_GetSymbolDescriptionOrKey = Module["_QTS_GetSymbolDescriptionOrKey"] = makeInvalidEarlyAccess("_QTS_GetSymbolDescriptionOrKey");
+  var _QTS_IsGlobalSymbol = Module["_QTS_IsGlobalSymbol"] = makeInvalidEarlyAccess("_QTS_IsGlobalSymbol");
+  var _QTS_IsJobPending = Module["_QTS_IsJobPending"] = makeInvalidEarlyAccess("_QTS_IsJobPending");
+  var _QTS_ExecutePendingJob = Module["_QTS_ExecutePendingJob"] = makeInvalidEarlyAccess("_QTS_ExecutePendingJob");
+  var _QTS_GetProp = Module["_QTS_GetProp"] = makeInvalidEarlyAccess("_QTS_GetProp");
+  var _QTS_GetPropNumber = Module["_QTS_GetPropNumber"] = makeInvalidEarlyAccess("_QTS_GetPropNumber");
+  var _QTS_SetProp = Module["_QTS_SetProp"] = makeInvalidEarlyAccess("_QTS_SetProp");
+  var _QTS_DefineProp = Module["_QTS_DefineProp"] = makeInvalidEarlyAccess("_QTS_DefineProp");
+  var _QTS_GetOwnPropertyNames = Module["_QTS_GetOwnPropertyNames"] = makeInvalidEarlyAccess("_QTS_GetOwnPropertyNames");
+  var _QTS_Call = Module["_QTS_Call"] = makeInvalidEarlyAccess("_QTS_Call");
+  var _QTS_ResolveException = Module["_QTS_ResolveException"] = makeInvalidEarlyAccess("_QTS_ResolveException");
+  var _QTS_Dump = Module["_QTS_Dump"] = makeInvalidEarlyAccess("_QTS_Dump");
+  var _QTS_Eval = Module["_QTS_Eval"] = makeInvalidEarlyAccess("_QTS_Eval");
+  var _QTS_GetModuleNamespace = Module["_QTS_GetModuleNamespace"] = makeInvalidEarlyAccess("_QTS_GetModuleNamespace");
+  var _QTS_Typeof = Module["_QTS_Typeof"] = makeInvalidEarlyAccess("_QTS_Typeof");
+  var _QTS_GetLength = Module["_QTS_GetLength"] = makeInvalidEarlyAccess("_QTS_GetLength");
+  var _QTS_IsEqual = Module["_QTS_IsEqual"] = makeInvalidEarlyAccess("_QTS_IsEqual");
+  var _QTS_GetGlobalObject = Module["_QTS_GetGlobalObject"] = makeInvalidEarlyAccess("_QTS_GetGlobalObject");
+  var _QTS_NewPromiseCapability = Module["_QTS_NewPromiseCapability"] = makeInvalidEarlyAccess("_QTS_NewPromiseCapability");
+  var _QTS_PromiseState = Module["_QTS_PromiseState"] = makeInvalidEarlyAccess("_QTS_PromiseState");
+  var _QTS_PromiseResult = Module["_QTS_PromiseResult"] = makeInvalidEarlyAccess("_QTS_PromiseResult");
+  var _QTS_TestStringArg = Module["_QTS_TestStringArg"] = makeInvalidEarlyAccess("_QTS_TestStringArg");
+  var _QTS_GetDebugLogEnabled = Module["_QTS_GetDebugLogEnabled"] = makeInvalidEarlyAccess("_QTS_GetDebugLogEnabled");
+  var _QTS_SetDebugLogEnabled = Module["_QTS_SetDebugLogEnabled"] = makeInvalidEarlyAccess("_QTS_SetDebugLogEnabled");
+  var _QTS_BuildIsDebug = Module["_QTS_BuildIsDebug"] = makeInvalidEarlyAccess("_QTS_BuildIsDebug");
+  var _QTS_BuildIsAsyncify = Module["_QTS_BuildIsAsyncify"] = makeInvalidEarlyAccess("_QTS_BuildIsAsyncify");
+  var _QTS_NewFunction = Module["_QTS_NewFunction"] = makeInvalidEarlyAccess("_QTS_NewFunction");
+  var _QTS_ArgvGetJSValueConstPointer = Module["_QTS_ArgvGetJSValueConstPointer"] = makeInvalidEarlyAccess("_QTS_ArgvGetJSValueConstPointer");
+  var _QTS_RuntimeEnableInterruptHandler = Module["_QTS_RuntimeEnableInterruptHandler"] = makeInvalidEarlyAccess("_QTS_RuntimeEnableInterruptHandler");
+  var _QTS_RuntimeDisableInterruptHandler = Module["_QTS_RuntimeDisableInterruptHandler"] = makeInvalidEarlyAccess("_QTS_RuntimeDisableInterruptHandler");
+  var _QTS_RuntimeEnableModuleLoader = Module["_QTS_RuntimeEnableModuleLoader"] = makeInvalidEarlyAccess("_QTS_RuntimeEnableModuleLoader");
+  var _QTS_RuntimeDisableModuleLoader = Module["_QTS_RuntimeDisableModuleLoader"] = makeInvalidEarlyAccess("_QTS_RuntimeDisableModuleLoader");
+  var _QTS_bjson_encode = Module["_QTS_bjson_encode"] = makeInvalidEarlyAccess("_QTS_bjson_encode");
+  var _QTS_bjson_decode = Module["_QTS_bjson_decode"] = makeInvalidEarlyAccess("_QTS_bjson_decode");
+  var _fflush = makeInvalidEarlyAccess("_fflush");
+  var _strerror = makeInvalidEarlyAccess("_strerror");
+  var ___funcs_on_exit = makeInvalidEarlyAccess("___funcs_on_exit");
+  var _emscripten_builtin_memalign = makeInvalidEarlyAccess("_emscripten_builtin_memalign");
+  var _emscripten_stack_init = makeInvalidEarlyAccess("_emscripten_stack_init");
+  var _emscripten_stack_get_free = makeInvalidEarlyAccess("_emscripten_stack_get_free");
+  var _emscripten_stack_get_base = makeInvalidEarlyAccess("_emscripten_stack_get_base");
+  var _emscripten_stack_get_end = makeInvalidEarlyAccess("_emscripten_stack_get_end");
+  var __emscripten_stack_restore = makeInvalidEarlyAccess("__emscripten_stack_restore");
+  var __emscripten_stack_alloc = makeInvalidEarlyAccess("__emscripten_stack_alloc");
+  var _emscripten_stack_get_current = makeInvalidEarlyAccess("_emscripten_stack_get_current");
+  var ___lsan_disable = makeInvalidEarlyAccess("___lsan_disable");
+  var ___lsan_enable = makeInvalidEarlyAccess("___lsan_enable");
+  var __indirect_function_table = makeInvalidEarlyAccess("__indirect_function_table");
+  function assignWasmExports(wasmExports2) {
+    assert(typeof wasmExports2["malloc"] != "undefined", "missing Wasm export: malloc");
+    assert(typeof wasmExports2["QTS_Throw"] != "undefined", "missing Wasm export: QTS_Throw");
+    assert(typeof wasmExports2["QTS_NewError"] != "undefined", "missing Wasm export: QTS_NewError");
+    assert(typeof wasmExports2["QTS_RuntimeSetMemoryLimit"] != "undefined", "missing Wasm export: QTS_RuntimeSetMemoryLimit");
+    assert(typeof wasmExports2["QTS_RuntimeComputeMemoryUsage"] != "undefined", "missing Wasm export: QTS_RuntimeComputeMemoryUsage");
+    assert(typeof wasmExports2["QTS_RuntimeDumpMemoryUsage"] != "undefined", "missing Wasm export: QTS_RuntimeDumpMemoryUsage");
+    assert(typeof wasmExports2["QTS_RecoverableLeakCheck"] != "undefined", "missing Wasm export: QTS_RecoverableLeakCheck");
+    assert(typeof wasmExports2["QTS_BuildIsSanitizeLeak"] != "undefined", "missing Wasm export: QTS_BuildIsSanitizeLeak");
+    assert(typeof wasmExports2["QTS_RuntimeSetMaxStackSize"] != "undefined", "missing Wasm export: QTS_RuntimeSetMaxStackSize");
+    assert(typeof wasmExports2["QTS_GetUndefined"] != "undefined", "missing Wasm export: QTS_GetUndefined");
+    assert(typeof wasmExports2["QTS_GetNull"] != "undefined", "missing Wasm export: QTS_GetNull");
+    assert(typeof wasmExports2["QTS_GetFalse"] != "undefined", "missing Wasm export: QTS_GetFalse");
+    assert(typeof wasmExports2["QTS_GetTrue"] != "undefined", "missing Wasm export: QTS_GetTrue");
+    assert(typeof wasmExports2["QTS_NewHostRef"] != "undefined", "missing Wasm export: QTS_NewHostRef");
+    assert(typeof wasmExports2["QTS_GetHostRefId"] != "undefined", "missing Wasm export: QTS_GetHostRefId");
+    assert(typeof wasmExports2["QTS_NewRuntime"] != "undefined", "missing Wasm export: QTS_NewRuntime");
+    assert(typeof wasmExports2["QTS_FreeRuntime"] != "undefined", "missing Wasm export: QTS_FreeRuntime");
+    assert(typeof wasmExports2["free"] != "undefined", "missing Wasm export: free");
+    assert(typeof wasmExports2["QTS_NewContext"] != "undefined", "missing Wasm export: QTS_NewContext");
+    assert(typeof wasmExports2["QTS_FreeContext"] != "undefined", "missing Wasm export: QTS_FreeContext");
+    assert(typeof wasmExports2["QTS_FreeValuePointer"] != "undefined", "missing Wasm export: QTS_FreeValuePointer");
+    assert(typeof wasmExports2["QTS_FreeValuePointerRuntime"] != "undefined", "missing Wasm export: QTS_FreeValuePointerRuntime");
+    assert(typeof wasmExports2["QTS_FreeVoidPointer"] != "undefined", "missing Wasm export: QTS_FreeVoidPointer");
+    assert(typeof wasmExports2["QTS_FreeCString"] != "undefined", "missing Wasm export: QTS_FreeCString");
+    assert(typeof wasmExports2["QTS_DupValuePointer"] != "undefined", "missing Wasm export: QTS_DupValuePointer");
+    assert(typeof wasmExports2["QTS_NewObject"] != "undefined", "missing Wasm export: QTS_NewObject");
+    assert(typeof wasmExports2["QTS_NewObjectProto"] != "undefined", "missing Wasm export: QTS_NewObjectProto");
+    assert(typeof wasmExports2["QTS_NewArray"] != "undefined", "missing Wasm export: QTS_NewArray");
+    assert(typeof wasmExports2["QTS_NewArrayBuffer"] != "undefined", "missing Wasm export: QTS_NewArrayBuffer");
+    assert(typeof wasmExports2["QTS_NewFloat64"] != "undefined", "missing Wasm export: QTS_NewFloat64");
+    assert(typeof wasmExports2["QTS_GetFloat64"] != "undefined", "missing Wasm export: QTS_GetFloat64");
+    assert(typeof wasmExports2["QTS_NewString"] != "undefined", "missing Wasm export: QTS_NewString");
+    assert(typeof wasmExports2["QTS_GetString"] != "undefined", "missing Wasm export: QTS_GetString");
+    assert(typeof wasmExports2["QTS_GetArrayBuffer"] != "undefined", "missing Wasm export: QTS_GetArrayBuffer");
+    assert(typeof wasmExports2["QTS_GetArrayBufferLength"] != "undefined", "missing Wasm export: QTS_GetArrayBufferLength");
+    assert(typeof wasmExports2["QTS_NewSymbol"] != "undefined", "missing Wasm export: QTS_NewSymbol");
+    assert(typeof wasmExports2["QTS_GetSymbolDescriptionOrKey"] != "undefined", "missing Wasm export: QTS_GetSymbolDescriptionOrKey");
+    assert(typeof wasmExports2["QTS_IsGlobalSymbol"] != "undefined", "missing Wasm export: QTS_IsGlobalSymbol");
+    assert(typeof wasmExports2["QTS_IsJobPending"] != "undefined", "missing Wasm export: QTS_IsJobPending");
+    assert(typeof wasmExports2["QTS_ExecutePendingJob"] != "undefined", "missing Wasm export: QTS_ExecutePendingJob");
+    assert(typeof wasmExports2["QTS_GetProp"] != "undefined", "missing Wasm export: QTS_GetProp");
+    assert(typeof wasmExports2["QTS_GetPropNumber"] != "undefined", "missing Wasm export: QTS_GetPropNumber");
+    assert(typeof wasmExports2["QTS_SetProp"] != "undefined", "missing Wasm export: QTS_SetProp");
+    assert(typeof wasmExports2["QTS_DefineProp"] != "undefined", "missing Wasm export: QTS_DefineProp");
+    assert(typeof wasmExports2["QTS_GetOwnPropertyNames"] != "undefined", "missing Wasm export: QTS_GetOwnPropertyNames");
+    assert(typeof wasmExports2["QTS_Call"] != "undefined", "missing Wasm export: QTS_Call");
+    assert(typeof wasmExports2["QTS_ResolveException"] != "undefined", "missing Wasm export: QTS_ResolveException");
+    assert(typeof wasmExports2["QTS_Dump"] != "undefined", "missing Wasm export: QTS_Dump");
+    assert(typeof wasmExports2["QTS_Eval"] != "undefined", "missing Wasm export: QTS_Eval");
+    assert(typeof wasmExports2["QTS_GetModuleNamespace"] != "undefined", "missing Wasm export: QTS_GetModuleNamespace");
+    assert(typeof wasmExports2["QTS_Typeof"] != "undefined", "missing Wasm export: QTS_Typeof");
+    assert(typeof wasmExports2["QTS_GetLength"] != "undefined", "missing Wasm export: QTS_GetLength");
+    assert(typeof wasmExports2["QTS_IsEqual"] != "undefined", "missing Wasm export: QTS_IsEqual");
+    assert(typeof wasmExports2["QTS_GetGlobalObject"] != "undefined", "missing Wasm export: QTS_GetGlobalObject");
+    assert(typeof wasmExports2["QTS_NewPromiseCapability"] != "undefined", "missing Wasm export: QTS_NewPromiseCapability");
+    assert(typeof wasmExports2["QTS_PromiseState"] != "undefined", "missing Wasm export: QTS_PromiseState");
+    assert(typeof wasmExports2["QTS_PromiseResult"] != "undefined", "missing Wasm export: QTS_PromiseResult");
+    assert(typeof wasmExports2["QTS_TestStringArg"] != "undefined", "missing Wasm export: QTS_TestStringArg");
+    assert(typeof wasmExports2["QTS_GetDebugLogEnabled"] != "undefined", "missing Wasm export: QTS_GetDebugLogEnabled");
+    assert(typeof wasmExports2["QTS_SetDebugLogEnabled"] != "undefined", "missing Wasm export: QTS_SetDebugLogEnabled");
+    assert(typeof wasmExports2["QTS_BuildIsDebug"] != "undefined", "missing Wasm export: QTS_BuildIsDebug");
+    assert(typeof wasmExports2["QTS_BuildIsAsyncify"] != "undefined", "missing Wasm export: QTS_BuildIsAsyncify");
+    assert(typeof wasmExports2["QTS_NewFunction"] != "undefined", "missing Wasm export: QTS_NewFunction");
+    assert(typeof wasmExports2["QTS_ArgvGetJSValueConstPointer"] != "undefined", "missing Wasm export: QTS_ArgvGetJSValueConstPointer");
+    assert(typeof wasmExports2["QTS_RuntimeEnableInterruptHandler"] != "undefined", "missing Wasm export: QTS_RuntimeEnableInterruptHandler");
+    assert(typeof wasmExports2["QTS_RuntimeDisableInterruptHandler"] != "undefined", "missing Wasm export: QTS_RuntimeDisableInterruptHandler");
+    assert(typeof wasmExports2["QTS_RuntimeEnableModuleLoader"] != "undefined", "missing Wasm export: QTS_RuntimeEnableModuleLoader");
+    assert(typeof wasmExports2["QTS_RuntimeDisableModuleLoader"] != "undefined", "missing Wasm export: QTS_RuntimeDisableModuleLoader");
+    assert(typeof wasmExports2["QTS_bjson_encode"] != "undefined", "missing Wasm export: QTS_bjson_encode");
+    assert(typeof wasmExports2["QTS_bjson_decode"] != "undefined", "missing Wasm export: QTS_bjson_decode");
+    assert(typeof wasmExports2["fflush"] != "undefined", "missing Wasm export: fflush");
+    assert(typeof wasmExports2["strerror"] != "undefined", "missing Wasm export: strerror");
+    assert(typeof wasmExports2["__funcs_on_exit"] != "undefined", "missing Wasm export: __funcs_on_exit");
+    assert(typeof wasmExports2["emscripten_builtin_memalign"] != "undefined", "missing Wasm export: emscripten_builtin_memalign");
+    assert(typeof wasmExports2["emscripten_stack_init"] != "undefined", "missing Wasm export: emscripten_stack_init");
+    assert(typeof wasmExports2["emscripten_stack_get_free"] != "undefined", "missing Wasm export: emscripten_stack_get_free");
+    assert(typeof wasmExports2["emscripten_stack_get_base"] != "undefined", "missing Wasm export: emscripten_stack_get_base");
+    assert(typeof wasmExports2["emscripten_stack_get_end"] != "undefined", "missing Wasm export: emscripten_stack_get_end");
+    assert(typeof wasmExports2["_emscripten_stack_restore"] != "undefined", "missing Wasm export: _emscripten_stack_restore");
+    assert(typeof wasmExports2["_emscripten_stack_alloc"] != "undefined", "missing Wasm export: _emscripten_stack_alloc");
+    assert(typeof wasmExports2["emscripten_stack_get_current"] != "undefined", "missing Wasm export: emscripten_stack_get_current");
+    assert(typeof wasmExports2["__lsan_disable"] != "undefined", "missing Wasm export: __lsan_disable");
+    assert(typeof wasmExports2["__lsan_enable"] != "undefined", "missing Wasm export: __lsan_enable");
+    assert(typeof wasmExports2["__indirect_function_table"] != "undefined", "missing Wasm export: __indirect_function_table");
+    _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);
+    _QTS_Throw = Module["_QTS_Throw"] = createExportWrapper("QTS_Throw", 2);
+    _QTS_NewError = Module["_QTS_NewError"] = createExportWrapper("QTS_NewError", 1);
+    _QTS_RuntimeSetMemoryLimit = Module["_QTS_RuntimeSetMemoryLimit"] = createExportWrapper("QTS_RuntimeSetMemoryLimit", 2);
+    _QTS_RuntimeComputeMemoryUsage = Module["_QTS_RuntimeComputeMemoryUsage"] = createExportWrapper("QTS_RuntimeComputeMemoryUsage", 2);
+    _QTS_RuntimeDumpMemoryUsage = Module["_QTS_RuntimeDumpMemoryUsage"] = createExportWrapper("QTS_RuntimeDumpMemoryUsage", 1);
+    _QTS_RecoverableLeakCheck = Module["_QTS_RecoverableLeakCheck"] = createExportWrapper("QTS_RecoverableLeakCheck", 0);
+    _QTS_BuildIsSanitizeLeak = Module["_QTS_BuildIsSanitizeLeak"] = createExportWrapper("QTS_BuildIsSanitizeLeak", 0);
+    _QTS_RuntimeSetMaxStackSize = Module["_QTS_RuntimeSetMaxStackSize"] = createExportWrapper("QTS_RuntimeSetMaxStackSize", 2);
+    _QTS_GetUndefined = Module["_QTS_GetUndefined"] = createExportWrapper("QTS_GetUndefined", 0);
+    _QTS_GetNull = Module["_QTS_GetNull"] = createExportWrapper("QTS_GetNull", 0);
+    _QTS_GetFalse = Module["_QTS_GetFalse"] = createExportWrapper("QTS_GetFalse", 0);
+    _QTS_GetTrue = Module["_QTS_GetTrue"] = createExportWrapper("QTS_GetTrue", 0);
+    _QTS_NewHostRef = Module["_QTS_NewHostRef"] = createExportWrapper("QTS_NewHostRef", 2);
+    _QTS_GetHostRefId = Module["_QTS_GetHostRefId"] = createExportWrapper("QTS_GetHostRefId", 1);
+    _QTS_NewRuntime = Module["_QTS_NewRuntime"] = createExportWrapper("QTS_NewRuntime", 0);
+    _QTS_FreeRuntime = Module["_QTS_FreeRuntime"] = createExportWrapper("QTS_FreeRuntime", 1);
+    _free = Module["_free"] = createExportWrapper("free", 1);
+    _QTS_NewContext = Module["_QTS_NewContext"] = createExportWrapper("QTS_NewContext", 2);
+    _QTS_FreeContext = Module["_QTS_FreeContext"] = createExportWrapper("QTS_FreeContext", 1);
+    _QTS_FreeValuePointer = Module["_QTS_FreeValuePointer"] = createExportWrapper("QTS_FreeValuePointer", 2);
+    _QTS_FreeValuePointerRuntime = Module["_QTS_FreeValuePointerRuntime"] = createExportWrapper("QTS_FreeValuePointerRuntime", 2);
+    _QTS_FreeVoidPointer = Module["_QTS_FreeVoidPointer"] = createExportWrapper("QTS_FreeVoidPointer", 2);
+    _QTS_FreeCString = Module["_QTS_FreeCString"] = createExportWrapper("QTS_FreeCString", 2);
+    _QTS_DupValuePointer = Module["_QTS_DupValuePointer"] = createExportWrapper("QTS_DupValuePointer", 2);
+    _QTS_NewObject = Module["_QTS_NewObject"] = createExportWrapper("QTS_NewObject", 1);
+    _QTS_NewObjectProto = Module["_QTS_NewObjectProto"] = createExportWrapper("QTS_NewObjectProto", 2);
+    _QTS_NewArray = Module["_QTS_NewArray"] = createExportWrapper("QTS_NewArray", 1);
+    _QTS_NewArrayBuffer = Module["_QTS_NewArrayBuffer"] = createExportWrapper("QTS_NewArrayBuffer", 3);
+    _QTS_NewFloat64 = Module["_QTS_NewFloat64"] = createExportWrapper("QTS_NewFloat64", 2);
+    _QTS_GetFloat64 = Module["_QTS_GetFloat64"] = createExportWrapper("QTS_GetFloat64", 2);
+    _QTS_NewString = Module["_QTS_NewString"] = createExportWrapper("QTS_NewString", 2);
+    _QTS_GetString = Module["_QTS_GetString"] = createExportWrapper("QTS_GetString", 2);
+    _QTS_GetArrayBuffer = Module["_QTS_GetArrayBuffer"] = createExportWrapper("QTS_GetArrayBuffer", 2);
+    _QTS_GetArrayBufferLength = Module["_QTS_GetArrayBufferLength"] = createExportWrapper("QTS_GetArrayBufferLength", 2);
+    _QTS_NewSymbol = Module["_QTS_NewSymbol"] = createExportWrapper("QTS_NewSymbol", 3);
+    _QTS_GetSymbolDescriptionOrKey = Module["_QTS_GetSymbolDescriptionOrKey"] = createExportWrapper("QTS_GetSymbolDescriptionOrKey", 2);
+    _QTS_IsGlobalSymbol = Module["_QTS_IsGlobalSymbol"] = createExportWrapper("QTS_IsGlobalSymbol", 2);
+    _QTS_IsJobPending = Module["_QTS_IsJobPending"] = createExportWrapper("QTS_IsJobPending", 1);
+    _QTS_ExecutePendingJob = Module["_QTS_ExecutePendingJob"] = createExportWrapper("QTS_ExecutePendingJob", 3);
+    _QTS_GetProp = Module["_QTS_GetProp"] = createExportWrapper("QTS_GetProp", 3);
+    _QTS_GetPropNumber = Module["_QTS_GetPropNumber"] = createExportWrapper("QTS_GetPropNumber", 3);
+    _QTS_SetProp = Module["_QTS_SetProp"] = createExportWrapper("QTS_SetProp", 4);
+    _QTS_DefineProp = Module["_QTS_DefineProp"] = createExportWrapper("QTS_DefineProp", 9);
+    _QTS_GetOwnPropertyNames = Module["_QTS_GetOwnPropertyNames"] = createExportWrapper("QTS_GetOwnPropertyNames", 5);
+    _QTS_Call = Module["_QTS_Call"] = createExportWrapper("QTS_Call", 5);
+    _QTS_ResolveException = Module["_QTS_ResolveException"] = createExportWrapper("QTS_ResolveException", 2);
+    _QTS_Dump = Module["_QTS_Dump"] = createExportWrapper("QTS_Dump", 2);
+    _QTS_Eval = Module["_QTS_Eval"] = createExportWrapper("QTS_Eval", 6);
+    _QTS_GetModuleNamespace = Module["_QTS_GetModuleNamespace"] = createExportWrapper("QTS_GetModuleNamespace", 2);
+    _QTS_Typeof = Module["_QTS_Typeof"] = createExportWrapper("QTS_Typeof", 2);
+    _QTS_GetLength = Module["_QTS_GetLength"] = createExportWrapper("QTS_GetLength", 3);
+    _QTS_IsEqual = Module["_QTS_IsEqual"] = createExportWrapper("QTS_IsEqual", 4);
+    _QTS_GetGlobalObject = Module["_QTS_GetGlobalObject"] = createExportWrapper("QTS_GetGlobalObject", 1);
+    _QTS_NewPromiseCapability = Module["_QTS_NewPromiseCapability"] = createExportWrapper("QTS_NewPromiseCapability", 2);
+    _QTS_PromiseState = Module["_QTS_PromiseState"] = createExportWrapper("QTS_PromiseState", 2);
+    _QTS_PromiseResult = Module["_QTS_PromiseResult"] = createExportWrapper("QTS_PromiseResult", 2);
+    _QTS_TestStringArg = Module["_QTS_TestStringArg"] = createExportWrapper("QTS_TestStringArg", 1);
+    _QTS_GetDebugLogEnabled = Module["_QTS_GetDebugLogEnabled"] = createExportWrapper("QTS_GetDebugLogEnabled", 1);
+    _QTS_SetDebugLogEnabled = Module["_QTS_SetDebugLogEnabled"] = createExportWrapper("QTS_SetDebugLogEnabled", 2);
+    _QTS_BuildIsDebug = Module["_QTS_BuildIsDebug"] = createExportWrapper("QTS_BuildIsDebug", 0);
+    _QTS_BuildIsAsyncify = Module["_QTS_BuildIsAsyncify"] = createExportWrapper("QTS_BuildIsAsyncify", 0);
+    _QTS_NewFunction = Module["_QTS_NewFunction"] = createExportWrapper("QTS_NewFunction", 5);
+    _QTS_ArgvGetJSValueConstPointer = Module["_QTS_ArgvGetJSValueConstPointer"] = createExportWrapper("QTS_ArgvGetJSValueConstPointer", 2);
+    _QTS_RuntimeEnableInterruptHandler = Module["_QTS_RuntimeEnableInterruptHandler"] = createExportWrapper("QTS_RuntimeEnableInterruptHandler", 1);
+    _QTS_RuntimeDisableInterruptHandler = Module["_QTS_RuntimeDisableInterruptHandler"] = createExportWrapper("QTS_RuntimeDisableInterruptHandler", 1);
+    _QTS_RuntimeEnableModuleLoader = Module["_QTS_RuntimeEnableModuleLoader"] = createExportWrapper("QTS_RuntimeEnableModuleLoader", 2);
+    _QTS_RuntimeDisableModuleLoader = Module["_QTS_RuntimeDisableModuleLoader"] = createExportWrapper("QTS_RuntimeDisableModuleLoader", 1);
+    _QTS_bjson_encode = Module["_QTS_bjson_encode"] = createExportWrapper("QTS_bjson_encode", 2);
+    _QTS_bjson_decode = Module["_QTS_bjson_decode"] = createExportWrapper("QTS_bjson_decode", 2);
+    _fflush = createExportWrapper("fflush", 1);
+    _strerror = createExportWrapper("strerror", 1);
+    ___funcs_on_exit = createExportWrapper("__funcs_on_exit", 0);
+    _emscripten_builtin_memalign = createExportWrapper("emscripten_builtin_memalign", 2);
+    _emscripten_stack_init = wasmExports2["emscripten_stack_init"];
+    _emscripten_stack_get_free = wasmExports2["emscripten_stack_get_free"];
+    _emscripten_stack_get_base = wasmExports2["emscripten_stack_get_base"];
+    _emscripten_stack_get_end = wasmExports2["emscripten_stack_get_end"];
+    __emscripten_stack_restore = wasmExports2["_emscripten_stack_restore"];
+    __emscripten_stack_alloc = wasmExports2["_emscripten_stack_alloc"];
+    _emscripten_stack_get_current = wasmExports2["emscripten_stack_get_current"];
+    ___lsan_disable = wasmExports2["__lsan_disable"];
+    ___lsan_enable = wasmExports2["__lsan_enable"];
+    __indirect_function_table = wasmExports2["__indirect_function_table"];
+  }
+  var wasmImports = {
+    /** @export */
+    __assert_fail: ___assert_fail,
+    /** @export */
+    __syscall_dup: ___syscall_dup,
+    /** @export */
+    __syscall_fstat64: ___syscall_fstat64,
+    /** @export */
+    __syscall_lstat64: ___syscall_lstat64,
+    /** @export */
+    __syscall_mkdirat: ___syscall_mkdirat,
+    /** @export */
+    __syscall_newfstatat: ___syscall_newfstatat,
+    /** @export */
+    __syscall_openat: ___syscall_openat,
+    /** @export */
+    __syscall_stat64: ___syscall_stat64,
+    /** @export */
+    _abort_js: __abort_js,
+    /** @export */
+    _emscripten_get_progname: __emscripten_get_progname,
+    /** @export */
+    _emscripten_sanitizer_get_option: __emscripten_sanitizer_get_option,
+    /** @export */
+    _emscripten_sanitizer_use_colors: __emscripten_sanitizer_use_colors,
+    /** @export */
+    _localtime_js: __localtime_js,
+    /** @export */
+    _mmap_js: __mmap_js,
+    /** @export */
+    _munmap_js: __munmap_js,
+    /** @export */
+    _tzset_js: __tzset_js,
+    /** @export */
+    clock_time_get: _clock_time_get,
+    /** @export */
+    emscripten_date_now: _emscripten_date_now,
+    /** @export */
+    emscripten_get_heap_max: _emscripten_get_heap_max,
+    /** @export */
+    emscripten_get_now: _emscripten_get_now,
+    /** @export */
+    emscripten_pc_get_column: _emscripten_pc_get_column,
+    /** @export */
+    emscripten_pc_get_file: _emscripten_pc_get_file,
+    /** @export */
+    emscripten_pc_get_function: _emscripten_pc_get_function,
+    /** @export */
+    emscripten_pc_get_line: _emscripten_pc_get_line,
+    /** @export */
+    emscripten_resize_heap: _emscripten_resize_heap,
+    /** @export */
+    emscripten_stack_snapshot: _emscripten_stack_snapshot,
+    /** @export */
+    emscripten_stack_unwind_buffer: _emscripten_stack_unwind_buffer,
+    /** @export */
+    environ_get: _environ_get,
+    /** @export */
+    environ_sizes_get: _environ_sizes_get,
+    /** @export */
+    fd_close: _fd_close,
+    /** @export */
+    fd_read: _fd_read,
+    /** @export */
+    fd_seek: _fd_seek,
+    /** @export */
+    fd_write: _fd_write,
+    /** @export */
+    memory: wasmMemory,
+    /** @export */
+    proc_exit: _proc_exit,
+    /** @export */
+    qts_host_call_function,
+    /** @export */
+    qts_host_interrupt_handler,
+    /** @export */
+    qts_host_load_module_source,
+    /** @export */
+    qts_host_normalize_module,
+    /** @export */
+    qts_host_ref_free
+  };
+  class WasmSourceMap {
+    mapping = {};
+    offsets = [];
+    constructor(sourceMap) {
+      this.version = sourceMap.version;
+      this.sources = sourceMap.sources;
+      this.names = sourceMap.names;
+      var vlqMap = {};
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach((c, i) => vlqMap[c] = i);
+      function decodeVLQ(string) {
+        var result = [];
+        var shift = 0;
+        var value = 0;
+        for (var ch of string) {
+          var integer = vlqMap[ch];
+          if (integer === void 0) {
+            throw new Error(`Invalid character (${ch})`);
+          }
+          value += (integer & 31) << shift;
+          if (integer & 32) {
+            shift += 5;
+          } else {
+            var negate = value & 1;
+            value >>= 1;
+            result.push(negate ? -value : value);
+            value = shift = 0;
+          }
+        }
+        return result;
+      }
+      var offset = 0, src = 0, line = 1, col = 1, name = 0;
+      for (const [index, segment] of sourceMap.mappings.split(",").entries()) {
+        if (!segment) continue;
+        var data = decodeVLQ(segment);
+        var info = {};
+        offset += data[0];
+        if (data.length >= 2) info.source = src += data[1];
+        if (data.length >= 3) info.line = line += data[2];
+        if (data.length >= 4) info.column = col += data[3];
+        if (data.length >= 5) info.name = name += data[4];
+        this.mapping[offset] = info;
+        this.offsets.push(offset);
+      }
+      this.offsets.sort((a, b) => a - b);
+    }
+    lookup(offset) {
+      var normalized = this.normalizeOffset(offset);
+      var info = this.mapping[normalized];
+      if (!info) {
+        return null;
+      }
+      return {
+        file: this.sources[info.source],
+        line: info.line,
+        column: info.column,
+        name: this.names[info.name]
+      };
+    }
+    normalizeOffset(offset) {
+      var lo = 0;
+      var hi = this.offsets.length;
+      var mid;
+      while (lo < hi) {
+        mid = Math.floor((lo + hi) / 2);
+        if (this.offsets[mid] > offset) {
+          hi = mid;
+        } else {
+          lo = mid + 1;
+        }
+      }
+      return this.offsets[lo - 1];
+    }
+  }
+  var wasmSourceMap;
+  var wasmSourceMapFile = locateFile("emscripten-module.wasm.map");
+  function receiveSourceMapJSON(sourceMap) {
+    wasmSourceMap = new WasmSourceMap(sourceMap);
+  }
+  function getSourceMap() {
+    var buf = readBinary(wasmSourceMapFile);
+    return JSON.parse(UTF8ArrayToString(buf));
+  }
+  async function getSourceMapAsync() {
+    if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      try {
+        var response = await fetch(wasmSourceMapFile, { credentials: "same-origin" });
+        return response.json();
+      } catch {
+      }
+    }
+    return getSourceMap();
+  }
+  addRunDependency("source-map");
+  getSourceMapAsync().then((json) => {
+    receiveSourceMapJSON(json);
+    removeRunDependency("source-map");
+  });
+  var calledRun;
+  function stackCheckInit() {
+    _emscripten_stack_init();
+    writeStackCookie();
+  }
+  function run() {
+    if (runDependencies > 0) {
+      dependenciesFulfilled = run;
+      return;
+    }
+    stackCheckInit();
+    preRun();
+    if (runDependencies > 0) {
+      dependenciesFulfilled = run;
+      return;
+    }
+    function doRun() {
+      assert(!calledRun);
+      calledRun = true;
+      Module["calledRun"] = true;
+      if (ABORT) return;
+      initRuntime();
+      readyPromiseResolve?.(Module);
+      Module["onRuntimeInitialized"]?.();
+      consumedModuleProp("onRuntimeInitialized");
+      assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
+      postRun();
+    }
+    if (Module["setStatus"]) {
+      Module["setStatus"]("Running...");
+      setTimeout(() => {
+        setTimeout(() => Module["setStatus"](""), 1);
+        doRun();
+      }, 1);
+    } else {
+      doRun();
+    }
+    checkStackCookie();
+  }
+  var wasmExports;
+  wasmExports = await createWasm();
+  run();
+  if (runtimeInitialized) {
+    moduleRtn = Module;
+  } else {
+    moduleRtn = new Promise((resolve, reject) => {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+  }
+  for (const prop of Object.keys(Module)) {
+    if (!(prop in moduleArg)) {
+      Object.defineProperty(moduleArg, prop, {
+        configurable: true,
+        get() {
+          abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`);
+        }
+      });
+    }
+  }
+  return moduleRtn;
+}
+var emscripten_module_default = QuickJSRaw;
+export {
+  emscripten_module_default as default
+};