@xeokit/xeokit-sdk 2.6.86-beta.0 → 2.6.86

package/dist/xeokit-sdk.es.js

@@ -1,7 +1,7 @@
 /**
- * xeokit-sdk v2.6.86-beta.0
- *  Commit: b493b423c957d61001d19c6407622d12db6cd1e7
- *  Built: 2025-07-29T12:27:53.081Z
+ * xeokit-sdk v2.6.86
+ *  Commit: c22de6eea11109e60991b4c31f0fb66792c24e2e
+ *  Built: 2025-07-29T15:16:54.682Z
  */
 
 /** @private */
@@ -74870,6 +74870,15 @@ const os = {
 
         return isIphone && isSafari;
     },
+    isIphoneOrIpadSafari() {
+        const userAgent = window.navigator.userAgent;
+        const isIphoneOrIpad = /iPhone|iPad/i.test(userAgent) || (
+            // iPad detection: Check for touch support and macOS-like user agent
+            /Macintosh/i.test(userAgent) && navigator.maxTouchPoints && navigator.maxTouchPoints > 2
+        );
+        const isSafari = /Safari/i.test(userAgent) && !/Chrome/i.test(userAgent);
+        return isIphoneOrIpad && isSafari;
+    },
     isTouchDevice() {
         return (
             'ontouchstart' in window || //works for most devices
@@ -102329,7 +102338,7 @@ function addContextMenuListener(elem, callback, failCallback = () => {}) {
         event.stopPropagation();
     };
     
-    if (os.isIphoneSafari()) {
+    if (os.isIphoneOrIpadSafari()) {
         elem.addEventListener('touchstart', touchStartHandler);
         elem.addEventListener('touchmove', touchMoveHandler);
         elem.addEventListener('touchend', touchEndHandler);
@@ -102339,7 +102348,7 @@ function addContextMenuListener(elem, callback, failCallback = () => {}) {
     }
 
     return function removeContextMenuListener() {
-        if (os.isIphoneSafari()) {
+        if (os.isIphoneOrIpadSafari()) {
             elem.removeEventListener('touchstart', touchStartHandler);
             elem.removeEventListener('touchmove', touchMoveHandler);
             elem.removeEventListener('touchend', touchEndHandler);
@@ -113470,13 +113479,13 @@ function getTableHeader(table) {
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION$6 = "4.3.2" ;
-const version = VERSION$6[0] >= '0' && VERSION$6[0] <= '9' ? `v${VERSION$6}` : '';
+const version$1 = VERSION$6[0] >= '0' && VERSION$6[0] <= '9' ? `v${VERSION$6}` : '';
 // Make sure we set the global variable
 function createLog() {
     const log = new Log({ id: 'loaders.gl' });
     globalThis.loaders = globalThis.loaders || {};
     globalThis.loaders.log = log;
-    globalThis.loaders.version = version;
+    globalThis.loaders.version = version$1;
     globalThis.probe = globalThis.probe || {};
     globalThis.probe.loaders = log;
     return log;
@@ -115029,7 +115038,7 @@ function isDataURL(url) {
  * - Supports fetching from Node.js local file system paths
  * - Respects pathPrefix and file aliases
  */
-async function fetchFile(urlOrData, fetchOptions) {
+async function fetchFile$1(urlOrData, fetchOptions) {
     if (typeof urlOrData === 'string') {
         const url = resolvePath(urlOrData);
         // Support fetching from local file system
@@ -115859,14 +115868,14 @@ function getFetchFunction(options, context) {
     }
     // options.fetch can be an options object
     if (isObject(loaderOptions.fetch)) {
-        return (url) => fetchFile(url, loaderOptions.fetch);
+        return (url) => fetchFile$1(url, loaderOptions.fetch);
     }
     // else refer to context (from parent loader) if available
     if (context?.fetch) {
         return context?.fetch;
     }
     // else return the default fetch function
-    return fetchFile;
+    return fetchFile$1;
 }
 
 // loaders.gl
@@ -117783,7 +117792,7 @@ function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets,
 }
 
 const EXT_MESH_FEATURES_NAME = 'EXT_mesh_features';
-const name$a = EXT_MESH_FEATURES_NAME;
+const name$b = EXT_MESH_FEATURES_NAME;
 async function decode$9(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtMeshFeatures(scenegraph, options);
@@ -117958,14 +117967,14 @@ function createAccessorKey(attributes) {
 
 var EXT_mesh_features = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$a,
+    name: name$b,
     decode: decode$9,
     encode: encode$5,
     createExtMeshFeatures: createExtMeshFeatures
 });
 
 const EXT_STRUCTURAL_METADATA_NAME = 'EXT_structural_metadata';
-const name$9 = EXT_STRUCTURAL_METADATA_NAME;
+const name$a = EXT_STRUCTURAL_METADATA_NAME;
 async function decode$8(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtStructuralMetadata(scenegraph, options);
@@ -118619,7 +118628,7 @@ function createBufferView(typedArray, scenegraph) {
 
 var EXT_structural_metadata = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$9,
+    name: name$a,
     decode: decode$8,
     encode: encode$4,
     createExtStructuralMetadata: createExtStructuralMetadata
@@ -118627,7 +118636,7 @@ var EXT_structural_metadata = /*#__PURE__*/Object.freeze({
 
 /** Extension name */
 const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
-const name$8 = EXT_FEATURE_METADATA_NAME;
+const name$9 = EXT_FEATURE_METADATA_NAME;
 async function decode$7(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtFeatureMetadata(scenegraph, options);
@@ -118925,7 +118934,7 @@ function processPrimitiveTextures(scenegraph, attributeName, featureTexturePrope
 
 var EXT_feature_metadata = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$8,
+    name: name$9,
     decode: decode$7
 });
 
@@ -119743,7 +119752,7 @@ function decode$6(instance, fun, target, count, size, source, filter) {
 
 /** Extension name */
 const EXT_MESHOPT_COMPRESSION = 'EXT_meshopt_compression';
-const name$7 = EXT_MESHOPT_COMPRESSION;
+const name$8 = EXT_MESHOPT_COMPRESSION;
 async function decode$5(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     if (!options?.gltf?.decompressMeshes || !options.gltf?.loadBuffers) {
@@ -119773,14 +119782,14 @@ async function decodeMeshoptBufferView(scenegraph, bufferView) {
 
 var EXT_meshopt_compression = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$7,
+    name: name$8,
     decode: decode$5
 });
 
 // GLTF EXTENSION: EXT_TEXTURE_WEBP
 const EXT_TEXTURE_WEBP = 'EXT_texture_webp';
 /** Extension name */
-const name$6 = EXT_TEXTURE_WEBP;
+const name$7 = EXT_TEXTURE_WEBP;
 /**
  * Replaces a texture source reference with the extension texture
  * Done in preprocess() to prevent load of default image
@@ -119808,14 +119817,14 @@ function preprocess$3(gltfData, options) {
 
 var EXT_texture_webp = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$6,
+    name: name$7,
     preprocess: preprocess$3
 });
 
 // GLTF EXTENSION: KHR_texture_basisu
 const KHR_TEXTURE_BASISU = 'KHR_texture_basisu';
 /** Extension name */
-const name$5 = KHR_TEXTURE_BASISU;
+const name$6 = KHR_TEXTURE_BASISU;
 /**
  * Replaces a texture source reference with the extension texture
  * Done in preprocess() to prevent load of default image
@@ -119837,7 +119846,7 @@ function preprocess$2(gltfData, options) {
 
 var KHR_texture_basisu = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$5,
+    name: name$6,
     preprocess: preprocess$2
 });
 
@@ -120563,7 +120572,7 @@ function toTypedArray(array, ArrayType, convertTypedArrays = false) {
 // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
 const KHR_DRACO_MESH_COMPRESSION = 'KHR_draco_mesh_compression';
 /** Extension name */
-const name$4 = KHR_DRACO_MESH_COMPRESSION;
+const name$5 = KHR_DRACO_MESH_COMPRESSION;
 function preprocess$1(gltfData, options, context) {
     const scenegraph = new GLTFScenegraph(gltfData);
     for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
@@ -120686,7 +120695,7 @@ function* makeMeshPrimitiveIterator(scenegraph) {
 
 var KHR_draco_mesh_compression = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$4,
+    name: name$5,
     preprocess: preprocess$1,
     decode: decode$4,
     encode: encode$3
@@ -122173,7 +122182,7 @@ function getIdentityMatrix() {
  */
 /** Extension name */
 const KHR_TEXTURE_TRANSFORM = 'KHR_texture_transform';
-const name$3 = KHR_TEXTURE_TRANSFORM;
+const name$4 = KHR_TEXTURE_TRANSFORM;
 const scratchVector = new Vector3();
 const scratchRotationMatrix = new Matrix3();
 const scratchScaleMatrix = new Matrix3();
@@ -122382,13 +122391,13 @@ function makeTransformationMatrix(extensionData) {
 
 var KHR_texture_transform = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$3,
+    name: name$4,
     decode: decode$3
 });
 
 // GLTF EXTENSION: KHR_lights_punctual
 const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
-const name$2 = KHR_LIGHTS_PUNCTUAL;
+const name$3 = KHR_LIGHTS_PUNCTUAL;
 async function decode$2(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
@@ -122440,14 +122449,14 @@ async function encode$2(gltfData) {
 
 var KHR_lights_punctual = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$2,
+    name: name$3,
     decode: decode$2,
     encode: encode$2
 });
 
 // GLTF EXTENSION: KHR_materials_unlit
 const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
-const name$1 = KHR_MATERIALS_UNLIT;
+const name$2 = KHR_MATERIALS_UNLIT;
 async function decode$1(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
@@ -122485,14 +122494,14 @@ function encode$1(gltfData) {
 
 var KHR_materials_unlit = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name$1,
+    name: name$2,
     decode: decode$1,
     encode: encode$1
 });
 
 // GLTF EXTENSION: KHR_techniques_webgl
 const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
-const name = KHR_TECHNIQUES_WEBGL;
+const name$1 = KHR_TECHNIQUES_WEBGL;
 async function decode(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
@@ -122565,7 +122574,7 @@ function resolveValues(technique, gltfScenegraph) {
 
 var KHR_techniques_webgl = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    name: name,
+    name: name$1,
     decode: decode,
     encode: encode
 });
@@ -143234,6 +143243,4079 @@ class WebIFCLoaderPlugin extends Plugin {
     }
 }
 
+const name = "@creooxag/cxconverter";
+const version = "0.0.3-alpha";
+const description = "";
+const exports$1 = {
+	".": {
+		types: "./dist/index.d.ts",
+		"import": "./dist/index.mjs",
+		require: "./dist/index.cjs"
+	}
+};
+const main = "./dist/index.mjs";
+const module$1 = "./dist/index.mjs";
+const types = "./dist/index.d.ts";
+const typesVersions = {
+	"*": {
+		"*": [
+			"./dist/*",
+			"./dist/index.d.ts"
+		]
+	}
+};
+const files = [
+	"dist/"
+];
+const scripts = {
+	"clean-dist": "rm -rf ./dist",
+	"clean-cmake": "rm -rf ./cmake-build",
+	"build-wasm-release": "emcmake cmake -S . -B ../cmake-build -DCMAKE_BUILD_TYPE=Release && cmake --build ../cmake-build",
+	"publish-npm": "npm publish --access public",
+	build: "unbuild",
+	dev: "unbuild --stub",
+	lint: "eslint .",
+	start: "esno examples/node/nodeExport.ts",
+	"example-html": "http-server -c-1 -p8237 --cors"
+};
+const keywords = [
+];
+const devDependencies = {
+	"@types/node": "^22.10.2",
+	esno: "^4.8.0",
+	"fast-glob": "^3.3.2",
+	globals: "^15.8.0",
+	"http-server": "^14.1.1",
+	prettier: "^3.3.3",
+	"prettier-eslint": "^16.3.0",
+	typescript: "^5.7.2",
+	unbuild: "^2.0.0",
+	"@eslint/eslintrc": "^3.2.0",
+	"@eslint/js": "^9.20.0",
+	"@typescript-eslint/eslint-plugin": "^8.24.0",
+	"@typescript-eslint/parser": "^8.24.0",
+	eslint: "^9.20.1",
+	"eslint-config-prettier": "^10.0.1",
+	"eslint-plugin-import": "^2.31.0",
+	"eslint-plugin-prettier": "^5.2.3"
+};
+const packageJSON = {
+	name: name,
+	version: version,
+	description: description,
+	exports: exports$1,
+	main: main,
+	module: module$1,
+	types: types,
+	typesVersions: typesVersions,
+	files: files,
+	scripts: scripts,
+	keywords: keywords,
+	devDependencies: devDependencies
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var IfcDbWasm = /* @__PURE__ */ (() => {
+  return async function(moduleArg = {}) {
+    var moduleRtn;
+    var Module = moduleArg;
+    var readyPromiseResolve, readyPromiseReject;
+    var readyPromise = new Promise((resolve, reject) => {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    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;
+    {
+      try {
+        scriptDirectory = new URL(".", _scriptName).href;
+      } catch {
+      }
+      {
+        readAsync = async (url) => {
+          var response = await fetch(url, { credentials: "same-origin" });
+          if (response.ok) {
+            return response.arrayBuffer();
+          }
+          throw new Error(response.status + " : " + response.url);
+        };
+      }
+    }
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    var wasmBinary;
+    var wasmMemory;
+    var ABORT = false;
+    var EXITSTATUS;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      HEAP32 = new Int32Array(b);
+      HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b);
+    }
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function")
+          Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(onPreRuns);
+    }
+    function initRuntime() {
+      if (!Module["noFSInit"] && !FS.initialized)
+        FS.init();
+      wasmExports["V"]();
+      FS.ignorePermissions = false;
+    }
+    function postRun() {
+      if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function")
+          Module["postRun"] = [Module["postRun"]];
+        while (Module["postRun"].length) {
+          addOnPostRun(Module["postRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(onPostRuns);
+    }
+    var runDependencies = 0;
+    var dependenciesFulfilled = null;
+    function addRunDependency(id) {
+      runDependencies++;
+      Module["monitorRunDependencies"]?.(runDependencies);
+    }
+    function removeRunDependency(id) {
+      runDependencies--;
+      Module["monitorRunDependencies"]?.(runDependencies);
+      if (runDependencies == 0) {
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      Module["onAbort"]?.(what);
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var wasmBinaryFile;
+    function findWasmBinary() {
+      if (Module["locateFile"]) {
+        return locateFile("ifcdb.wasm");
+      }
+      return new URL("ifcdb.wasm", import.meta.url).href;
+    }
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      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}`);
+        abort(reason);
+      }
+    }
+    async function instantiateAsync(binary, binaryFile, imports) {
+      if (!binary && typeof WebAssembly.instantiateStreaming == "function") {
+        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() {
+      return { a: wasmImports };
+    }
+    async function createWasm() {
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmExports = Asyncify.instrumentWasmExports(wasmExports);
+        wasmMemory = wasmExports["U"];
+        updateMemoryViews();
+        removeRunDependency();
+        return wasmExports;
+      }
+      addRunDependency();
+      function receiveInstantiationResult(result2) {
+        return receiveInstance(result2["instance"]);
+      }
+      var info = getWasmImports();
+      if (Module["instantiateWasm"]) {
+        return new Promise((resolve, reject) => {
+          Module["instantiateWasm"](info, (mod, inst) => {
+            resolve(receiveInstance(mod));
+          });
+        });
+      }
+      wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary());
+      try {
+        var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+        var exports = receiveInstantiationResult(result);
+        return exports;
+      } catch (e) {
+        readyPromiseReject(e);
+        return Promise.reject(e);
+      }
+    }
+    class ExitStatus {
+      constructor(status) {
+        __publicField$2(this, "name", "ExitStatus");
+        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);
+    var dynCallLegacy = (sig, ptr, args) => {
+      sig = sig.replace(/p/g, "i");
+      var f = Module["dynCall_" + sig];
+      return f(ptr, ...args);
+    };
+    var dynCall = (sig, ptr, args = [], promising = false) => {
+      var rtn = dynCallLegacy(sig, ptr, args);
+      function convert(rtn2) {
+        return rtn2;
+      }
+      return convert(rtn);
+    };
+    var noExitRuntime = true;
+    class ExceptionInfo {
+      constructor(excPtr) {
+        this.excPtr = excPtr;
+        this.ptr = excPtr - 24;
+      }
+      set_type(type) {
+        HEAPU32[this.ptr + 4 >> 2] = type;
+      }
+      get_type() {
+        return HEAPU32[this.ptr + 4 >> 2];
+      }
+      set_destructor(destructor) {
+        HEAPU32[this.ptr + 8 >> 2] = destructor;
+      }
+      get_destructor() {
+        return HEAPU32[this.ptr + 8 >> 2];
+      }
+      set_caught(caught) {
+        caught = caught ? 1 : 0;
+        HEAP8[this.ptr + 12] = caught;
+      }
+      get_caught() {
+        return HEAP8[this.ptr + 12] != 0;
+      }
+      set_rethrown(rethrown) {
+        rethrown = rethrown ? 1 : 0;
+        HEAP8[this.ptr + 13] = rethrown;
+      }
+      get_rethrown() {
+        return HEAP8[this.ptr + 13] != 0;
+      }
+      init(type, destructor) {
+        this.set_adjusted_ptr(0);
+        this.set_type(type);
+        this.set_destructor(destructor);
+      }
+      set_adjusted_ptr(adjustedPtr) {
+        HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
+      }
+      get_adjusted_ptr() {
+        return HEAPU32[this.ptr + 16 >> 2];
+      }
+    }
+    var exceptionLast = 0;
+    var ___cxa_throw = (ptr, type, destructor) => {
+      var info = new ExceptionInfo(ptr);
+      info.init(type, destructor);
+      exceptionLast = ptr;
+      throw exceptionLast;
+    };
+    var syscallGetVarargI = () => {
+      var ret = HEAP32[+SYSCALLS.varargs >> 2];
+      SYSCALLS.varargs += 4;
+      return ret;
+    };
+    var syscallGetVarargP = syscallGetVarargI;
+    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 = () => (view) => crypto.getRandomValues(view);
+    var randomFill = (view) => {
+      (randomFill = initRandomFill())(view);
+    };
+    var PATH_FS = { resolve: (...args) => {
+      var resolvedPath = "", resolvedAbsolute = false;
+      for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        var path = i >= 0 ? args[i] : FS.cwd();
+        if (typeof path != "string") {
+          throw new TypeError("Arguments to path.resolve must be strings");
+        } else if (!path) {
+          return "";
+        }
+        resolvedPath = path + "/" + resolvedPath;
+        resolvedAbsolute = PATH.isAbs(path);
+      }
+      resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
+      return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+    }, relative: (from, to) => {
+      from = PATH_FS.resolve(from).slice(1);
+      to = PATH_FS.resolve(to).slice(1);
+      function trim(arr) {
+        var start = 0;
+        for (; start < arr.length; start++) {
+          if (arr[start] !== "")
+            break;
+        }
+        var end = arr.length - 1;
+        for (; end >= 0; end--) {
+          if (arr[end] !== "")
+            break;
+        }
+        if (start > end)
+          return [];
+        return arr.slice(start, end - start + 1);
+      }
+      var fromParts = trim(from.split("/"));
+      var toParts = trim(to.split("/"));
+      var length = Math.min(fromParts.length, toParts.length);
+      var samePartsLength = length;
+      for (var i = 0; i < length; i++) {
+        if (fromParts[i] !== toParts[i]) {
+          samePartsLength = i;
+          break;
+        }
+      }
+      var outputParts = [];
+      for (var i = samePartsLength; i < fromParts.length; i++) {
+        outputParts.push("..");
+      }
+      outputParts = outputParts.concat(toParts.slice(samePartsLength));
+      return outputParts.join("/");
+    } };
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
+    var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+        ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode((u0 & 31) << 6 | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+        } else {
+          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+        }
+        if (u0 < 65536) {
+          str += String.fromCharCode(u0);
+        } else {
+          var ch = u0 - 65536;
+          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+        }
+      }
+      return str;
+    };
+    var FS_stdin_getChar_buffer = [];
+    var lengthBytesUTF8 = (str) => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var c = str.charCodeAt(i);
+        if (c <= 127) {
+          len++;
+        } else if (c <= 2047) {
+          len += 2;
+        } else if (c >= 55296 && c <= 57343) {
+          len += 4;
+          ++i;
+        } else {
+          len += 3;
+        }
+      }
+      return len;
+    };
+    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+      if (!(maxBytesToWrite > 0))
+        return 0;
+      var startIdx = outIdx;
+      var endIdx = outIdx + maxBytesToWrite - 1;
+      for (var i = 0; i < str.length; ++i) {
+        var u = str.charCodeAt(i);
+        if (u >= 55296 && u <= 57343) {
+          var u1 = str.charCodeAt(++i);
+          u = 65536 + ((u & 1023) << 10) | u1 & 1023;
+        }
+        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;
+          heap[outIdx++] = 240 | u >> 18;
+          heap[outIdx++] = 128 | u >> 12 & 63;
+          heap[outIdx++] = 128 | u >> 6 & 63;
+          heap[outIdx++] = 128 | u & 63;
+        }
+      }
+      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 (typeof window != "undefined" && typeof window.prompt == "function") {
+          result = window.prompt("Input: ");
+          if (result !== null) {
+            result += "\n";
+          }
+        }
+        if (!result) {
+          return null;
+        }
+        FS_stdin_getChar_buffer = intArrayFromString(result, true);
+      }
+      return FS_stdin_getChar_buffer.shift();
+    };
+    var TTY = { ttys: [], init() {
+    }, shutdown() {
+    }, register(dev, ops) {
+      TTY.ttys[dev] = { input: [], output: [], ops };
+      FS.registerDevice(dev, TTY.stream_ops);
+    }, stream_ops: { open(stream) {
+      var tty = TTY.ttys[stream.node.rdev];
+      if (!tty) {
+        throw new FS.ErrnoError(43);
+      }
+      stream.tty = tty;
+      stream.seekable = false;
+    }, close(stream) {
+      stream.tty.ops.fsync(stream.tty);
+    }, fsync(stream) {
+      stream.tty.ops.fsync(stream.tty);
+    }, read(stream, buffer, offset, length, pos) {
+      if (!stream.tty || !stream.tty.ops.get_char) {
+        throw new FS.ErrnoError(60);
+      }
+      var bytesRead = 0;
+      for (var i = 0; i < length; i++) {
+        var result;
+        try {
+          result = stream.tty.ops.get_char(stream.tty);
+        } catch (e) {
+          throw new FS.ErrnoError(29);
+        }
+        if (result === void 0 && bytesRead === 0) {
+          throw new FS.ErrnoError(6);
+        }
+        if (result === null || result === void 0)
+          break;
+        bytesRead++;
+        buffer[offset + i] = result;
+      }
+      if (bytesRead) {
+        stream.node.atime = Date.now();
+      }
+      return bytesRead;
+    }, write(stream, buffer, offset, length, pos) {
+      if (!stream.tty || !stream.tty.ops.put_char) {
+        throw new FS.ErrnoError(60);
+      }
+      try {
+        for (var i = 0; i < length; i++) {
+          stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+        }
+      } catch (e) {
+        throw new FS.ErrnoError(29);
+      }
+      if (length) {
+        stream.node.mtime = stream.node.ctime = Date.now();
+      }
+      return i;
+    } }, default_tty_ops: { get_char(tty) {
+      return FS_stdin_getChar();
+    }, put_char(tty, val) {
+      if (val === null || val === 10) {
+        out(UTF8ArrayToString(tty.output));
+        tty.output = [];
+      } else {
+        if (val != 0)
+          tty.output.push(val);
+      }
+    }, fsync(tty) {
+      if (tty.output?.length > 0) {
+        out(UTF8ArrayToString(tty.output));
+        tty.output = [];
+      }
+    }, ioctl_tcgets(tty) {
+      return { c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+    }, ioctl_tcsets(tty, optional_actions, data) {
+      return 0;
+    }, ioctl_tiocgwinsz(tty) {
+      return [24, 80];
+    } }, default_tty1_ops: { put_char(tty, val) {
+      if (val === null || val === 10) {
+        err(UTF8ArrayToString(tty.output));
+        tty.output = [];
+      } else {
+        if (val != 0)
+          tty.output.push(val);
+      }
+    }, fsync(tty) {
+      if (tty.output?.length > 0) {
+        err(UTF8ArrayToString(tty.output));
+        tty.output = [];
+      }
+    } } };
+    var mmapAlloc = (size) => {
+      abort();
+    };
+    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 || (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 MEMFS.doesNotExistError;
+    }, mknod(parent, name, mode, dev) {
+      return MEMFS.createNode(parent, name, mode, dev);
+    }, rename(old_node, new_dir, new_name) {
+      var new_node;
+      try {
+        new_node = FS.lookupNode(new_dir, new_name);
+      } catch (e) {
+      }
+      if (new_node) {
+        if (FS.isDir(old_node.mode)) {
+          for (var i in new_node.contents) {
+            throw new FS.ErrnoError(55);
+          }
+        }
+        FS.hashRemoveNode(new_node);
+      }
+      delete old_node.parent.contents[old_node.name];
+      new_dir.contents[new_name] = old_node;
+      old_node.name = new_name;
+      new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
+    }, unlink(parent, name) {
+      delete parent.contents[name];
+      parent.ctime = parent.mtime = Date.now();
+    }, rmdir(parent, name) {
+      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);
+      if (size > 8 && contents.subarray) {
+        buffer.set(contents.subarray(position, position + size), offset);
+      } else {
+        for (var i = 0; i < size; i++)
+          buffer[offset + i] = contents[position + i];
+      }
+      return size;
+    }, write(stream, buffer, offset, length, position, canOwn) {
+      if (buffer.buffer === HEAP8.buffer) {
+        canOwn = false;
+      }
+      if (!length)
+        return 0;
+      var node = stream.node;
+      node.mtime = node.ctime = Date.now();
+      if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+        if (canOwn) {
+          node.contents = buffer.subarray(offset, offset + length);
+          node.usedBytes = length;
+          return length;
+        } else if (node.usedBytes === 0 && position === 0) {
+          node.contents = buffer.slice(offset, offset + length);
+          node.usedBytes = length;
+          return length;
+        } else if (position + length <= node.usedBytes) {
+          node.contents.set(buffer.subarray(offset, offset + length), position);
+          return length;
+        }
+      }
+      MEMFS.expandFileStorage(node, position + length);
+      if (node.contents.subarray && buffer.subarray) {
+        node.contents.set(buffer.subarray(offset, offset + length), position);
+      } else {
+        for (var i = 0; i < length; i++) {
+          node.contents[position + i] = buffer[offset + i];
+        }
+      }
+      node.usedBytes = Math.max(node.usedBytes, position + length);
+      return length;
+    }, llseek(stream, offset, whence) {
+      var position = offset;
+      if (whence === 1) {
+        position += stream.position;
+      } else if (whence === 2) {
+        if (FS.isFile(stream.node.mode)) {
+          position += stream.node.usedBytes;
+        }
+      }
+      if (position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      return position;
+    }, mmap(stream, length, position, prot, flags) {
+      if (!FS.isFile(stream.node.mode)) {
+        throw new FS.ErrnoError(43);
+      }
+      var ptr;
+      var allocated;
+      var contents = stream.node.contents;
+      if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
+        allocated = false;
+        ptr = contents.byteOffset;
+      } else {
+        allocated = true;
+        ptr = mmapAlloc();
+        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 asyncLoad = async (url) => {
+      var arrayBuffer = await readAsync(url);
+      return new Uint8Array(arrayBuffer);
+    };
+    asyncLoad.isAsync = true;
+    var FS_createDataFile = (...args) => FS.createDataFile(...args);
+    var preloadPlugins = [];
+    var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+      if (typeof Browser != "undefined")
+        Browser.init();
+      var handled = false;
+      preloadPlugins.forEach((plugin) => {
+        if (handled)
+          return;
+        if (plugin["canHandle"](fullname)) {
+          plugin["handle"](byteArray, fullname, finish, onerror);
+          handled = true;
+        }
+      });
+      return handled;
+    };
+    var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+      var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+      function processData(byteArray) {
+        function finish(byteArray2) {
+          preFinish?.();
+          if (!dontCreateFile) {
+            FS_createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
+          }
+          onload?.();
+          removeRunDependency();
+        }
+        if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+          onerror?.();
+          removeRunDependency();
+        })) {
+          return;
+        }
+        finish(byteArray);
+      }
+      addRunDependency();
+      if (typeof url == "string") {
+        asyncLoad(url).then(processData, onerror);
+      } else {
+        processData(url);
+      }
+    };
+    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 FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, readFiles: {}, ErrnoError: class {
+      constructor(errno) {
+        __publicField$2(this, "name", "ErrnoError");
+        this.errno = errno;
+      }
+    }, FSStream: class {
+      constructor() {
+        __publicField$2(this, "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 {
+      constructor(parent, name, mode, rdev) {
+        __publicField$2(this, "node_ops", {});
+        __publicField$2(this, "stream_ops", {});
+        __publicField$2(this, "readMode", 292 | 73);
+        __publicField$2(this, "writeMode", 146);
+        __publicField$2(this, "mounted", null);
+        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 ?? (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("/");
+                continue linkloop;
+              } else {
+                current = current.parent;
+              }
+              continue;
+            }
+            current_path = PATH.join2(current_path, parts[i]);
+            try {
+              current = FS.lookupNode(current, parts[i]);
+            } catch (e) {
+              if (e?.errno === 44 && islast && opts.noent_okay) {
+                return { path: current_path };
+              }
+              throw e;
+            }
+            if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
+              current = current.mounted.root;
+            }
+            if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+              if (!current.node_ops.readlink) {
+                throw new FS.ErrnoError(52);
+              }
+              var link = current.node_ops.readlink(current);
+              if (!PATH.isAbs(link)) {
+                link = PATH.dirname(current_path) + "/" + link;
+              }
+              path = link + "/" + parts.slice(i + 1).join("/");
+              continue linkloop;
+            }
+          }
+          return { path: current_path, node: current };
+        }
+      throw new FS.ErrnoError(32);
+    }, getPath(node) {
+      var path;
+      while (true) {
+        if (FS.isRoot(node)) {
+          var mount = node.mount.mountpoint;
+          if (!path)
+            return mount;
+          return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+        }
+        path = path ? `${node.name}/${path}` : node.name;
+        node = node.parent;
+      }
+    }, hashName(parentid, name) {
+      var hash = 0;
+      for (var i = 0; i < name.length; i++) {
+        hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+      }
+      return (parentid + hash >>> 0) % FS.nameTable.length;
+    }, hashAddNode(node) {
+      var hash = FS.hashName(node.parent.id, node.name);
+      node.name_next = FS.nameTable[hash];
+      FS.nameTable[hash] = node;
+    }, hashRemoveNode(node) {
+      var hash = FS.hashName(node.parent.id, node.name);
+      if (FS.nameTable[hash] === node) {
+        FS.nameTable[hash] = node.name_next;
+      } else {
+        var current = FS.nameTable[hash];
+        while (current) {
+          if (current.name_next === node) {
+            current.name_next = node.name_next;
+            break;
+          }
+          current = current.name_next;
+        }
+      }
+    }, lookupNode(parent, name) {
+      var errCode = FS.mayLookup(parent);
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      var hash = FS.hashName(parent.id, name);
+      for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+        var nodeName = node.name;
+        if (node.parent.id === parent.id && nodeName === name) {
+          return node;
+        }
+      }
+      return FS.lookup(parent, name);
+    }, createNode(parent, name, mode, rdev) {
+      var node = new FS.FSNode(parent, name, mode, rdev);
+      FS.hashAddNode(node);
+      return node;
+    }, destroyNode(node) {
+      FS.hashRemoveNode(node);
+    }, isRoot(node) {
+      return node === node.parent;
+    }, isMountpoint(node) {
+      return !!node.mounted;
+    }, isFile(mode) {
+      return (mode & 61440) === 32768;
+    }, isDir(mode) {
+      return (mode & 61440) === 16384;
+    }, isLink(mode) {
+      return (mode & 61440) === 40960;
+    }, isChrdev(mode) {
+      return (mode & 61440) === 8192;
+    }, isBlkdev(mode) {
+      return (mode & 61440) === 24576;
+    }, isFIFO(mode) {
+      return (mode & 61440) === 4096;
+    }, isSocket(mode) {
+      return (mode & 49152) === 49152;
+    }, flagsToPermissionString(flag) {
+      var perms = ["r", "w", "rw"][flag & 3];
+      if (flag & 512) {
+        perms += "w";
+      }
+      return perms;
+    }, nodePermissions(node, perms) {
+      if (FS.ignorePermissions) {
+        return 0;
+      }
+      if (perms.includes("r") && !(node.mode & 292)) {
+        return 2;
+      } else if (perms.includes("w") && !(node.mode & 146)) {
+        return 2;
+      } else 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;
+      } else if (FS.isDir(node.mode)) {
+        if (FS.flagsToPermissionString(flags) !== "r" || flags & (512 | 64)) {
+          return 31;
+        }
+      }
+      return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+    }, 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) {
+      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 ?? (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) {
+        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);
+        }
+      }
+      mounts.forEach((mount) => {
+        if (!mount.type.syncfs) {
+          return done(null);
+        }
+        mount.type.syncfs(mount, populate, done);
+      });
+    }, mount(type, opts, mountpoint) {
+      var root = mountpoint === "/";
+      var pseudo = !mountpoint;
+      var node;
+      if (root && FS.root) {
+        throw new FS.ErrnoError(10);
+      } else if (!root && !pseudo) {
+        var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+        mountpoint = lookup.path;
+        node = lookup.node;
+        if (FS.isMountpoint(node)) {
+          throw new FS.ErrnoError(10);
+        }
+        if (!FS.isDir(node.mode)) {
+          throw new FS.ErrnoError(54);
+        }
+      }
+      var mount = { type, opts, mountpoint, mounts: [] };
+      var mountRoot = type.mount(mount);
+      mountRoot.mount = mount;
+      mount.root = mountRoot;
+      if (root) {
+        FS.root = mountRoot;
+      } else if (node) {
+        node.mounted = mount;
+        if (node.mount) {
+          node.mount.mounts.push(mount);
+        }
+      }
+      return mountRoot;
+    }, unmount(mountpoint) {
+      var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+      if (!FS.isMountpoint(lookup.node)) {
+        throw new FS.ErrnoError(28);
+      }
+      var node = lookup.node;
+      var mount = node.mounted;
+      var mounts = FS.getMounts(mount);
+      Object.keys(FS.nameTable).forEach((hash) => {
+        var current = FS.nameTable[hash];
+        while (current) {
+          var next = current.name_next;
+          if (mounts.includes(current.mount)) {
+            FS.destroyNode(current);
+          }
+          current = next;
+        }
+      });
+      node.mounted = null;
+      var idx = node.mount.mounts.indexOf(mount);
+      node.mount.mounts.splice(idx, 1);
+    }, lookup(parent, name) {
+      return parent.node_ops.lookup(parent, name);
+    }, mknod(path, mode, dev) {
+      var 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 ?? (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 });
+    }, 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), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false });
+      if (stream.stream_ops.open) {
+        stream.stream_ops.open(stream);
+      }
+      if (created) {
+        FS.chmod(node, mode & 511);
+      }
+      if (Module["logReadFiles"] && !(flags & 1)) {
+        if (!(path in FS.readFiles)) {
+          FS.readFiles[path] = 1;
+        }
+      }
+      return stream;
+    }, close(stream) {
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if (stream.getdents)
+        stream.getdents = null;
+      try {
+        if (stream.stream_ops.close) {
+          stream.stream_ops.close(stream);
+        }
+      } catch (e) {
+        throw e;
+      } finally {
+        FS.closeStream(stream.fd);
+      }
+      stream.fd = null;
+    }, isClosed(stream) {
+      return stream.fd === null;
+    }, llseek(stream, offset, whence) {
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if (!stream.seekable || !stream.stream_ops.llseek) {
+        throw new FS.ErrnoError(70);
+      }
+      if (whence != 0 && whence != 1 && whence != 2) {
+        throw new FS.ErrnoError(28);
+      }
+      stream.position = stream.stream_ops.llseek(stream, offset, whence);
+      stream.ungotten = [];
+      return stream.position;
+    }, read(stream, buffer, offset, length, position) {
+      if (length < 0 || position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if ((stream.flags & 2097155) === 1) {
+        throw new FS.ErrnoError(8);
+      }
+      if (FS.isDir(stream.node.mode)) {
+        throw new FS.ErrnoError(31);
+      }
+      if (!stream.stream_ops.read) {
+        throw new FS.ErrnoError(28);
+      }
+      var seeking = typeof position != "undefined";
+      if (!seeking) {
+        position = stream.position;
+      } else if (!stream.seekable) {
+        throw new FS.ErrnoError(70);
+      }
+      var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+      if (!seeking)
+        stream.position += bytesRead;
+      return bytesRead;
+    }, write(stream, buffer, offset, length, position, canOwn) {
+      if (length < 0 || position < 0) {
+        throw new FS.ErrnoError(28);
+      }
+      if (FS.isClosed(stream)) {
+        throw new FS.ErrnoError(8);
+      }
+      if ((stream.flags & 2097155) === 0) {
+        throw new FS.ErrnoError(8);
+      }
+      if (FS.isDir(stream.node.mode)) {
+        throw new FS.ErrnoError(31);
+      }
+      if (!stream.stream_ops.write) {
+        throw new FS.ErrnoError(28);
+      }
+      if (stream.seekable && stream.flags & 1024) {
+        FS.llseek(stream, 0, 2);
+      }
+      var seeking = typeof position != "undefined";
+      if (!seeking) {
+        position = stream.position;
+      } else if (!stream.seekable) {
+        throw new FS.ErrnoError(70);
+      }
+      var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+      if (!seeking)
+        stream.position += bytesWritten;
+      return bytesWritten;
+    }, mmap(stream, length, position, prot, flags) {
+      if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
+        throw new FS.ErrnoError(2);
+      }
+      if ((stream.flags & 2097155) === 1) {
+        throw new FS.ErrnoError(2);
+      }
+      if (!stream.stream_ops.mmap) {
+        throw new FS.ErrnoError(43);
+      }
+      if (!length) {
+        throw new FS.ErrnoError(28);
+      }
+      return stream.stream_ops.mmap(stream, length, position, prot, flags);
+    }, msync(stream, buffer, offset, length, mmapFlags) {
+      if (!stream.stream_ops.msync) {
+        return 0;
+      }
+      return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
+    }, ioctl(stream, cmd, arg) {
+      if (!stream.stream_ops.ioctl) {
+        throw new FS.ErrnoError(59);
+      }
+      return stream.stream_ops.ioctl(stream, cmd, arg);
+    }, readFile(path, opts = {}) {
+      opts.flags = opts.flags || 0;
+      opts.encoding = opts.encoding || "binary";
+      if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
+        throw new Error(`Invalid encoding type "${opts.encoding}"`);
+      }
+      var ret;
+      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") {
+        ret = UTF8ArrayToString(buf);
+      } else if (opts.encoding === "binary") {
+        ret = buf;
+      }
+      FS.close(stream);
+      return ret;
+    }, writeFile(path, data, opts = {}) {
+      opts.flags = opts.flags || 577;
+      var stream = FS.open(path, opts.flags, opts.mode);
+      if (typeof data == "string") {
+        var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+        var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+        FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
+      } else if (ArrayBuffer.isView(data)) {
+        FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
+      } else {
+        throw new Error("Unsupported data type");
+      }
+      FS.close(stream);
+    }, cwd: () => FS.currentPath, chdir(path) {
+      var lookup = FS.lookupPath(path, { follow: true });
+      if (lookup.node === null) {
+        throw new FS.ErrnoError(44);
+      }
+      if (!FS.isDir(lookup.node.mode)) {
+        throw new FS.ErrnoError(54);
+      }
+      var errCode = FS.nodePermissions(lookup.node, "x");
+      if (errCode) {
+        throw new FS.ErrnoError(errCode);
+      }
+      FS.currentPath = lookup.path;
+    }, createDefaultDirectories() {
+      FS.mkdir("/tmp");
+      FS.mkdir("/home");
+      FS.mkdir("/home/web_user");
+    }, createDefaultDevices() {
+      FS.mkdir("/dev");
+      FS.registerDevice(FS.makedev(1, 3), { read: () => 0, write: (stream, buffer, offset, length, pos) => length, llseek: () => 0 });
+      FS.mkdev("/dev/null", FS.makedev(1, 3));
+      TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+      TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+      FS.mkdev("/dev/tty", FS.makedev(5, 0));
+      FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+      var randomBuffer = new Uint8Array(1024), randomLeft = 0;
+      var randomByte = () => {
+        if (randomLeft === 0) {
+          randomFill(randomBuffer);
+          randomLeft = randomBuffer.byteLength;
+        }
+        return randomBuffer[--randomLeft];
+      };
+      FS.createDevice("/dev", "random", randomByte);
+      FS.createDevice("/dev", "urandom", randomByte);
+      FS.mkdir("/dev/shm");
+      FS.mkdir("/dev/shm/tmp");
+    }, createSpecialDirectories() {
+      FS.mkdir("/proc");
+      var proc_self = FS.mkdir("/proc/self");
+      FS.mkdir("/proc/self/fd");
+      FS.mount({ mount() {
+        var node = FS.createNode(proc_self, "fd", 16895, 73);
+        node.stream_ops = { llseek: MEMFS.stream_ops.llseek };
+        node.node_ops = { lookup(parent, name) {
+          var fd = +name;
+          var stream = FS.getStreamChecked(fd);
+          var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path }, id: fd + 1 };
+          ret.parent = ret;
+          return ret;
+        }, readdir() {
+          return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString());
+        } };
+        return node;
+      } }, {}, "/proc/self/fd");
+    }, createStandardStreams(input, output, error) {
+      if (input) {
+        FS.createDevice("/dev", "stdin", input);
+      } else {
+        FS.symlink("/dev/tty", "/dev/stdin");
+      }
+      if (output) {
+        FS.createDevice("/dev", "stdout", null, output);
+      } else {
+        FS.symlink("/dev/tty", "/dev/stdout");
+      }
+      if (error) {
+        FS.createDevice("/dev", "stderr", null, error);
+      } else {
+        FS.symlink("/dev/tty1", "/dev/stderr");
+      }
+      FS.open("/dev/stdin", 0);
+      FS.open("/dev/stdout", 1);
+      FS.open("/dev/stderr", 1);
+    }, staticInit() {
+      FS.nameTable = new Array(4096);
+      FS.mount(MEMFS, {}, "/");
+      FS.createDefaultDirectories();
+      FS.createDefaultDevices();
+      FS.createSpecialDirectories();
+      FS.filesystems = { MEMFS };
+    }, init(input, output, error) {
+      FS.initialized = true;
+      input ?? (input = Module["stdin"]);
+      output ?? (output = Module["stdout"]);
+      error ?? (error = Module["stderr"]);
+      FS.createStandardStreams(input, output, error);
+    }, quit() {
+      FS.initialized = false;
+      for (var stream of FS.streams) {
+        if (stream) {
+          FS.close(stream);
+        }
+      }
+    }, findObject(path, dontResolveLastLink) {
+      var ret = FS.analyzePath(path, dontResolveLastLink);
+      if (!ret.exists) {
+        return null;
+      }
+      return ret.object;
+    }, analyzePath(path, dontResolveLastLink) {
+      try {
+        var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+        path = lookup.path;
+      } catch (e) {
+      }
+      var ret = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null };
+      try {
+        var lookup = FS.lookupPath(path, { parent: true });
+        ret.parentExists = true;
+        ret.parentPath = lookup.path;
+        ret.parentObject = lookup.node;
+        ret.name = PATH.basename(path);
+        lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+        ret.exists = true;
+        ret.path = lookup.path;
+        ret.object = lookup.node;
+        ret.name = lookup.node.name;
+        ret.isRoot = lookup.path === "/";
+      } catch (e) {
+        ret.error = e.errno;
+      }
+      return ret;
+    }, createPath(parent, path, canRead, canWrite) {
+      parent = typeof parent == "string" ? parent : FS.getPath(parent);
+      var parts = path.split("/").reverse();
+      while (parts.length) {
+        var part = parts.pop();
+        if (!part)
+          continue;
+        var current = PATH.join2(parent, part);
+        try {
+          FS.mkdir(current);
+        } catch (e) {
+          if (e.errno != 20)
+            throw e;
+        }
+        parent = current;
+      }
+      return current;
+    }, createFile(parent, name, properties, canRead, canWrite) {
+      var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+      var mode = FS_getMode(canRead, canWrite);
+      return FS.create(path, mode);
+    }, createDataFile(parent, name, data, canRead, canWrite, canOwn) {
+      var path = name;
+      if (parent) {
+        parent = typeof parent == "string" ? parent : FS.getPath(parent);
+        path = name ? PATH.join2(parent, name) : parent;
+      }
+      var mode = FS_getMode(canRead, canWrite);
+      var node = FS.create(path, mode);
+      if (data) {
+        if (typeof data == "string") {
+          var arr = new Array(data.length);
+          for (var i = 0, len = data.length; i < len; ++i)
+            arr[i] = data.charCodeAt(i);
+          data = arr;
+        }
+        FS.chmod(node, mode | 146);
+        var stream = FS.open(node, 577);
+        FS.write(stream, data, 0, data.length, 0, canOwn);
+        FS.close(stream);
+        FS.chmod(node, mode);
+      }
+    }, createDevice(parent, name, input, output) {
+      var _a;
+      var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+      var mode = FS_getMode(!!input, !!output);
+      (_a = FS.createDevice).major ?? (_a.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 (typeof XMLHttpRequest != "undefined") {
+        throw new Error("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);
+          obj.usedBytes = obj.contents.length;
+        } catch (e) {
+          throw new FS.ErrnoError(29);
+        }
+      }
+    }, createLazyFile(parent, name, url, canRead, canWrite) {
+      class LazyUint8Array {
+        constructor() {
+          __publicField$2(this, "lengthKnown", false);
+          __publicField$2(this, "chunks", []);
+        }
+        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))
+            throw new Error("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)
+              throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+            if (to > datalength - 1)
+              throw new Error("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))
+              throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
+            if (xhr2.response !== void 0) {
+              return new Uint8Array(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")
+              throw new Error("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 (typeof XMLHttpRequest != "undefined") {
+        throw "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 = {};
+      var keys = Object.keys(node.stream_ops);
+      keys.forEach((key) => {
+        var fn = node.stream_ops[key];
+        stream_ops[key] = (...args) => {
+          FS.forceLoadFile(node);
+          return fn(...args);
+        };
+      });
+      function writeChunks(stream, buffer, offset, length, position) {
+        var contents = stream.node.contents;
+        if (position >= contents.length)
+          return 0;
+        var size = Math.min(contents.length - position, length);
+        if (contents.slice) {
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents[position + i];
+          }
+        } else {
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents.get(position + i);
+          }
+        }
+        return size;
+      }
+      stream_ops.read = (stream, buffer, offset, length, position) => {
+        FS.forceLoadFile(node);
+        return writeChunks(stream, buffer, offset, length, position);
+      };
+      stream_ops.mmap = (stream, length, position, prot, flags) => {
+        FS.forceLoadFile(node);
+        var ptr = mmapAlloc();
+        if (!ptr) {
+          throw new FS.ErrnoError(48);
+        }
+        writeChunks(stream, HEAP8, ptr, length, position);
+        return { ptr, allocated: true };
+      };
+      node.stream_ops = stream_ops;
+      return node;
+    } };
+    var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+    var SYSCALLS = { DEFAULT_POLLMASK: 5, 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) {
+      HEAP32[buf >> 2] = stat.dev;
+      HEAP32[buf + 4 >> 2] = stat.mode;
+      HEAPU32[buf + 8 >> 2] = stat.nlink;
+      HEAP32[buf + 12 >> 2] = stat.uid;
+      HEAP32[buf + 16 >> 2] = stat.gid;
+      HEAP32[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) {
+      HEAP32[buf + 4 >> 2] = stats.bsize;
+      HEAP32[buf + 40 >> 2] = stats.bsize;
+      HEAP32[buf + 8 >> 2] = stats.blocks;
+      HEAP32[buf + 12 >> 2] = stats.bfree;
+      HEAP32[buf + 16 >> 2] = stats.bavail;
+      HEAP32[buf + 20 >> 2] = stats.files;
+      HEAP32[buf + 24 >> 2] = stats.ffree;
+      HEAP32[buf + 28 >> 2] = stats.fsid;
+      HEAP32[buf + 44 >> 2] = stats.flags;
+      HEAP32[buf + 36 >> 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_fcntl64(fd, cmd, varargs) {
+      SYSCALLS.varargs = varargs;
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        switch (cmd) {
+          case 0: {
+            var arg = syscallGetVarargI();
+            if (arg < 0) {
+              return -28;
+            }
+            while (FS.streams[arg]) {
+              arg++;
+            }
+            var newStream;
+            newStream = FS.dupStream(stream, arg);
+            return newStream.fd;
+          }
+          case 1:
+          case 2:
+            return 0;
+          case 3:
+            return stream.flags;
+          case 4: {
+            var arg = syscallGetVarargI();
+            stream.flags |= arg;
+            return 0;
+          }
+          case 12: {
+            var arg = syscallGetVarargP();
+            var offset = 0;
+            HEAP16[arg + offset >> 1] = 2;
+            return 0;
+          }
+          case 13:
+          case 14:
+            return 0;
+        }
+        return -28;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_ioctl(fd, op, varargs) {
+      SYSCALLS.varargs = varargs;
+      try {
+        var stream = SYSCALLS.getStreamFromFD(fd);
+        switch (op) {
+          case 21509: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21505: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tcgets) {
+              var termios = stream.tty.ops.ioctl_tcgets(stream);
+              var argp = syscallGetVarargP();
+              HEAP32[argp >> 2] = termios.c_iflag || 0;
+              HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
+              HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
+              HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
+              for (var i = 0; i < 32; i++) {
+                HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
+              }
+              return 0;
+            }
+            return 0;
+          }
+          case 21510:
+          case 21511:
+          case 21512: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21506:
+          case 21507:
+          case 21508: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tcsets) {
+              var argp = syscallGetVarargP();
+              var c_iflag = HEAP32[argp >> 2];
+              var c_oflag = HEAP32[argp + 4 >> 2];
+              var c_cflag = HEAP32[argp + 8 >> 2];
+              var c_lflag = HEAP32[argp + 12 >> 2];
+              var c_cc = [];
+              for (var i = 0; i < 32; i++) {
+                c_cc.push(HEAP8[argp + i + 17]);
+              }
+              return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
+            }
+            return 0;
+          }
+          case 21519: {
+            if (!stream.tty)
+              return -59;
+            var argp = syscallGetVarargP();
+            HEAP32[argp >> 2] = 0;
+            return 0;
+          }
+          case 21520: {
+            if (!stream.tty)
+              return -59;
+            return -28;
+          }
+          case 21531: {
+            var argp = syscallGetVarargP();
+            return FS.ioctl(stream, op, argp);
+          }
+          case 21523: {
+            if (!stream.tty)
+              return -59;
+            if (stream.tty.ops.ioctl_tiocgwinsz) {
+              var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+              var argp = syscallGetVarargP();
+              HEAP16[argp >> 1] = winsize[0];
+              HEAP16[argp + 2 >> 1] = winsize[1];
+            }
+            return 0;
+          }
+          case 21524: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          case 21515: {
+            if (!stream.tty)
+              return -59;
+            return 0;
+          }
+          default:
+            return -28;
+        }
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_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_renameat(olddirfd, oldpath, newdirfd, newpath) {
+      try {
+        oldpath = SYSCALLS.getStr(oldpath);
+        newpath = SYSCALLS.getStr(newpath);
+        oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
+        newpath = SYSCALLS.calculateAt(newdirfd, newpath);
+        FS.rename(oldpath, newpath);
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_rmdir(path) {
+      try {
+        path = SYSCALLS.getStr(path);
+        FS.rmdir(path);
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_stat64(path, buf) {
+      try {
+        path = SYSCALLS.getStr(path);
+        return SYSCALLS.writeStat(buf, FS.stat(path));
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    function ___syscall_unlinkat(dirfd, path, flags) {
+      try {
+        path = SYSCALLS.getStr(path);
+        path = SYSCALLS.calculateAt(dirfd, path);
+        if (!flags) {
+          FS.unlink(path);
+        } else if (flags === 512) {
+          FS.rmdir(path);
+        } else {
+          return -28;
+        }
+        return 0;
+      } catch (e) {
+        if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+          throw e;
+        return -e.errno;
+      }
+    }
+    var __abort_js = () => abort("");
+    var structRegistrations = {};
+    var runDestructors = (destructors) => {
+      while (destructors.length) {
+        var ptr = destructors.pop();
+        var del = destructors.pop();
+        del(ptr);
+      }
+    };
+    function readPointer(pointer) {
+      return this["fromWireType"](HEAPU32[pointer >> 2]);
+    }
+    var awaitingDependencies = {};
+    var registeredTypes = {};
+    var typeDependencies = {};
+    var InternalError = class InternalError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "InternalError";
+      }
+    };
+    var throwInternalError = (message) => {
+      throw new InternalError(message);
+    };
+    var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+      myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
+      function onComplete(typeConverters2) {
+        var myTypeConverters = getTypeConverters(typeConverters2);
+        if (myTypeConverters.length !== myTypes.length) {
+          throwInternalError("Mismatched type converter count");
+        }
+        for (var i = 0; i < myTypes.length; ++i) {
+          registerType(myTypes[i], myTypeConverters[i]);
+        }
+      }
+      var typeConverters = new Array(dependentTypes.length);
+      var unregisteredTypes = [];
+      var registered = 0;
+      dependentTypes.forEach((dt, i) => {
+        if (registeredTypes.hasOwnProperty(dt)) {
+          typeConverters[i] = registeredTypes[dt];
+        } else {
+          unregisteredTypes.push(dt);
+          if (!awaitingDependencies.hasOwnProperty(dt)) {
+            awaitingDependencies[dt] = [];
+          }
+          awaitingDependencies[dt].push(() => {
+            typeConverters[i] = registeredTypes[dt];
+            ++registered;
+            if (registered === unregisteredTypes.length) {
+              onComplete(typeConverters);
+            }
+          });
+        }
+      });
+      if (0 === unregisteredTypes.length) {
+        onComplete(typeConverters);
+      }
+    };
+    var __embind_finalize_value_object = (structType) => {
+      var reg = structRegistrations[structType];
+      delete structRegistrations[structType];
+      var rawConstructor = reg.rawConstructor;
+      var rawDestructor = reg.rawDestructor;
+      var fieldRecords = reg.fields;
+      var fieldTypes = fieldRecords.map((field) => field.getterReturnType).concat(fieldRecords.map((field) => field.setterArgumentType));
+      whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes2) => {
+        var fields = {};
+        fieldRecords.forEach((field, i) => {
+          var fieldName = field.fieldName;
+          var getterReturnType = fieldTypes2[i];
+          var optional = fieldTypes2[i].optional;
+          var getter = field.getter;
+          var getterContext = field.getterContext;
+          var setterArgumentType = fieldTypes2[i + fieldRecords.length];
+          var setter = field.setter;
+          var setterContext = field.setterContext;
+          fields[fieldName] = { read: (ptr) => getterReturnType["fromWireType"](getter(getterContext, ptr)), write: (ptr, o) => {
+            var destructors = [];
+            setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
+            runDestructors(destructors);
+          }, optional };
+        });
+        return [{ name: reg.name, fromWireType: (ptr) => {
+          var rv = {};
+          for (var i in fields) {
+            rv[i] = fields[i].read(ptr);
+          }
+          rawDestructor(ptr);
+          return rv;
+        }, toWireType: (destructors, o) => {
+          for (var fieldName in fields) {
+            if (!(fieldName in o) && !fields[fieldName].optional) {
+              throw new TypeError(`Missing field: "${fieldName}"`);
+            }
+          }
+          var ptr = rawConstructor();
+          for (fieldName in fields) {
+            fields[fieldName].write(ptr, o[fieldName]);
+          }
+          if (destructors !== null) {
+            destructors.push(rawDestructor, ptr);
+          }
+          return ptr;
+        }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction: rawDestructor }];
+      });
+    };
+    var embind_init_charCodes = () => {
+      var codes = new Array(256);
+      for (var i = 0; i < 256; ++i) {
+        codes[i] = String.fromCharCode(i);
+      }
+      embind_charCodes = codes;
+    };
+    var embind_charCodes;
+    var readLatin1String = (ptr) => {
+      var ret = "";
+      var c = ptr;
+      while (HEAPU8[c]) {
+        ret += embind_charCodes[HEAPU8[c++]];
+      }
+      return ret;
+    };
+    var BindingError = class BindingError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "BindingError";
+      }
+    };
+    var throwBindingError = (message) => {
+      throw new BindingError(message);
+    };
+    function sharedRegisterType(rawType, registeredInstance, options = {}) {
+      var name = registeredInstance.name;
+      if (!rawType) {
+        throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+      }
+      if (registeredTypes.hasOwnProperty(rawType)) {
+        if (options.ignoreDuplicateRegistrations) {
+          return;
+        } else {
+          throwBindingError(`Cannot register type '${name}' twice`);
+        }
+      }
+      registeredTypes[rawType] = registeredInstance;
+      delete typeDependencies[rawType];
+      if (awaitingDependencies.hasOwnProperty(rawType)) {
+        var callbacks = awaitingDependencies[rawType];
+        delete awaitingDependencies[rawType];
+        callbacks.forEach((cb) => cb());
+      }
+    }
+    function registerType(rawType, registeredInstance, options = {}) {
+      return sharedRegisterType(rawType, registeredInstance, options);
+    }
+    var integerReadValueFromPointer = (name, width, signed) => {
+      switch (width) {
+        case 1:
+          return signed ? (pointer) => HEAP8[pointer] : (pointer) => HEAPU8[pointer];
+        case 2:
+          return signed ? (pointer) => HEAP16[pointer >> 1] : (pointer) => HEAPU16[pointer >> 1];
+        case 4:
+          return signed ? (pointer) => HEAP32[pointer >> 2] : (pointer) => HEAPU32[pointer >> 2];
+        case 8:
+          return signed ? (pointer) => HEAP64[pointer >> 3] : (pointer) => HEAPU64[pointer >> 3];
+        default:
+          throw new TypeError(`invalid integer width (${width}): ${name}`);
+      }
+    };
+    var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
+      name = readLatin1String(name);
+      const isUnsignedType = minRange === 0n;
+      let fromWireType = (value) => value;
+      if (isUnsignedType) {
+        const bitSize = size * 8;
+        fromWireType = (value) => BigInt.asUintN(bitSize, value);
+        maxRange = fromWireType(maxRange);
+      }
+      registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => {
+        if (typeof value == "number") {
+          value = BigInt(value);
+        }
+        return value;
+      }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null });
+    };
+    var GenericWireTypeSize = 8;
+    var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, fromWireType: function(wt) {
+        return !!wt;
+      }, toWireType: function(destructors, o) {
+        return o ? trueValue : falseValue;
+      }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: function(pointer) {
+        return this["fromWireType"](HEAPU8[pointer]);
+      }, destructorFunction: null });
+    };
+    var emval_freelist = [];
+    var emval_handles = [0, 1, , 1, null, 1, true, 1, false, 1];
+    var __emval_decref = (handle) => {
+      if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+        emval_handles[handle] = void 0;
+        emval_freelist.push(handle);
+      }
+    };
+    var Emval = { toValue: (handle) => {
+      if (!handle) {
+        throwBindingError(`Cannot use deleted val. handle = ${handle}`);
+      }
+      return emval_handles[handle];
+    }, toHandle: (value) => {
+      switch (value) {
+        case void 0:
+          return 2;
+        case null:
+          return 4;
+        case true:
+          return 6;
+        case false:
+          return 8;
+        default: {
+          const handle = emval_freelist.pop() || emval_handles.length;
+          emval_handles[handle] = value;
+          emval_handles[handle + 1] = 1;
+          return handle;
+        }
+      }
+    } };
+    var EmValType = { name: "emscripten::val", fromWireType: (handle) => {
+      var rv = Emval.toValue(handle);
+      __emval_decref(handle);
+      return rv;
+    }, toWireType: (destructors, value) => Emval.toHandle(value), argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction: null };
+    var __embind_register_emval = (rawType) => registerType(rawType, EmValType);
+    var floatReadValueFromPointer = (name, width) => {
+      switch (width) {
+        case 4:
+          return function(pointer) {
+            return this["fromWireType"](HEAPF32[pointer >> 2]);
+          };
+        case 8:
+          return function(pointer) {
+            return this["fromWireType"](HEAPF64[pointer >> 3]);
+          };
+        default:
+          throw new TypeError(`invalid float width (${width}): ${name}`);
+      }
+    };
+    var __embind_register_float = (rawType, name, size) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, fromWireType: (value) => value, toWireType: (destructors, value) => value, argPackAdvance: GenericWireTypeSize, readValueFromPointer: floatReadValueFromPointer(name, size), destructorFunction: null });
+    };
+    var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
+    function usesDestructorStack(argTypes) {
+      for (var i = 1; i < argTypes.length; ++i) {
+        if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+      var needsDestructorStack = usesDestructorStack(argTypes);
+      var argCount = argTypes.length - 2;
+      var argsList = [];
+      var argsListWired = ["fn"];
+      if (isClassMethodFunc) {
+        argsListWired.push("thisWired");
+      }
+      for (var i = 0; i < argCount; ++i) {
+        argsList.push(`arg${i}`);
+        argsListWired.push(`arg${i}Wired`);
+      }
+      argsList = argsList.join(",");
+      argsListWired = argsListWired.join(",");
+      var invokerFnBody = `return function (${argsList}) {
+`;
+      if (needsDestructorStack) {
+        invokerFnBody += "var destructors = [];\n";
+      }
+      var dtorStack = needsDestructorStack ? "destructors" : "null";
+      var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
+      if (isClassMethodFunc) {
+        invokerFnBody += `var thisWired = classParam['toWireType'](${dtorStack}, this);
+`;
+      }
+      for (var i = 0; i < argCount; ++i) {
+        invokerFnBody += `var arg${i}Wired = argType${i}['toWireType'](${dtorStack}, arg${i});
+`;
+        args1.push(`argType${i}`);
+      }
+      invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});
+`;
+      var returnVal = returns ? "rv" : "";
+      args1.push("Asyncify");
+      invokerFnBody += `function onDone(${returnVal}) {
+`;
+      if (needsDestructorStack) {
+        invokerFnBody += "runDestructors(destructors);\n";
+      } else {
+        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+          var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+          if (argTypes[i].destructorFunction !== null) {
+            invokerFnBody += `${paramName}_dtor(${paramName});
+`;
+            args1.push(`${paramName}_dtor`);
+          }
+        }
+      }
+      if (returns) {
+        invokerFnBody += "var ret = retType['fromWireType'](rv);\nreturn ret;\n";
+      }
+      invokerFnBody += "}\n";
+      invokerFnBody += `return Asyncify.currData ? Asyncify.whenDone().then(onDone) : onDone(${returnVal});
+`;
+      invokerFnBody += "}\n";
+      return [args1, invokerFnBody];
+    }
+    var runAndAbortIfError = (func) => {
+      try {
+        return func();
+      } catch (e) {
+        abort(e);
+      }
+    };
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    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 exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var maybeExit = () => {
+      if (!keepRuntimeAlive()) {
+        try {
+          _exit(EXITSTATUS);
+        } catch (e) {
+          handleException(e);
+        }
+      }
+    };
+    var callUserCallback = (func) => {
+      if (ABORT) {
+        return;
+      }
+      try {
+        func();
+        maybeExit();
+      } catch (e) {
+        handleException(e);
+      }
+    };
+    var Asyncify = { instrumentWasmImports(imports) {
+      var importPattern = /^(invoke_.*|__asyncjs__.*)$/;
+      for (let [x, original] of Object.entries(imports)) {
+        if (typeof original == "function") {
+          original.isAsync || importPattern.test(x);
+        }
+      }
+    }, instrumentWasmExports(exports) {
+      var ret = {};
+      for (let [x, original] of Object.entries(exports)) {
+        if (typeof original == "function") {
+          ret[x] = (...args) => {
+            Asyncify.exportCallStack.push(x);
+            try {
+              return original(...args);
+            } finally {
+              if (!ABORT) {
+                Asyncify.exportCallStack.pop();
+                Asyncify.maybeStopUnwind();
+              }
+            }
+          };
+        } else {
+          ret[x] = original;
+        }
+      }
+      return ret;
+    }, State: { Normal: 0, Unwinding: 1, Rewinding: 2, Disabled: 3 }, state: 0, StackSize: 4096, currData: null, handleSleepReturnValue: 0, exportCallStack: [], callStackNameToId: {}, callStackIdToName: {}, callStackId: 0, asyncPromiseHandlers: null, sleepCallbacks: [], getCallStackId(funcName) {
+      var id = Asyncify.callStackNameToId[funcName];
+      if (id === void 0) {
+        id = Asyncify.callStackId++;
+        Asyncify.callStackNameToId[funcName] = id;
+        Asyncify.callStackIdToName[id] = funcName;
+      }
+      return id;
+    }, maybeStopUnwind() {
+      if (Asyncify.currData && Asyncify.state === Asyncify.State.Unwinding && Asyncify.exportCallStack.length === 0) {
+        Asyncify.state = Asyncify.State.Normal;
+        runAndAbortIfError(_asyncify_stop_unwind);
+        if (typeof Fibers != "undefined") {
+          Fibers.trampoline();
+        }
+      }
+    }, whenDone() {
+      return new Promise((resolve, reject) => {
+        Asyncify.asyncPromiseHandlers = { resolve, reject };
+      });
+    }, allocateData() {
+      var ptr = _malloc(12 + Asyncify.StackSize);
+      Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
+      Asyncify.setDataRewindFunc(ptr);
+      return ptr;
+    }, setDataHeader(ptr, stack, stackSize) {
+      HEAPU32[ptr >> 2] = stack;
+      HEAPU32[ptr + 4 >> 2] = stack + stackSize;
+    }, setDataRewindFunc(ptr) {
+      var bottomOfCallStack = Asyncify.exportCallStack[0];
+      var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
+      HEAP32[ptr + 8 >> 2] = rewindId;
+    }, getDataRewindFuncName(ptr) {
+      var id = HEAP32[ptr + 8 >> 2];
+      var name = Asyncify.callStackIdToName[id];
+      return name;
+    }, getDataRewindFunc(name) {
+      var func = wasmExports[name];
+      return func;
+    }, doRewind(ptr) {
+      var name = Asyncify.getDataRewindFuncName(ptr);
+      var func = Asyncify.getDataRewindFunc(name);
+      return func();
+    }, handleSleep(startAsync) {
+      if (ABORT)
+        return;
+      if (Asyncify.state === Asyncify.State.Normal) {
+        var reachedCallback = false;
+        var reachedAfterCallback = false;
+        startAsync((handleSleepReturnValue = 0) => {
+          if (ABORT)
+            return;
+          Asyncify.handleSleepReturnValue = handleSleepReturnValue;
+          reachedCallback = true;
+          if (!reachedAfterCallback) {
+            return;
+          }
+          Asyncify.state = Asyncify.State.Rewinding;
+          runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
+          if (typeof MainLoop != "undefined" && MainLoop.func) {
+            MainLoop.resume();
+          }
+          var asyncWasmReturnValue, isError = false;
+          try {
+            asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
+          } catch (err2) {
+            asyncWasmReturnValue = err2;
+            isError = true;
+          }
+          var handled = false;
+          if (!Asyncify.currData) {
+            var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
+            if (asyncPromiseHandlers) {
+              Asyncify.asyncPromiseHandlers = null;
+              (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
+              handled = true;
+            }
+          }
+          if (isError && !handled) {
+            throw asyncWasmReturnValue;
+          }
+        });
+        reachedAfterCallback = true;
+        if (!reachedCallback) {
+          Asyncify.state = Asyncify.State.Unwinding;
+          Asyncify.currData = Asyncify.allocateData();
+          if (typeof MainLoop != "undefined" && MainLoop.func) {
+            MainLoop.pause();
+          }
+          runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
+        }
+      } else if (Asyncify.state === Asyncify.State.Rewinding) {
+        Asyncify.state = Asyncify.State.Normal;
+        runAndAbortIfError(_asyncify_stop_rewind);
+        _free(Asyncify.currData);
+        Asyncify.currData = null;
+        Asyncify.sleepCallbacks.forEach(callUserCallback);
+      } else {
+        abort(`invalid state: ${Asyncify.state}`);
+      }
+      return Asyncify.handleSleepReturnValue;
+    }, handleAsync: (startAsync) => Asyncify.handleSleep((wakeUp) => {
+      startAsync().then(wakeUp);
+    }) };
+    function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
+      var argCount = argTypes.length;
+      if (argCount < 2) {
+        throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+      }
+      var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+      var needsDestructorStack = usesDestructorStack(argTypes);
+      var returns = argTypes[0].name !== "void";
+      var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+      for (var i = 0; i < argCount - 2; ++i) {
+        closureArgs.push(argTypes[i + 2]);
+      }
+      closureArgs.push(Asyncify);
+      if (!needsDestructorStack) {
+        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+          if (argTypes[i].destructorFunction !== null) {
+            closureArgs.push(argTypes[i].destructorFunction);
+          }
+        }
+      }
+      let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
+      var invokerFn = new Function(...args, invokerFnBody)(...closureArgs);
+      return createNamedFunction(humanName, invokerFn);
+    }
+    var ensureOverloadTable = (proto, methodName, humanName) => {
+      if (void 0 === proto[methodName].overloadTable) {
+        var prevFunc = proto[methodName];
+        proto[methodName] = function(...args) {
+          if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+            throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
+          }
+          return proto[methodName].overloadTable[args.length].apply(this, args);
+        };
+        proto[methodName].overloadTable = [];
+        proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+      }
+    };
+    var exposePublicSymbol = (name, value, numArguments) => {
+      if (Module.hasOwnProperty(name)) {
+        if (void 0 === numArguments || void 0 !== Module[name].overloadTable && void 0 !== Module[name].overloadTable[numArguments]) {
+          throwBindingError(`Cannot register public name '${name}' twice`);
+        }
+        ensureOverloadTable(Module, name, name);
+        if (Module[name].overloadTable.hasOwnProperty(numArguments)) {
+          throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
+        }
+        Module[name].overloadTable[numArguments] = value;
+      } else {
+        Module[name] = value;
+        Module[name].argCount = numArguments;
+      }
+    };
+    var heap32VectorToArray = (count, firstElement) => {
+      var array = [];
+      for (var i = 0; i < count; i++) {
+        array.push(HEAPU32[firstElement + i * 4 >> 2]);
+      }
+      return array;
+    };
+    var replacePublicSymbol = (name, value, numArguments) => {
+      if (!Module.hasOwnProperty(name)) {
+        throwInternalError("Replacing nonexistent public symbol");
+      }
+      if (void 0 !== Module[name].overloadTable && void 0 !== numArguments) {
+        Module[name].overloadTable[numArguments] = value;
+      } else {
+        Module[name] = value;
+        Module[name].argCount = numArguments;
+      }
+    };
+    var getDynCaller = (sig, ptr, promising = false) => (...args) => dynCall(sig, ptr, args, promising);
+    var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
+      signature = readLatin1String(signature);
+      function makeDynCaller() {
+        return getDynCaller(signature, rawFunction);
+      }
+      var fp = makeDynCaller();
+      if (typeof fp != "function") {
+        throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
+      }
+      return fp;
+    };
+    class UnboundTypeError extends Error {
+    }
+    var getTypeName = (type) => {
+      var ptr = ___getTypeName(type);
+      var rv = readLatin1String(ptr);
+      _free(ptr);
+      return rv;
+    };
+    var throwUnboundTypeError = (message, types) => {
+      var unboundTypes = [];
+      var seen = {};
+      function visit(type) {
+        if (seen[type]) {
+          return;
+        }
+        if (registeredTypes[type]) {
+          return;
+        }
+        if (typeDependencies[type]) {
+          typeDependencies[type].forEach(visit);
+          return;
+        }
+        unboundTypes.push(type);
+        seen[type] = true;
+      }
+      types.forEach(visit);
+      throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
+    };
+    var getFunctionName = (signature) => {
+      signature = signature.trim();
+      const argsIndex = signature.indexOf("(");
+      if (argsIndex === -1)
+        return signature;
+      return signature.slice(0, argsIndex);
+    };
+    var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => {
+      var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+      name = readLatin1String(name);
+      name = getFunctionName(name);
+      rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync);
+      exposePublicSymbol(name, function() {
+        throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
+      }, argCount - 1);
+      whenDependentTypesAreResolved([], argTypes, (argTypes2) => {
+        var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1));
+        replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1);
+        return [];
+      });
+    };
+    var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
+      name = readLatin1String(name);
+      const isUnsignedType = minRange === 0;
+      let fromWireType = (value) => value;
+      if (isUnsignedType) {
+        var bitshift = 32 - 8 * size;
+        fromWireType = (value) => value << bitshift >>> bitshift;
+        maxRange = fromWireType(maxRange);
+      }
+      registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => value, argPackAdvance: GenericWireTypeSize, readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
+    };
+    var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
+      var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+      var TA = typeMapping[dataTypeIndex];
+      function decodeMemoryView(handle) {
+        var size = HEAPU32[handle >> 2];
+        var data = HEAPU32[handle + 4 >> 2];
+        return new TA(HEAP8.buffer, data, size);
+      }
+      name = readLatin1String(name);
+      registerType(rawType, { name, fromWireType: decodeMemoryView, argPackAdvance: GenericWireTypeSize, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true });
+    };
+    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    var __embind_register_std_string = (rawType, name) => {
+      name = readLatin1String(name);
+      registerType(rawType, { name, fromWireType(value) {
+        var length = HEAPU32[value >> 2];
+        var payload = value + 4;
+        var str;
+        var i; {
+          var decodeStartPtr = payload;
+          for (var i = 0; i <= length; ++i) {
+            var currentBytePtr = payload + i;
+            if (i == length || HEAPU8[currentBytePtr] == 0) {
+              var maxRead = currentBytePtr - decodeStartPtr;
+              var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+              if (str === void 0) {
+                str = stringSegment;
+              } else {
+                str += String.fromCharCode(0);
+                str += stringSegment;
+              }
+              decodeStartPtr = currentBytePtr + 1;
+            }
+          }
+        }
+        _free(value);
+        return str;
+      }, toWireType(destructors, value) {
+        if (value instanceof ArrayBuffer) {
+          value = new Uint8Array(value);
+        }
+        var length;
+        var valueIsOfTypeString = typeof value == "string";
+        if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) {
+          throwBindingError("Cannot pass non-string to std::string");
+        }
+        if (valueIsOfTypeString) {
+          length = lengthBytesUTF8(value);
+        } else {
+          length = value.length;
+        }
+        var base = _malloc(4 + length + 1);
+        var ptr = base + 4;
+        HEAPU32[base >> 2] = length;
+        if (valueIsOfTypeString) {
+          {
+            stringToUTF8(value, ptr, length + 1);
+          }
+        } else {
+          HEAPU8.set(value, ptr);
+        }
+        if (destructors !== null) {
+          destructors.push(_free, base);
+        }
+        return base;
+      }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
+        _free(ptr);
+      } });
+    };
+    var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
+    var UTF16ToString = (ptr, maxBytesToRead) => {
+      var idx = ptr >> 1;
+      var maxIdx = idx + maxBytesToRead / 2;
+      var endIdx = idx;
+      while (!(endIdx >= maxIdx) && HEAPU16[endIdx])
+        ++endIdx;
+      if (endIdx - idx > 16 && UTF16Decoder)
+        return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx));
+      var str = "";
+      for (var i = idx; !(i >= maxIdx); ++i) {
+        var codeUnit = HEAPU16[i];
+        if (codeUnit == 0)
+          break;
+        str += String.fromCharCode(codeUnit);
+      }
+      return str;
+    };
+    var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+      maxBytesToWrite ?? (maxBytesToWrite = 2147483647);
+      if (maxBytesToWrite < 2)
+        return 0;
+      maxBytesToWrite -= 2;
+      var startPtr = outPtr;
+      var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+      for (var i = 0; i < numCharsToWrite; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        HEAP16[outPtr >> 1] = codeUnit;
+        outPtr += 2;
+      }
+      HEAP16[outPtr >> 1] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF16 = (str) => str.length * 2;
+    var UTF32ToString = (ptr, maxBytesToRead) => {
+      var i = 0;
+      var str = "";
+      while (!(i >= maxBytesToRead / 4)) {
+        var utf32 = HEAP32[ptr + i * 4 >> 2];
+        if (utf32 == 0)
+          break;
+        ++i;
+        if (utf32 >= 65536) {
+          var ch = utf32 - 65536;
+          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+        } else {
+          str += String.fromCharCode(utf32);
+        }
+      }
+      return str;
+    };
+    var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+      maxBytesToWrite ?? (maxBytesToWrite = 2147483647);
+      if (maxBytesToWrite < 4)
+        return 0;
+      var startPtr = outPtr;
+      var endPtr = startPtr + maxBytesToWrite - 4;
+      for (var i = 0; i < str.length; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        if (codeUnit >= 55296 && codeUnit <= 57343) {
+          var trailSurrogate = str.charCodeAt(++i);
+          codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
+        }
+        HEAP32[outPtr >> 2] = codeUnit;
+        outPtr += 4;
+        if (outPtr + 4 > endPtr)
+          break;
+      }
+      HEAP32[outPtr >> 2] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF32 = (str) => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var codeUnit = str.charCodeAt(i);
+        if (codeUnit >= 55296 && codeUnit <= 57343)
+          ++i;
+        len += 4;
+      }
+      return len;
+    };
+    var __embind_register_std_wstring = (rawType, charSize, name) => {
+      name = readLatin1String(name);
+      var decodeString, encodeString, readCharAt, lengthBytesUTF;
+      if (charSize === 2) {
+        decodeString = UTF16ToString;
+        encodeString = stringToUTF16;
+        lengthBytesUTF = lengthBytesUTF16;
+        readCharAt = (pointer) => HEAPU16[pointer >> 1];
+      } else if (charSize === 4) {
+        decodeString = UTF32ToString;
+        encodeString = stringToUTF32;
+        lengthBytesUTF = lengthBytesUTF32;
+        readCharAt = (pointer) => HEAPU32[pointer >> 2];
+      }
+      registerType(rawType, { name, fromWireType: (value) => {
+        var length = HEAPU32[value >> 2];
+        var str;
+        var decodeStartPtr = value + 4;
+        for (var i = 0; i <= length; ++i) {
+          var currentBytePtr = value + 4 + i * charSize;
+          if (i == length || readCharAt(currentBytePtr) == 0) {
+            var maxReadBytes = currentBytePtr - decodeStartPtr;
+            var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+            if (str === void 0) {
+              str = stringSegment;
+            } else {
+              str += String.fromCharCode(0);
+              str += stringSegment;
+            }
+            decodeStartPtr = currentBytePtr + charSize;
+          }
+        }
+        _free(value);
+        return str;
+      }, toWireType: (destructors, value) => {
+        if (!(typeof value == "string")) {
+          throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
+        }
+        var length = lengthBytesUTF(value);
+        var ptr = _malloc(4 + length + charSize);
+        HEAPU32[ptr >> 2] = length / charSize;
+        encodeString(value, ptr + 4, length + charSize);
+        if (destructors !== null) {
+          destructors.push(_free, ptr);
+        }
+        return ptr;
+      }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
+        _free(ptr);
+      } });
+    };
+    var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => {
+      structRegistrations[rawType] = { name: readLatin1String(name), rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), fields: [] };
+    };
+    var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => {
+      structRegistrations[structType].fields.push({ fieldName: readLatin1String(fieldName), getterReturnType, getter: embind__requireFunction(getterSignature, getter), getterContext, setterArgumentType, setter: embind__requireFunction(setterSignature, setter), setterContext });
+    };
+    var __embind_register_void = (rawType, name) => {
+      name = readLatin1String(name);
+      registerType(rawType, { isVoid: true, name, argPackAdvance: 0, fromWireType: () => void 0, toWireType: (destructors, o) => void 0 });
+    };
+    var requireRegisteredType = (rawType, humanName) => {
+      var impl = registeredTypes[rawType];
+      if (void 0 === impl) {
+        throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+      }
+      return impl;
+    };
+    var emval_returnValue = (returnType, destructorsRef, handle) => {
+      var destructors = [];
+      var result = returnType["toWireType"](destructors, handle);
+      if (destructors.length) {
+        HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
+      }
+      return result;
+    };
+    var __emval_as = (handle, returnType, destructorsRef) => {
+      handle = Emval.toValue(handle);
+      returnType = requireRegisteredType(returnType, "emval::as");
+      return emval_returnValue(returnType, destructorsRef, handle);
+    };
+    var emval_methodCallers = [];
+    var __emval_call = (caller, handle, destructorsRef, args) => {
+      caller = emval_methodCallers[caller];
+      handle = Emval.toValue(handle);
+      return caller(null, handle, destructorsRef, args);
+    };
+    var emval_symbols = {};
+    var getStringOrSymbol = (address) => {
+      var symbol = emval_symbols[address];
+      if (symbol === void 0) {
+        return readLatin1String(address);
+      }
+      return symbol;
+    };
+    var emval_get_global = () => {
+      if (typeof globalThis == "object") {
+        return globalThis;
+      }
+      return (/* @__PURE__ */ function() {
+        return Function;
+      }())("return this")();
+    };
+    var __emval_get_global = (name) => {
+      if (name === 0) {
+        return Emval.toHandle(emval_get_global());
+      } else {
+        name = getStringOrSymbol(name);
+        return Emval.toHandle(emval_get_global()[name]);
+      }
+    };
+    var emval_addMethodCaller = (caller) => {
+      var id = emval_methodCallers.length;
+      emval_methodCallers.push(caller);
+      return id;
+    };
+    var emval_lookupTypes = (argCount, argTypes) => {
+      var a = new Array(argCount);
+      for (var i = 0; i < argCount; ++i) {
+        a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2], `parameter ${i}`);
+      }
+      return a;
+    };
+    var __emval_get_method_caller = (argCount, argTypes, kind) => {
+      var types = emval_lookupTypes(argCount, argTypes);
+      var retType = types.shift();
+      argCount--;
+      var functionBody = `return function (obj, func, destructorsRef, args) {
+`;
+      var offset = 0;
+      var argsList = [];
+      if (kind === 0) {
+        argsList.push("obj");
+      }
+      var params = ["retType"];
+      var args = [retType];
+      for (var i = 0; i < argCount; ++i) {
+        argsList.push(`arg${i}`);
+        params.push(`argType${i}`);
+        args.push(types[i]);
+        functionBody += `  var arg${i} = argType${i}.readValueFromPointer(args${offset ? "+" + offset : ""});
+`;
+        offset += types[i].argPackAdvance;
+      }
+      var invoker = kind === 1 ? "new func" : "func.call";
+      functionBody += `  var rv = ${invoker}(${argsList.join(", ")});
+`;
+      if (!retType.isVoid) {
+        params.push("emval_returnValue");
+        args.push(emval_returnValue);
+        functionBody += "  return emval_returnValue(retType, destructorsRef, rv);\n";
+      }
+      functionBody += "};\n";
+      var invokerFunction = new Function(...params, functionBody)(...args);
+      var functionName = `methodCaller<(${types.map((t) => t.name).join(", ")}) => ${retType.name}>`;
+      return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+    };
+    var __emval_incref = (handle) => {
+      if (handle > 9) {
+        emval_handles[handle + 1] += 1;
+      }
+    };
+    var __emval_is_string = (handle) => {
+      handle = Emval.toValue(handle);
+      return typeof handle == "string";
+    };
+    var __emval_run_destructors = (handle) => {
+      var destructors = Emval.toValue(handle);
+      runDestructors(destructors);
+      __emval_decref(handle);
+    };
+    var __emval_take_value = (type, arg) => {
+      type = requireRegisteredType(type, "_emval_take_value");
+      var v = type["readValueFromPointer"](arg);
+      return Emval.toHandle(v);
+    };
+    var INT53_MAX = 9007199254740992;
+    var INT53_MIN = -9007199254740992;
+    var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+    function __gmtime_js(time, tmPtr) {
+      time = bigintToI53Checked(time);
+      var date = new Date(time * 1e3);
+      HEAP32[tmPtr >> 2] = date.getUTCSeconds();
+      HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
+      HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
+      HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
+      HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
+      HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
+      HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
+      var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
+      var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
+      HEAP32[tmPtr + 28 >> 2] = yday;
+    }
+    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;
+    };
+    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;
+    }
+    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);
+      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 checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+    function _clock_time_get(clk_id, ignored_precision, ptime) {
+      if (!checkWasiClock(clk_id)) {
+        return 28;
+      }
+      var now;
+      if (clk_id === 0) {
+        now = _emscripten_date_now();
+      } else {
+        now = _emscripten_get_now();
+      }
+      var nsec = Math.round(now * 1e3 * 1e3);
+      HEAP64[ptime >> 3] = BigInt(nsec);
+      return 0;
+    }
+    var readEmAsmArgsArray = [];
+    var readEmAsmArgs = (sigPtr, buf) => {
+      readEmAsmArgsArray.length = 0;
+      var ch;
+      while (ch = HEAPU8[sigPtr++]) {
+        var wide = ch != 105;
+        wide &= ch != 112;
+        buf += wide && buf % 8 ? 4 : 0;
+        readEmAsmArgsArray.push(ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]);
+        buf += wide ? 8 : 4;
+      }
+      return readEmAsmArgsArray;
+    };
+    var runEmAsmFunction = (code, sigPtr, argbuf) => {
+      var args = readEmAsmArgs(sigPtr, argbuf);
+      return ASM_CONSTS[code](...args);
+    };
+    var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
+    var getHeapMax = () => 2147483648;
+    var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+    var growMemory = (size) => {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 65535) / 65536 | 0;
+      try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1;
+      } catch (e) {
+      }
+    };
+    var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        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;
+        }
+      }
+      return false;
+    };
+    var safeSetTimeout = (func, timeout) => setTimeout(() => {
+      callUserCallback(func);
+    }, timeout);
+    var _emscripten_sleep = (ms) => Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
+    _emscripten_sleep.isAsync = true;
+    var ENV = {};
+    var getExecutableName = () => thisProgram || "./this.program";
+    var getEnvStrings = () => {
+      if (!getEnvStrings.strings) {
+        var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "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;
+      }
+    }
+    function _fd_fdstat_get(fd, pbuf) {
+      try {
+        var rightsBase = 0;
+        var rightsInheriting = 0;
+        var flags = 0;
+        {
+          var stream = SYSCALLS.getStreamFromFD(fd);
+          var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
+        }
+        HEAP8[pbuf] = type;
+        HEAP16[pbuf + 2 >> 1] = flags;
+        HEAP64[pbuf + 8 >> 3] = BigInt(rightsBase);
+        HEAP64[pbuf + 16 >> 3] = BigInt(rightsInheriting);
+        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 stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+    var stringToUTF8OnStack = (str) => {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret;
+    };
+    FS.createPreloadedFile = FS_createPreloadedFile;
+    FS.staticInit();
+    MEMFS.doesNotExistError = new FS.ErrnoError(44);
+    MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+    embind_init_charCodes();
+    {
+      if (Module["noExitRuntime"])
+        noExitRuntime = Module["noExitRuntime"];
+      if (Module["preloadPlugins"])
+        preloadPlugins = Module["preloadPlugins"];
+      if (Module["print"])
+        out = Module["print"];
+      if (Module["printErr"])
+        err = Module["printErr"];
+      if (Module["wasmBinary"])
+        wasmBinary = Module["wasmBinary"];
+      if (Module["arguments"])
+        arguments_ = Module["arguments"];
+      if (Module["thisProgram"])
+        thisProgram = Module["thisProgram"];
+    }
+    var ASM_CONSTS = { 1473352: () => {
+      console.error("progress callback is not set.");
+    } };
+    var wasmImports = { a: ___cxa_throw, j: ___syscall_fcntl64, G: ___syscall_ioctl, H: ___syscall_openat, r: ___syscall_renameat, s: ___syscall_rmdir, w: ___syscall_stat64, t: ___syscall_unlinkat, u: __abort_js, L: __embind_finalize_value_object, m: __embind_register_bigint, R: __embind_register_bool, P: __embind_register_emval, l: __embind_register_float, f: __embind_register_function, c: __embind_register_integer, b: __embind_register_memory_view, Q: __embind_register_std_string, g: __embind_register_std_wstring, O: __embind_register_value_object, M: __embind_register_value_object_field, S: __embind_register_void, N: __emval_as, d: __emval_call, q: __emval_decref, F: __emval_get_global, e: __emval_get_method_caller, o: __emval_incref, T: __emval_is_string, n: __emval_run_destructors, p: __emval_take_value, x: __gmtime_js, y: __localtime_js, z: __tzset_js, J: _clock_time_get, K: _emscripten_asm_const_int, I: _emscripten_date_now, v: _emscripten_resize_heap, k: _emscripten_sleep, C: _environ_get, D: _environ_sizes_get, h: _fd_close, B: _fd_fdstat_get, E: _fd_read, A: _fd_seek, i: _fd_write };
+    var wasmExports = await createWasm();
+    wasmExports["V"];
+    var ___getTypeName = wasmExports["W"];
+    var _malloc = wasmExports["X"];
+    var _free = wasmExports["Y"];
+    var _main = Module["_main"] = wasmExports["Z"];
+    var __emscripten_stack_alloc = wasmExports["_"];
+    Module["dynCall_ii"] = wasmExports["$"];
+    Module["dynCall_vi"] = wasmExports["aa"];
+    Module["dynCall_vii"] = wasmExports["ba"];
+    Module["dynCall_iii"] = wasmExports["ca"];
+    Module["dynCall_viii"] = wasmExports["da"];
+    Module["dynCall_v"] = wasmExports["ea"];
+    Module["dynCall_diiii"] = wasmExports["fa"];
+    Module["dynCall_viif"] = wasmExports["ga"];
+    Module["dynCall_iiiii"] = wasmExports["ha"];
+    Module["dynCall_iiii"] = wasmExports["ia"];
+    Module["dynCall_ddd"] = wasmExports["ja"];
+    Module["dynCall_i"] = wasmExports["ka"];
+    Module["dynCall_fii"] = wasmExports["la"];
+    Module["dynCall_viiii"] = wasmExports["ma"];
+    Module["dynCall_iiiiii"] = wasmExports["na"];
+    Module["dynCall_idd"] = wasmExports["oa"];
+    Module["dynCall_jiji"] = wasmExports["pa"];
+    Module["dynCall_iidiiii"] = wasmExports["qa"];
+    Module["dynCall_viijii"] = wasmExports["ra"];
+    Module["dynCall_iiiiiiiii"] = wasmExports["sa"];
+    Module["dynCall_iiiiiii"] = wasmExports["ta"];
+    Module["dynCall_iiiiij"] = wasmExports["ua"];
+    Module["dynCall_iiiiid"] = wasmExports["va"];
+    Module["dynCall_iiiiijj"] = wasmExports["wa"];
+    Module["dynCall_iiiiiiii"] = wasmExports["xa"];
+    Module["dynCall_iiiiiijj"] = wasmExports["ya"];
+    Module["dynCall_viiiiii"] = wasmExports["za"];
+    Module["dynCall_viiiii"] = wasmExports["Aa"];
+    var _asyncify_start_unwind = wasmExports["Ba"];
+    var _asyncify_stop_unwind = wasmExports["Ca"];
+    var _asyncify_start_rewind = wasmExports["Da"];
+    var _asyncify_stop_rewind = wasmExports["Ea"];
+    function callMain(args = []) {
+      var entryFunction = _main;
+      args.unshift(thisProgram);
+      var argc = args.length;
+      var argv = stackAlloc((argc + 1) * 4);
+      var argv_ptr = argv;
+      args.forEach((arg) => {
+        HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
+        argv_ptr += 4;
+      });
+      HEAPU32[argv_ptr >> 2] = 0;
+      try {
+        var ret = entryFunction(argc, argv);
+        exitJS(ret, true);
+        return ret;
+      } catch (e) {
+        return handleException(e);
+      }
+    }
+    function run(args = arguments_) {
+      if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return;
+      }
+      function doRun() {
+        Module["calledRun"] = true;
+        if (ABORT)
+          return;
+        initRuntime();
+        readyPromiseResolve(Module);
+        Module["onRuntimeInitialized"]?.();
+        var noInitialRun = Module["noInitialRun"] || true;
+        if (!noInitialRun)
+          callMain(args);
+        postRun();
+      }
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+          setTimeout(() => Module["setStatus"](""), 1);
+          doRun();
+        }, 1);
+      } else {
+        doRun();
+      }
+    }
+    function preInit() {
+      if (Module["preInit"]) {
+        if (typeof Module["preInit"] == "function")
+          Module["preInit"] = [Module["preInit"]];
+        while (Module["preInit"].length > 0) {
+          Module["preInit"].shift()();
+        }
+      }
+    }
+    preInit();
+    run();
+    moduleRtn = readyPromise;
+    return moduleRtn;
+  };
+})();
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const cdnUrl = `https://cdn.jsdelivr.net/npm/@creooxag/cxconverter@${packageJSON.version}/dist/`;
+const defaultUrlPrefix = "./";
+const _IfcWasmConverterLoader = class _IfcWasmConverterLoader {
+  constructor() {
+    __publicField$1(this, "module");
+  }
+  static async getInstance(userUrlPrefix = "remote") {
+    let urlPrefix = defaultUrlPrefix;
+    if (userUrlPrefix) {
+      urlPrefix = userUrlPrefix == "remote" ? cdnUrl : userUrlPrefix;
+    }
+    if (!_IfcWasmConverterLoader.instance) {
+      _IfcWasmConverterLoader.instance = new _IfcWasmConverterLoader();
+      const Module = {
+        locateFile: function(path) {
+          const fullPath = urlPrefix + path;
+          if (path.endsWith(".wasm")) {
+            console.log(`Loading wasm file from ${fullPath}`);
+            return fullPath;
+          }
+          return path;
+        }
+      };
+      try {
+        _IfcWasmConverterLoader.instance.module = await IfcDbWasm(Module);
+      } catch (error) {
+        console.error("Error on wasm import:", error);
+      }
+    }
+    return _IfcWasmConverterLoader.instance;
+  }
+  static async getModule(userUrlPrefix) {
+    return (await _IfcWasmConverterLoader.getInstance(userUrlPrefix)).module;
+  }
+};
+__publicField$1(_IfcWasmConverterLoader, "instance");
+let IfcWasmConverterLoader = _IfcWasmConverterLoader;
+
+async function ifc2gltf(ifcData, params = { remote: true }) {
+  if (params.remote == void 0)
+    params.remote = true;
+  const inputOptionsString = params.inputOptions ? params.inputOptions : JSON.stringify(inputOptionsDefault);
+  const loadOptions = {
+    "maxFileSizeInMegaBytes": 1e3
+  };
+  let resolveCallbackGltf = void 0;
+  let resolveCallbackMetadata = void 0;
+  const url = params.remote ? "remote" : params.urlPath;
+  const module = await IfcWasmConverterLoader.getModule(url);
+  if (params.progressCallback)
+    module.setProgressCallback(params.progressCallback);
+  else
+    module.setProgressCallback((progress) => {
+      console.log(`Progress: ${progress}`);
+    });
+  if (params.progressTextCallback)
+    module.setProgressTextCallback(params.progressTextCallback);
+  else
+    module.setProgressTextCallback((progressText) => {
+      console.log(`Progress text: ${progressText}`);
+    });
+  module.setInputOptions(inputOptionsString);
+  const promiseGltf = new Promise((resolve) => {
+    resolveCallbackGltf = resolve;
+  });
+  const promiseMetadata = new Promise((resolve) => {
+    resolveCallbackMetadata = resolve;
+  });
+  if (resolveCallbackGltf)
+    module.setGltfCompleteCallback(resolveCallbackGltf);
+  if (resolveCallbackMetadata)
+    module.setMetaDataCompleteCallback(resolveCallbackMetadata);
+  module.loadModel(ifcData, loadOptions);
+  await Promise.all([promiseGltf, promiseMetadata]);
+  const gltf = await module.getGeometry();
+  const uint8Array = await module.getMetaData();
+  const decoder = new TextDecoder();
+  const metaStr = decoder.decode(uint8Array);
+  const metaData = await JSON.parse(metaStr);
+  return { gltf, metaData };
+}
+const inputOptionsDefault = {
+  "inputParameters": {
+    "exportPropertySets": "yes",
+    "exportIfcPropertyTypes": "yes",
+    "exportIfcValueTypes": "yes",
+    "exportPolylines": "yes",
+    "excludeGeometryForIfcTypes": ["IfcOpeningElement"],
+    "excludeGUIDs": [""],
+    "exportOnlyGUIDs": [""],
+    "centerModelAtOrigin": "yes",
+    "ignoreProfileRadius": "yes",
+    "enableGltfCompression": "yes",
+    "enableGltfQuantization": "no",
+    "exportNormals": "no",
+    "numPointsPerCircle": 18,
+    "licenceKey": "",
+    // JSON above is copied from default input config file. Changes applied here:
+    "loadingPriorityTypes": ["IFCWALL", "IFCSLAB", "IFCWINDOW", "IFCROOF", "IFCFURNISHINGELEMENT", "IFCAIRTERMINAL"]
+    //[ "IfcOpeningElement" ],
+  }
+};
+
+/**
+ * Fetches a file from the given URL and returns its contents as text.
+ *
+ * @param {string} url - The URL to fetch the file from.
+ * @returns {Promise<string>} A promise that resolves to the file contents.
+ * @private
+ */
+async function fetchFile(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        return response.text();
+    } catch (error) {
+        console.error('Error fetching file:', error);
+    }
+}
+
+/**
+ * {@link Viewer} plugin that uses [CxConverter](https://github.com/Creoox/cxconverter) to load BIM models directly from IFC files, using its WebAssembly buid from [npm package](https://www.npmjs.com/package/@creooxag/cxconverter).
+ *
+ * ## Overview
+ * The WebAssembly build of CxConverter is still in alfa stage, so it may not work as expected. This documentation will be updated as the library and the plugin evolve. The example below shows how to use the plugin:
+ * ````javascript
+ * import { CxConverterIFCLoaderPlugin, Viewer } from "../../dist/xeokit-sdk.es.js";
+ * const cxConverterIFCLoaderPlugin = new CxConverterIFCLoaderPlugin(viewer);
+ * 
+ * const sceneModel = await cxConverterIFCLoaderPlugin.load({
+ *        src: "../../assets/models/ifc/Duplex.ifc"
+ * }); 
+ * ````
+    See the code in action [here](https://xeokit.github.io/xeokit-sdk/examples/buildings/#cxConverterIFC_vbo_Duplex).
+ */
+
+class CxConverterIFCLoaderPlugin extends Plugin {
+    /**
+     * @constructor
+     * @param {Viewer} viewer The Viewer.
+     * @param {Object} [cfg={}] Plugin configuration.
+     */
+    constructor(viewer, cfg = {}) {
+        super("ifcLoader", viewer, cfg);
+
+        /**
+         * The GLTFLoaderPlugin used internally to load the converted GLTF.
+         * @type {GLTFLoaderPlugin}
+         */
+        this.gltfLoader = new GLTFLoaderPlugin(this.viewer);
+    }
+
+    /**
+     * Loads an IFC model from the given source.
+     *
+     * @param {Object} [params={}] Loading parameters.
+     * @param {string} params.src Path to an IFC file.
+     * @param {Function} [params.progressCallback] Callback to track loading progress.
+     * @param {Function} [params.progressTextCallback] Callback to track loading progress with text updates.
+     * @returns {Promise<SceneModel>} A promise that resolves to the loaded SceneModel.
+     */
+    async load(params = {}) {
+        if (!params.src) {
+            this.error("load() param expected: src");
+        }
+        const data = await fetchFile(params.src);
+        const { gltf, metaData } = await ifc2gltf(
+            data,
+            {
+                remote: true,
+                progressCallback: params.progressCallback,
+                progressTextCallback: params.progressTextCallback
+            }
+        );
+        const sceneModel = this.gltfLoader.load({
+            id: "myModel",
+            gltf: gltf,
+            metaModelJSON: metaData
+        });
+        return sceneModel;
+    }
+}
+
 /**
  * Default data access strategy for {@link LASLoaderPlugin}.
  */
@@ -166702,4 +170784,4 @@ class ZoneTranslateTouchControl extends ZoneTranslateControl {
     }
 }
 
-export { AlphaFormat, AmbientLight, AngleMeasurementEditMouseControl, AngleMeasurementEditTouchControl, AngleMeasurementsControl, AngleMeasurementsMouseControl, AngleMeasurementsPlugin, AngleMeasurementsTouchControl, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, Bitmap, ByteType, CameraMemento, CameraPath, CameraPathAnimation, CityJSONLoaderPlugin, ClampToEdgeWrapping, Component, CompressedMediaType, Configs, ContextMenu, CubicBezierCurve, Curve, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DirLight, DistanceMeasurementEditControl, DistanceMeasurementEditMouseControl, DistanceMeasurementEditTouchControl, DistanceMeasurementsControl, DistanceMeasurementsMouseControl, DistanceMeasurementsPlugin, DistanceMeasurementsTouchControl, Dot3D, DotBIMDefaultDataSource, DotBIMLoaderPlugin, EdgeMaterial, EmphasisMaterial, FaceAlignedSectionPlanesPlugin, FastNavPlugin, FloatType, Fresnel, Frustum$1 as Frustum, FrustumPlane, GIFMediaType, GLTFDefaultDataSource, GLTFLoaderPlugin, HalfFloatType, ImagePlane, IntType, JPEGMediaType, KTX2TextureTranscoder, LASLoaderPlugin, Label3D, LambertMaterial, LightMap, LineSet, LinearEncoding, LinearFilter, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, Loader, LoadingManager, LocaleService, LuminanceAlphaFormat, LuminanceFormat, Map$1 as Map, Marker, MarqueePicker, MarqueePickerMouseControl, Mesh, MeshSurfaceArea, MeshVolume, MetallicMaterial, MirroredRepeatWrapping, ModelMemento, NavCubePlugin, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, Node$1 as Node, OBJLoaderPlugin, ObjectsKdTree3, ObjectsMemento, PNGMediaType, Path, PerformanceModel, PhongMaterial, PickResult, Plugin, PointLight, PointerCircle, PointerLens, QuadraticBezierCurve, Queue, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBFormat, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, ReadableGeometry, RedFormat, RedIntegerFormat, ReflectionMap, RepeatWrapping, STLDefaultDataSource, STLLoaderPlugin, SceneModel, SceneModelMesh, SceneModelTransform, SectionPlane, SectionPlanesPlugin, ShortType, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TextureTranscoder, TransformControl, TreeViewPlugin, UnsignedByteType, UnsignedInt248Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VBOGeometry, ViewCullPlugin, Viewer, WebIFCLoaderPlugin, Wire3D, WorkerPool$1 as WorkerPool, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, ZoneEditControl, ZoneEditMouseControl, ZoneEditTouchControl, ZoneTranslateControl, ZoneTranslateMouseControl, ZoneTranslateTouchControl, ZonesMouseControl, ZonesPlugin, ZonesPolysurfaceMouseControl, ZonesPolysurfaceTouchControl, ZonesTouchControl, activateDraggableDot, activateDraggableDots, addMousePressListener, addTouchPressListener, buildBoxGeometry, buildBoxLinesGeometry, buildBoxLinesGeometryFromAABB, buildCylinderGeometry, buildGridGeometry, buildLineGeometry, buildPlaneGeometry, buildPolylineGeometry, buildPolylineGeometryFromCurve, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, createCombinedTexture, createRTCViewMat, createSkyboxMesh, createSphereMapMesh, frustumIntersectsAABB3, getKTX2TextureTranscoder, getPlaneRTCPos, isTriangleMeshSolid, load3DSGeometry, loadOBJGeometry, marker3D, math, meshSurfaceArea, meshVolume, os, rtcToWorldPos, sRGBEncoding, setFrustum, startPolygonCreate, stats, touchPointSelector, transformToNode, triangulateEarClipping, utils, wire3D, worldToRTCPos, worldToRTCPositions };
+export { AlphaFormat, AmbientLight, AngleMeasurementEditMouseControl, AngleMeasurementEditTouchControl, AngleMeasurementsControl, AngleMeasurementsMouseControl, AngleMeasurementsPlugin, AngleMeasurementsTouchControl, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, Bitmap, ByteType, CameraMemento, CameraPath, CameraPathAnimation, CityJSONLoaderPlugin, ClampToEdgeWrapping, Component, CompressedMediaType, Configs, ContextMenu, CubicBezierCurve, Curve, CxConverterIFCLoaderPlugin, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DirLight, DistanceMeasurementEditControl, DistanceMeasurementEditMouseControl, DistanceMeasurementEditTouchControl, DistanceMeasurementsControl, DistanceMeasurementsMouseControl, DistanceMeasurementsPlugin, DistanceMeasurementsTouchControl, Dot3D, DotBIMDefaultDataSource, DotBIMLoaderPlugin, EdgeMaterial, EmphasisMaterial, FaceAlignedSectionPlanesPlugin, FastNavPlugin, FloatType, Fresnel, Frustum$1 as Frustum, FrustumPlane, GIFMediaType, GLTFDefaultDataSource, GLTFLoaderPlugin, HalfFloatType, ImagePlane, IntType, JPEGMediaType, KTX2TextureTranscoder, LASLoaderPlugin, Label3D, LambertMaterial, LightMap, LineSet, LinearEncoding, LinearFilter, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, Loader, LoadingManager, LocaleService, LuminanceAlphaFormat, LuminanceFormat, Map$1 as Map, Marker, MarqueePicker, MarqueePickerMouseControl, Mesh, MeshSurfaceArea, MeshVolume, MetallicMaterial, MirroredRepeatWrapping, ModelMemento, NavCubePlugin, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, Node$1 as Node, OBJLoaderPlugin, ObjectsKdTree3, ObjectsMemento, PNGMediaType, Path, PerformanceModel, PhongMaterial, PickResult, Plugin, PointLight, PointerCircle, PointerLens, QuadraticBezierCurve, Queue, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBFormat, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, ReadableGeometry, RedFormat, RedIntegerFormat, ReflectionMap, RepeatWrapping, STLDefaultDataSource, STLLoaderPlugin, SceneModel, SceneModelMesh, SceneModelTransform, SectionPlane, SectionPlanesPlugin, ShortType, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TextureTranscoder, TransformControl, TreeViewPlugin, UnsignedByteType, UnsignedInt248Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VBOGeometry, ViewCullPlugin, Viewer, WebIFCLoaderPlugin, Wire3D, WorkerPool$1 as WorkerPool, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, ZoneEditControl, ZoneEditMouseControl, ZoneEditTouchControl, ZoneTranslateControl, ZoneTranslateMouseControl, ZoneTranslateTouchControl, ZonesMouseControl, ZonesPlugin, ZonesPolysurfaceMouseControl, ZonesPolysurfaceTouchControl, ZonesTouchControl, activateDraggableDot, activateDraggableDots, addMousePressListener, addTouchPressListener, buildBoxGeometry, buildBoxLinesGeometry, buildBoxLinesGeometryFromAABB, buildCylinderGeometry, buildGridGeometry, buildLineGeometry, buildPlaneGeometry, buildPolylineGeometry, buildPolylineGeometryFromCurve, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, createCombinedTexture, createRTCViewMat, createSkyboxMesh, createSphereMapMesh, frustumIntersectsAABB3, getKTX2TextureTranscoder, getPlaneRTCPos, isTriangleMeshSolid, load3DSGeometry, loadOBJGeometry, marker3D, math, meshSurfaceArea, meshVolume, os, rtcToWorldPos, sRGBEncoding, setFrustum, startPolygonCreate, stats, touchPointSelector, transformToNode, triangulateEarClipping, utils, wire3D, worldToRTCPos, worldToRTCPositions };