wasm-image-optimization 1.2.30 → 1.3.0

package/dist/cjs/node/node-worker.js

@@ -179,14 +179,8 @@ var require_libImage = __commonJS({
       return async function(moduleArg = {}) {
         var moduleRtn;
         var Module2 = moduleArg;
-        var readyPromiseResolve, readyPromiseReject;
-        var readyPromise = new Promise((resolve, reject) => {
-          readyPromiseResolve = resolve;
-          readyPromiseReject = reject;
-        });
         var ENVIRONMENT_IS_WEB = true;
         var ENVIRONMENT_IS_WORKER = false;
-        var moduleOverrides = { ...Module2 };
         var arguments_ = [];
         var thisProgram = "./this.program";
         var quit_ = (status, toThrow) => {
@@ -201,18 +195,9 @@ var require_libImage = __commonJS({
         }
         var readAsync, readBinary;
         if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-          if (ENVIRONMENT_IS_WORKER) {
-            scriptDirectory = self.location.href;
-          } else if (typeof document != "undefined" && document.currentScript) {
-            scriptDirectory = document.currentScript.src;
-          }
-          if (_scriptName) {
-            scriptDirectory = _scriptName;
-          }
-          if (scriptDirectory.startsWith("blob:")) {
-            scriptDirectory = "";
-          } else {
-            scriptDirectory = scriptDirectory.slice(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+          try {
+            scriptDirectory = new URL(".", _scriptName).href;
+          } catch {
           }
           {
             readAsync = async (url) => {
@@ -225,30 +210,28 @@ var require_libImage = __commonJS({
           }
         } else {
         }
-        var out = Module2["print"] || console.log.bind(console);
-        var err = Module2["printErr"] || console.error.bind(console);
-        Object.assign(Module2, moduleOverrides);
-        moduleOverrides = null;
-        if (Module2["arguments"]) arguments_ = Module2["arguments"];
-        if (Module2["thisProgram"]) thisProgram = Module2["thisProgram"];
-        var wasmBinary = Module2["wasmBinary"];
-        var wasmMemory;
+        var out = console.log.bind(console);
+        var err = console.error.bind(console);
+        var wasmBinary;
         var ABORT = false;
         var EXITSTATUS;
-        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+        var readyPromiseResolve, readyPromiseReject;
+        var wasmMemory;
+        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+        var HEAP64, HEAPU64;
         var runtimeInitialized = false;
         function updateMemoryViews() {
           var b = wasmMemory.buffer;
-          Module2["HEAP8"] = HEAP8 = new Int8Array(b);
-          Module2["HEAP16"] = HEAP16 = new Int16Array(b);
-          Module2["HEAPU8"] = HEAPU8 = new Uint8Array(b);
-          Module2["HEAPU16"] = HEAPU16 = new Uint16Array(b);
-          Module2["HEAP32"] = HEAP32 = new Int32Array(b);
-          Module2["HEAPU32"] = HEAPU32 = new Uint32Array(b);
-          Module2["HEAPF32"] = HEAPF32 = new Float32Array(b);
-          Module2["HEAPF64"] = HEAPF64 = new Float64Array(b);
-          Module2["HEAP64"] = HEAP64 = new BigInt64Array(b);
-          Module2["HEAPU64"] = HEAPU64 = new BigUint64Array(b);
+          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 (Module2["preRun"]) {
@@ -263,7 +246,7 @@ var require_libImage = __commonJS({
           runtimeInitialized = true;
           if (!Module2["noFSInit"] && !FS.initialized) FS.init();
           TTY.init();
-          wasmExports["fa"]();
+          wasmExports["ha"]();
           FS.ignorePermissions = false;
         }
         function postRun() {
@@ -275,26 +258,6 @@ var require_libImage = __commonJS({
           }
           callRuntimeCallbacks(onPostRuns);
         }
-        var runDependencies = 0;
-        var dependenciesFulfilled = null;
-        function getUniqueRunDependency(id) {
-          return id;
-        }
-        function addRunDependency(id) {
-          runDependencies++;
-          Module2["monitorRunDependencies"]?.(runDependencies);
-        }
-        function removeRunDependency(id) {
-          runDependencies--;
-          Module2["monitorRunDependencies"]?.(runDependencies);
-          if (runDependencies == 0) {
-            if (dependenciesFulfilled) {
-              var callback = dependenciesFulfilled;
-              dependenciesFulfilled = null;
-              callback();
-            }
-          }
-        }
         function abort(what) {
           Module2["onAbort"]?.(what);
           what = "Aborted(" + what + ")";
@@ -302,7 +265,7 @@ var require_libImage = __commonJS({
           ABORT = true;
           what += ". Build with -sASSERTIONS for more info.";
           var e = new WebAssembly.RuntimeError(what);
-          readyPromiseReject(e);
+          readyPromiseReject?.(e);
           throw e;
         }
         var wasmBinaryFile;
@@ -339,7 +302,7 @@ var require_libImage = __commonJS({
           }
         }
         async function instantiateAsync(binary, binaryFile, imports) {
-          if (!binary && typeof WebAssembly.instantiateStreaming == "function") {
+          if (!binary) {
             try {
               var response = fetch(binaryFile, { credentials: "same-origin" });
               var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
@@ -357,13 +320,12 @@ var require_libImage = __commonJS({
         async function createWasm() {
           function receiveInstance(instance, module3) {
             wasmExports = instance.exports;
-            wasmMemory = wasmExports["ea"];
+            wasmMemory = wasmExports["ga"];
             updateMemoryViews();
-            wasmTable = wasmExports["ga"];
-            removeRunDependency("wasm-instantiate");
+            wasmTable = wasmExports["ia"];
+            assignWasmExports(wasmExports);
             return wasmExports;
           }
-          addRunDependency("wasm-instantiate");
           function receiveInstantiationResult(result2) {
             return receiveInstance(result2["instance"]);
           }
@@ -371,20 +333,14 @@ var require_libImage = __commonJS({
           if (Module2["instantiateWasm"]) {
             return new Promise((resolve, reject) => {
               Module2["instantiateWasm"](info, (mod, inst) => {
-                receiveInstance(mod, inst);
-                resolve(mod.exports);
+                resolve(receiveInstance(mod, inst));
               });
             });
           }
           wasmBinaryFile ??= findWasmBinary();
-          try {
-            var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
-            var exports3 = receiveInstantiationResult(result);
-            return exports3;
-          } catch (e) {
-            readyPromiseReject(e);
-            return Promise.reject(e);
-          }
+          var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+          var exports3 = receiveInstantiationResult(result);
+          return exports3;
         }
         class ExitStatus {
           name = "ExitStatus";
@@ -399,17 +355,21 @@ var require_libImage = __commonJS({
           }
         };
         var onPostRuns = [];
-        var addOnPostRun = (cb) => onPostRuns.unshift(cb);
+        var addOnPostRun = (cb) => onPostRuns.push(cb);
         var onPreRuns = [];
-        var addOnPreRun = (cb) => onPreRuns.unshift(cb);
-        var noExitRuntime = Module2["noExitRuntime"] || true;
+        var addOnPreRun = (cb) => onPreRuns.push(cb);
+        var noExitRuntime = true;
         var stackRestore = (val) => __emscripten_stack_restore(val);
         var stackSave = () => _emscripten_stack_get_current();
         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;
+        var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+          var maxIdx = idx + maxBytesToRead;
+          if (ignoreNul) return maxIdx;
+          while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+          return idx;
+        };
+        var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+          var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
           if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
             return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
           }
@@ -440,7 +400,7 @@ var require_libImage = __commonJS({
           }
           return str;
         };
-        var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+        var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
         var ___assert_fail = (condition, filename, line, func) => abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
         class ExceptionInfo {
           constructor(excPtr) {
@@ -616,11 +576,7 @@ var require_libImage = __commonJS({
           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;
-            }
+            var u = str.codePointAt(i);
             if (u <= 127) {
               if (outIdx >= endIdx) break;
               heap[outIdx++] = u;
@@ -639,6 +595,7 @@ var require_libImage = __commonJS({
               heap[outIdx++] = 128 | u >> 12 & 63;
               heap[outIdx++] = 128 | u >> 6 & 63;
               heap[outIdx++] = 128 | u & 63;
+              i++;
             }
           }
           heap[outIdx] = 0;
@@ -848,6 +805,10 @@ var require_libImage = __commonJS({
             MEMFS.resizeFileStorage(node, attr.size);
           }
         }, lookup(parent, name) {
+          if (!MEMFS.doesNotExistError) {
+            MEMFS.doesNotExistError = new FS.ErrnoError(44);
+            MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+          }
           throw MEMFS.doesNotExistError;
         }, mknod(parent, name, mode, dev) {
           return MEMFS.createNode(parent, name, mode, dev);
@@ -976,66 +937,73 @@ var require_libImage = __commonJS({
           MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
           return 0;
         } } };
+        var FS_modeStringToFlags = (str) => {
+          var flagModes = { r: 0, "r+": 2, w: 512 | 64 | 1, "w+": 512 | 64 | 2, a: 1024 | 64 | 1, "a+": 1024 | 64 | 2 };
+          var flags = flagModes[str];
+          if (typeof flags == "undefined") {
+            throw new Error(`Unknown file open mode: ${str}`);
+          }
+          return flags;
+        };
+        var FS_getMode = (canRead, canWrite) => {
+          var mode = 0;
+          if (canRead) mode |= 292 | 73;
+          if (canWrite) mode |= 146;
+          return mode;
+        };
         var asyncLoad = async (url) => {
           var arrayBuffer = await readAsync(url);
           return new Uint8Array(arrayBuffer);
         };
-        var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => {
-          FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
+        var FS_createDataFile = (...args) => FS.createDataFile(...args);
+        var getUniqueRunDependency = (id) => id;
+        var runDependencies = 0;
+        var dependenciesFulfilled = null;
+        var removeRunDependency = (id) => {
+          runDependencies--;
+          Module2["monitorRunDependencies"]?.(runDependencies);
+          if (runDependencies == 0) {
+            if (dependenciesFulfilled) {
+              var callback = dependenciesFulfilled;
+              dependenciesFulfilled = null;
+              callback();
+            }
+          }
+        };
+        var addRunDependency = (id) => {
+          runDependencies++;
+          Module2["monitorRunDependencies"]?.(runDependencies);
         };
-        var preloadPlugins = Module2["preloadPlugins"] || [];
-        var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+        var preloadPlugins = [];
+        var FS_handledByPreloadPlugin = async (byteArray, fullname) => {
           if (typeof Browser != "undefined") Browser.init();
-          var handled = false;
-          preloadPlugins.forEach((plugin) => {
-            if (handled) return;
+          for (var plugin of preloadPlugins) {
             if (plugin["canHandle"](fullname)) {
-              plugin["handle"](byteArray, fullname, finish, onerror);
-              handled = true;
+              return plugin["handle"](byteArray, fullname);
             }
-          });
-          return handled;
+          }
+          return byteArray;
         };
-        var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+        var FS_preloadFile = async (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => {
           var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
           var dep = getUniqueRunDependency(`cp ${fullname}`);
-          function processData(byteArray) {
-            function finish(byteArray2) {
-              preFinish?.();
-              if (!dontCreateFile) {
-                FS_createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
-              }
-              onload?.();
-              removeRunDependency(dep);
+          addRunDependency(dep);
+          try {
+            var byteArray = url;
+            if (typeof url == "string") {
+              byteArray = await asyncLoad(url);
             }
-            if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
-              onerror?.();
-              removeRunDependency(dep);
-            })) {
-              return;
+            byteArray = await FS_handledByPreloadPlugin(byteArray, fullname);
+            preFinish?.();
+            if (!dontCreateFile) {
+              FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
             }
-            finish(byteArray);
-          }
-          addRunDependency(dep);
-          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}`);
+          } finally {
+            removeRunDependency(dep);
           }
-          return flags;
         };
-        var FS_getMode = (canRead, canWrite) => {
-          var mode = 0;
-          if (canRead) mode |= 292 | 73;
-          if (canWrite) mode |= 146;
-          return mode;
+        var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+          FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror);
         };
         var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, readFiles: {}, ErrnoError: class {
           name = "ErrnoError";
@@ -1129,7 +1097,13 @@ var require_libImage = __commonJS({
               }
               if (parts[i] === "..") {
                 current_path = PATH.dirname(current_path);
-                current = current.parent;
+                if (FS.isRoot(current)) {
+                  path = current_path + "/" + parts.slice(i + 1).join("/");
+                  nlinks--;
+                  continue linkloop;
+                } else {
+                  current = current.parent;
+                }
                 continue;
               }
               current_path = PATH.join2(current_path, parts[i]);
@@ -1889,27 +1863,23 @@ var require_libImage = __commonJS({
           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;
+            buf = UTF8ArrayToString(buf);
           }
           FS.close(stream);
-          return ret;
+          return buf;
         }, 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)) {
+            data = new Uint8Array(intArrayFromString(data, true));
+          }
+          if (ArrayBuffer.isView(data)) {
             FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
           } else {
             throw new Error("Unsupported data type");
@@ -2129,7 +2099,6 @@ var require_libImage = __commonJS({
           } else {
             try {
               obj.contents = readBinary(obj.url);
-              obj.usedBytes = obj.contents.length;
             } catch (e) {
               throw new FS.ErrnoError(29);
             }
@@ -2287,12 +2256,12 @@ var require_libImage = __commonJS({
           }
           return dir + "/" + path;
         }, writeStat(buf, stat) {
-          HEAP32[buf >> 2] = stat.dev;
-          HEAP32[buf + 4 >> 2] = stat.mode;
+          HEAPU32[buf >> 2] = stat.dev;
+          HEAPU32[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;
+          HEAPU32[buf + 12 >> 2] = stat.uid;
+          HEAPU32[buf + 16 >> 2] = stat.gid;
+          HEAPU32[buf + 20 >> 2] = stat.rdev;
           HEAP64[buf + 24 >> 3] = BigInt(stat.size);
           HEAP32[buf + 32 >> 2] = 4096;
           HEAP32[buf + 36 >> 2] = stat.blocks;
@@ -2308,16 +2277,16 @@ var require_libImage = __commonJS({
           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;
+          HEAPU32[buf + 4 >> 2] = stats.bsize;
+          HEAPU32[buf + 60 >> 2] = stats.bsize;
+          HEAP64[buf + 8 >> 3] = BigInt(stats.blocks);
+          HEAP64[buf + 16 >> 3] = BigInt(stats.bfree);
+          HEAP64[buf + 24 >> 3] = BigInt(stats.bavail);
+          HEAP64[buf + 32 >> 3] = BigInt(stats.files);
+          HEAP64[buf + 40 >> 3] = BigInt(stats.ffree);
+          HEAPU32[buf + 48 >> 2] = stats.fsid;
+          HEAPU32[buf + 64 >> 2] = stats.flags;
+          HEAPU32[buf + 56 >> 2] = stats.namelen;
         }, doMsync(addr, stream, len, flags, offset) {
           if (!FS.isFile(stream.node.mode)) {
             throw new FS.ErrnoError(43);
@@ -2436,6 +2405,7 @@ var require_libImage = __commonJS({
                 if (!stream.tty) return -59;
                 return -28;
               }
+              case 21537:
               case 21531: {
                 var argp = syscallGetVarargP();
                 return FS.ioctl(stream, op, argp);
@@ -2479,37 +2449,18 @@ var require_libImage = __commonJS({
           }
         }
         var __abort_js = () => abort("");
-        var embindRepr = (v) => {
-          if (v === null) {
-            return "null";
-          }
-          var t = typeof v;
-          if (t === "object" || t === "array" || t === "function") {
-            return v.toString();
-          } else {
-            return "" + v;
-          }
-        };
-        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++]];
+        var AsciiToString = (ptr) => {
+          var str = "";
+          while (1) {
+            var ch = HEAPU8[ptr++];
+            if (!ch) return str;
+            str += String.fromCharCode(ch);
           }
-          return ret;
         };
         var awaitingDependencies = {};
         var registeredTypes = {};
         var typeDependencies = {};
-        var BindingError = Module2["BindingError"] = class BindingError extends Error {
+        var BindingError = class BindingError extends Error {
           constructor(message) {
             super(message);
             this.name = "BindingError";
@@ -2556,45 +2507,39 @@ var require_libImage = __commonJS({
           }
         };
         var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
-          name = readLatin1String(name);
-          var isUnsignedType = name.indexOf("u") != -1;
+          name = AsciiToString(name);
+          const isUnsignedType = minRange === 0n;
+          let fromWireType = (value) => value;
           if (isUnsignedType) {
-            maxRange = (1n << 64n) - 1n;
+            const bitSize = size * 8;
+            fromWireType = (value) => BigInt.asUintN(bitSize, value);
+            maxRange = fromWireType(maxRange);
           }
-          registerType(primitiveType, { name, fromWireType: (value) => value, toWireType: function(destructors, value) {
-            if (typeof value != "bigint" && typeof value != "number") {
-              throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${this.name}`);
-            }
+          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 });
+          }, readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null });
         };
-        var GenericWireTypeSize = 8;
         var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
-          name = readLatin1String(name);
+          name = AsciiToString(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]);
+          }, readValueFromPointer: function(pointer) {
+            return this.fromWireType(HEAPU8[pointer]);
           }, destructorFunction: null });
         };
         var emval_freelist = [];
-        var emval_handles = [];
+        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 count_emval_handles = () => emval_handles.length / 2 - 5 - emval_freelist.length;
-        var init_emval = () => {
-          emval_handles.push(0, 1, void 0, 1, null, 1, true, 1, false, 1);
-          Module2["count_emval_handles"] = count_emval_handles;
-        };
         var Emval = { toValue: (handle) => {
           if (!handle) {
             throwBindingError(`Cannot use deleted val. handle = ${handle}`);
@@ -2619,31 +2564,31 @@ var require_libImage = __commonJS({
           }
         } };
         function readPointer(pointer) {
-          return this["fromWireType"](HEAPU32[pointer >> 2]);
+          return this.fromWireType(HEAPU32[pointer >> 2]);
         }
         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 };
+        }, toWireType: (destructors, value) => Emval.toHandle(value), 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]);
+                return this.fromWireType(HEAPF32[pointer >> 2]);
               };
             case 8:
               return function(pointer) {
-                return this["fromWireType"](HEAPF64[pointer >> 3]);
+                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 });
+          name = AsciiToString(name);
+          registerType(rawType, { name, fromWireType: (value) => value, toWireType: (destructors, value) => value, readValueFromPointer: floatReadValueFromPointer(name, size), destructorFunction: null });
         };
         var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
         var runDestructors = (destructors) => {
@@ -2668,7 +2613,7 @@ var require_libImage = __commonJS({
           }
           var isClassMethodFunc = argTypes[1] !== null && classType !== null;
           var needsDestructorStack = usesDestructorStack(argTypes);
-          var returns = argTypes[0].name !== "void";
+          var returns = !argTypes[0].isVoid;
           var expectedArgCount = argCount - 2;
           var argsWired = new Array(expectedArgCount);
           var invokerFuncArgs = [];
@@ -2679,11 +2624,11 @@ var require_libImage = __commonJS({
             invokerFuncArgs.length = isClassMethodFunc ? 2 : 1;
             invokerFuncArgs[0] = cppTargetFunc;
             if (isClassMethodFunc) {
-              thisWired = argTypes[1]["toWireType"](destructors, this);
+              thisWired = argTypes[1].toWireType(destructors, this);
               invokerFuncArgs[1] = thisWired;
             }
             for (var i = 0; i < expectedArgCount; ++i) {
-              argsWired[i] = argTypes[i + 2]["toWireType"](destructors, args[i]);
+              argsWired[i] = argTypes[i + 2].toWireType(destructors, args[i]);
               invokerFuncArgs.push(argsWired[i]);
             }
             var rv = cppInvokerFunc(...invokerFuncArgs);
@@ -2699,7 +2644,7 @@ var require_libImage = __commonJS({
                 }
               }
               if (returns) {
-                return argTypes[0]["fromWireType"](rv2);
+                return argTypes[0].fromWireType(rv2);
               }
             }
             return onDone(rv);
@@ -2741,7 +2686,7 @@ var require_libImage = __commonJS({
           }
           return array;
         };
-        var InternalError = Module2["InternalError"] = class InternalError extends Error {
+        var InternalError = class InternalError extends Error {
           constructor(message) {
             super(message);
             this.name = "InternalError";
@@ -2771,7 +2716,7 @@ var require_libImage = __commonJS({
           return func;
         };
         var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
-          signature = readLatin1String(signature);
+          signature = AsciiToString(signature);
           function makeDynCaller() {
             var rtn = getWasmTableEntry(rawFunction);
             return rtn;
@@ -2786,7 +2731,7 @@ var require_libImage = __commonJS({
         }
         var getTypeName = (type) => {
           var ptr = ___getTypeName(type);
-          var rv = readLatin1String(ptr);
+          var rv = AsciiToString(ptr);
           _free(ptr);
           return rv;
         };
@@ -2853,7 +2798,7 @@ var require_libImage = __commonJS({
         };
         var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => {
           var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
-          name = readLatin1String(name);
+          name = AsciiToString(name);
           name = getFunctionName(name);
           rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync);
           exposePublicSymbol(name, function() {
@@ -2866,31 +2811,15 @@ var require_libImage = __commonJS({
           });
         };
         var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
-          name = readLatin1String(name);
-          if (maxRange === -1) {
-            maxRange = 4294967295;
-          }
-          var fromWireType = (value) => value;
-          if (minRange === 0) {
+          name = AsciiToString(name);
+          const isUnsignedType = minRange === 0;
+          let fromWireType = (value) => value;
+          if (isUnsignedType) {
             var bitshift = 32 - 8 * size;
             fromWireType = (value) => value << bitshift >>> bitshift;
+            maxRange = fromWireType(maxRange);
           }
-          var isUnsignedType = name.includes("unsigned");
-          var checkAssertions = (value, toTypeName) => {
-          };
-          var toWireType;
-          if (isUnsignedType) {
-            toWireType = function(destructors, value) {
-              checkAssertions(value, this.name);
-              return value >>> 0;
-            };
-          } else {
-            toWireType = function(destructors, value) {
-              checkAssertions(value, this.name);
-              return value;
-            };
-          }
-          registerType(primitiveType, { name, fromWireType, toWireType, argPackAdvance: GenericWireTypeSize, readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
+          registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => value, 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];
@@ -2900,39 +2829,24 @@ var require_libImage = __commonJS({
             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 });
+          name = AsciiToString(name);
+          registerType(rawType, { name, fromWireType: decodeMemoryView, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true });
         };
         var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
         var __embind_register_std_string = (rawType, name) => {
-          name = readLatin1String(name);
+          name = AsciiToString(name);
           var stdStringIsUTF8 = true;
           registerType(rawType, { name, fromWireType(value) {
             var length = HEAPU32[value >> 2];
             var payload = value + 4;
             var str;
             if (stdStringIsUTF8) {
-              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;
-                }
-              }
+              str = UTF8ToString(payload, length, true);
             } else {
-              var a = new Array(length);
+              str = "";
               for (var i = 0; i < length; ++i) {
-                a[i] = String.fromCharCode(HEAPU8[payload + i]);
+                str += String.fromCharCode(HEAPU8[payload + i]);
               }
-              str = a.join("");
             }
             _free(value);
             return str;
@@ -2973,22 +2887,18 @@ var require_libImage = __commonJS({
               destructors.push(_free, base);
             }
             return base;
-          }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
+          }, readValueFromPointer: readPointer, destructorFunction(ptr) {
             _free(ptr);
           } });
         };
         var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
-        var UTF16ToString = (ptr, maxBytesToRead) => {
-          var endPtr = ptr;
-          var idx = endPtr >> 1;
-          var maxIdx = idx + maxBytesToRead / 2;
-          while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
-          endPtr = idx << 1;
-          if (endPtr - ptr > 32 && UTF16Decoder) return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+        var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => {
+          var idx = ptr >> 1;
+          var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul);
+          if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx));
           var str = "";
-          for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
-            var codeUnit = HEAP16[ptr + i * 2 >> 1];
-            if (codeUnit == 0) break;
+          for (var i = idx; i < endIdx; ++i) {
+            var codeUnit = HEAPU16[i];
             str += String.fromCharCode(codeUnit);
           }
           return str;
@@ -3008,19 +2918,13 @@ var require_libImage = __commonJS({
           return outPtr - startPtr;
         };
         var lengthBytesUTF16 = (str) => str.length * 2;
-        var UTF32ToString = (ptr, maxBytesToRead) => {
-          var i = 0;
+        var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => {
           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);
-            }
+          var startIdx = ptr >> 2;
+          for (var i = 0; !(i >= maxBytesToRead / 4); i++) {
+            var utf32 = HEAPU32[startIdx + i];
+            if (!utf32 && !ignoreNul) break;
+            str += String.fromCodePoint(utf32);
           }
           return str;
         };
@@ -3030,12 +2934,11 @@ var require_libImage = __commonJS({
           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;
+            var codePoint = str.codePointAt(i);
+            if (codePoint > 65535) {
+              i++;
             }
-            HEAP32[outPtr >> 2] = codeUnit;
+            HEAP32[outPtr >> 2] = codePoint;
             outPtr += 4;
             if (outPtr + 4 > endPtr) break;
           }
@@ -3045,44 +2948,29 @@ var require_libImage = __commonJS({
         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;
+            var codePoint = str.codePointAt(i);
+            if (codePoint > 65535) {
+              i++;
+            }
             len += 4;
           }
           return len;
         };
         var __embind_register_std_wstring = (rawType, charSize, name) => {
-          name = readLatin1String(name);
-          var decodeString, encodeString, readCharAt, lengthBytesUTF;
+          name = AsciiToString(name);
+          var decodeString, encodeString, lengthBytesUTF;
           if (charSize === 2) {
             decodeString = UTF16ToString;
             encodeString = stringToUTF16;
             lengthBytesUTF = lengthBytesUTF16;
-            readCharAt = (pointer) => HEAPU16[pointer >> 1];
-          } else if (charSize === 4) {
+          } else {
             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;
-              }
-            }
+            var str = decodeString(value + 4, length * charSize, true);
             _free(value);
             return str;
           }, toWireType: (destructors, value) => {
@@ -3097,45 +2985,100 @@ var require_libImage = __commonJS({
               destructors.push(_free, ptr);
             }
             return ptr;
-          }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
+          }, readValueFromPointer: readPointer, destructorFunction(ptr) {
             _free(ptr);
           } });
         };
         var __embind_register_void = (rawType, name) => {
-          name = readLatin1String(name);
-          registerType(rawType, { isVoid: true, name, argPackAdvance: 0, fromWireType: () => void 0, toWireType: (destructors, o) => void 0 });
+          name = AsciiToString(name);
+          registerType(rawType, { isVoid: true, name, fromWireType: () => void 0, toWireType: (destructors, o) => void 0 });
         };
         var __emscripten_throw_longjmp = () => {
           throw Infinity;
         };
+        var emval_methodCallers = [];
+        var emval_addMethodCaller = (caller) => {
+          var id = emval_methodCallers.length;
+          emval_methodCallers.push(caller);
+          return id;
+        };
+        var requireRegisteredType = (rawType, humanName) => {
+          var impl = registeredTypes[rawType];
+          if (void 0 === impl) {
+            throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+          }
+          return impl;
+        };
+        var emval_lookupTypes = (argCount, argTypes) => {
+          var a = new Array(argCount);
+          for (var i = 0; i < argCount; ++i) {
+            a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2], `parameter ${i}`);
+          }
+          return a;
+        };
+        var emval_returnValue = (toReturnWire, destructorsRef, handle) => {
+          var destructors = [];
+          var result = toReturnWire(destructors, handle);
+          if (destructors.length) {
+            HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
+          }
+          return result;
+        };
         var emval_symbols = {};
         var getStringOrSymbol = (address) => {
           var symbol = emval_symbols[address];
           if (symbol === void 0) {
-            return readLatin1String(address);
+            return AsciiToString(address);
           }
           return symbol;
         };
+        var __emval_create_invoker = (argCount, argTypesPtr, kind) => {
+          var GenericWireTypeSize = 8;
+          var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr);
+          var toReturnWire = retType.toWireType.bind(retType);
+          var argFromPtr = argTypes.map((type) => type.readValueFromPointer.bind(type));
+          argCount--;
+          var argN = new Array(argCount);
+          var invokerFunction = (handle, methodName, destructorsRef, args) => {
+            var offset = 0;
+            for (var i = 0; i < argCount; ++i) {
+              argN[i] = argFromPtr[i](args + offset);
+              offset += GenericWireTypeSize;
+            }
+            var rv;
+            switch (kind) {
+              case 0:
+                rv = Emval.toValue(handle).apply(null, argN);
+                break;
+              case 2:
+                rv = Reflect.construct(Emval.toValue(handle), argN);
+                break;
+              case 3:
+                rv = argN[0];
+                break;
+              case 1:
+                rv = Emval.toValue(handle)[getStringOrSymbol(methodName)](...argN);
+                break;
+            }
+            return emval_returnValue(toReturnWire, destructorsRef, rv);
+          };
+          var functionName = `methodCaller<(${argTypes.map((t) => t.name)}) => ${retType.name}>`;
+          return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+        };
+        var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args);
         var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));
         var __emval_new_object = () => Emval.toHandle({});
+        var __emval_run_destructors = (handle) => {
+          var destructors = Emval.toValue(handle);
+          runDestructors(destructors);
+          __emval_decref(handle);
+        };
         var __emval_set_property = (handle, key, value) => {
           handle = Emval.toValue(handle);
           key = Emval.toValue(key);
           value = Emval.toValue(value);
           handle[key] = value;
         };
-        var requireRegisteredType = (rawType, humanName) => {
-          var impl = registeredTypes[rawType];
-          if (void 0 === impl) {
-            throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
-          }
-          return impl;
-        };
-        var __emval_take_value = (type, arg) => {
-          type = requireRegisteredType(type, "_emval_take_value");
-          var v = type["readValueFromPointer"](arg);
-          return Emval.toHandle(v);
-        };
         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];
@@ -3236,6 +3179,9 @@ var require_libImage = __commonJS({
             handleException(e);
           }
         };
+        function getFullscreenElement() {
+          return document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.webkitCurrentFullScreenElement || document.msFullscreenElement;
+        }
         var safeSetTimeout = (func, timeout) => setTimeout(() => {
           callUserCallback(func);
         }, timeout);
@@ -3253,97 +3199,93 @@ var require_libImage = __commonJS({
           imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
             return !Module2["noImageDecoding"] && /\.(jpg|jpeg|png|bmp|webp)$/i.test(name);
           };
-          imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+          imagePlugin["handle"] = async function imagePlugin_handle(byteArray, name) {
             var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
             if (b.size !== byteArray.length) {
               b = new Blob([new Uint8Array(byteArray).buffer], { type: Browser.getMimetype(name) });
             }
             var url = URL.createObjectURL(b);
-            var img = new Image();
-            img.onload = () => {
-              var canvas2 = document.createElement("canvas");
-              canvas2.width = img.width;
-              canvas2.height = img.height;
-              var ctx = canvas2.getContext("2d");
-              ctx.drawImage(img, 0, 0);
-              Browser.preloadedImages[name] = canvas2;
-              URL.revokeObjectURL(url);
-              onload?.(byteArray);
-            };
-            img.onerror = (event) => {
-              err(`Image ${url} could not be decoded`);
-              onerror?.();
-            };
-            img.src = url;
+            return new Promise((resolve, reject) => {
+              var img = new Image();
+              img.onload = () => {
+                var canvas2 = document.createElement("canvas");
+                canvas2.width = img.width;
+                canvas2.height = img.height;
+                var ctx = canvas2.getContext("2d");
+                ctx.drawImage(img, 0, 0);
+                Browser.preloadedImages[name] = canvas2;
+                URL.revokeObjectURL(url);
+                resolve(byteArray);
+              };
+              img.onerror = (event) => {
+                err(`Image ${url} could not be decoded`);
+                reject();
+              };
+              img.src = url;
+            });
           };
           preloadPlugins.push(imagePlugin);
           var audioPlugin = {};
           audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
             return !Module2["noAudioDecoding"] && name.slice(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 };
           };
-          audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) {
-            var done = false;
-            function finish(audio2) {
-              if (done) return;
-              done = true;
-              Browser.preloadedAudios[name] = audio2;
-              onload?.(byteArray);
-            }
-            var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
-            var url = URL.createObjectURL(b);
-            var audio = new Audio();
-            audio.addEventListener("canplaythrough", () => finish(audio), false);
-            audio.onerror = function audio_onerror(event) {
-              if (done) return;
-              err(`warning: browser could not fully decode audio ${name}, trying slower base64 approach`);
-              function encode64(data) {
-                var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-                var PAD = "=";
-                var ret = "";
-                var leftchar = 0;
-                var leftbits = 0;
-                for (var i = 0; i < data.length; i++) {
-                  leftchar = leftchar << 8 | data[i];
-                  leftbits += 8;
-                  while (leftbits >= 6) {
-                    var curr = leftchar >> leftbits - 6 & 63;
-                    leftbits -= 6;
-                    ret += BASE[curr];
+          audioPlugin["handle"] = async function audioPlugin_handle(byteArray, name) {
+            return new Promise((resolve, reject) => {
+              var done = false;
+              function finish(audio2) {
+                if (done) return;
+                done = true;
+                Browser.preloadedAudios[name] = audio2;
+                resolve(byteArray);
+              }
+              var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+              var url = URL.createObjectURL(b);
+              var audio = new Audio();
+              audio.addEventListener("canplaythrough", () => finish(audio), false);
+              audio.onerror = function audio_onerror(event) {
+                if (done) return;
+                err(`warning: browser could not fully decode audio ${name}, trying slower base64 approach`);
+                function encode64(data) {
+                  var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+                  var PAD = "=";
+                  var ret = "";
+                  var leftchar = 0;
+                  var leftbits = 0;
+                  for (var i = 0; i < data.length; i++) {
+                    leftchar = leftchar << 8 | data[i];
+                    leftbits += 8;
+                    while (leftbits >= 6) {
+                      var curr = leftchar >> leftbits - 6 & 63;
+                      leftbits -= 6;
+                      ret += BASE[curr];
+                    }
                   }
+                  if (leftbits == 2) {
+                    ret += BASE[(leftchar & 3) << 4];
+                    ret += PAD + PAD;
+                  } else if (leftbits == 4) {
+                    ret += BASE[(leftchar & 15) << 2];
+                    ret += PAD;
+                  }
+                  return ret;
                 }
-                if (leftbits == 2) {
-                  ret += BASE[(leftchar & 3) << 4];
-                  ret += PAD + PAD;
-                } else if (leftbits == 4) {
-                  ret += BASE[(leftchar & 15) << 2];
-                  ret += PAD;
-                }
-                return ret;
-              }
-              audio.src = "data:audio/x-" + name.slice(-3) + ";base64," + encode64(byteArray);
-              finish(audio);
-            };
-            audio.src = url;
-            safeSetTimeout(() => {
-              finish(audio);
-            }, 1e4);
+                audio.src = "data:audio/x-" + name.slice(-3) + ";base64," + encode64(byteArray);
+                finish(audio);
+              };
+              audio.src = url;
+              safeSetTimeout(() => {
+                finish(audio);
+              }, 1e4);
+            });
           };
           preloadPlugins.push(audioPlugin);
           function pointerLockChange() {
             var canvas2 = Browser.getCanvas();
-            Browser.pointerLock = document["pointerLockElement"] === canvas2 || document["mozPointerLockElement"] === canvas2 || document["webkitPointerLockElement"] === canvas2 || document["msPointerLockElement"] === canvas2;
+            Browser.pointerLock = document.pointerLockElement === canvas2;
           }
           var canvas = Browser.getCanvas();
           if (canvas) {
-            canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || (() => {
-            });
-            canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || (() => {
-            });
-            canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
             document.addEventListener("pointerlockchange", pointerLockChange, false);
-            document.addEventListener("mozpointerlockchange", pointerLockChange, false);
-            document.addEventListener("webkitpointerlockchange", pointerLockChange, false);
-            document.addEventListener("mspointerlockchange", pointerLockChange, false);
             if (Module2["elementPointerLock"]) {
               canvas.addEventListener("click", (ev) => {
                 if (!Browser.pointerLock && Browser.getCanvas().requestPointerLock) {
@@ -3391,7 +3333,7 @@ var require_libImage = __commonJS({
           function fullscreenChange() {
             Browser.isFullscreen = false;
             var canvasContainer2 = canvas.parentNode;
-            if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer2) {
+            if (getFullscreenElement() === canvasContainer2) {
               canvas.exitFullscreen = Browser.exitFullscreen;
               if (Browser.lockPointer) canvas.requestPointerLock();
               Browser.isFullscreen = true;
@@ -3558,7 +3500,7 @@ var require_libImage = __commonJS({
               h = Math.round(w / Module2["forcedAspectRatio"]);
             }
           }
-          if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") {
+          if (getFullscreenElement() === canvas.parentNode && typeof screen != "undefined") {
             var factor = Math.min(screen.width / w, screen.height / h);
             w = Math.round(w * factor);
             h = Math.round(h * factor);
@@ -3608,8 +3550,8 @@ var require_libImage = __commonJS({
         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;
+          var oldHeapSize = wasmMemory.buffer.byteLength;
+          var pages = (size - oldHeapSize + 65535) / 65536 | 0;
           try {
             wasmMemory.grow(pages);
             updateMemoryViews();
@@ -3642,7 +3584,7 @@ var require_libImage = __commonJS({
         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 lang = (typeof navigator == "object" && navigator.language || "C").replace("-", "_") + ".UTF-8";
             var env = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: lang, _: getExecutableName() };
             for (var x in ENV) {
               if (ENV[x] === void 0) delete env[x];
@@ -3656,27 +3598,24 @@ var require_libImage = __commonJS({
           }
           return getEnvStrings.strings;
         };
-        var stringToAscii = (str, buffer) => {
-          for (var i = 0; i < str.length; ++i) {
-            HEAP8[buffer++] = str.charCodeAt(i);
-          }
-          HEAP8[buffer] = 0;
-        };
         var _environ_get = (__environ, environ_buf) => {
           var bufSize = 0;
-          getEnvStrings().forEach((string, i) => {
+          var envp = 0;
+          for (var string of getEnvStrings()) {
             var ptr = environ_buf + bufSize;
-            HEAPU32[__environ + i * 4 >> 2] = ptr;
-            stringToAscii(string, ptr);
-            bufSize += string.length + 1;
-          });
+            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;
-          strings.forEach((string) => bufSize += string.length + 1);
+          for (var string of strings) {
+            bufSize += lengthBytesUTF8(string) + 1;
+          }
           HEAPU32[penviron_buf_size >> 2] = bufSize;
           return 0;
         };
@@ -3760,26 +3699,37 @@ var require_libImage = __commonJS({
             return e.errno;
           }
         }
+        var createContext = Browser.createContext;
         FS.createPreloadedFile = FS_createPreloadedFile;
+        FS.preloadFile = FS_preloadFile;
         FS.staticInit();
-        MEMFS.doesNotExistError = new FS.ErrnoError(44);
-        MEMFS.doesNotExistError.stack = "<generic error, no stack>";
-        embind_init_charCodes();
-        init_emval();
-        Module2["requestFullscreen"] = Browser.requestFullscreen;
-        Module2["setCanvasSize"] = Browser.setCanvasSize;
-        Module2["getUserMedia"] = Browser.getUserMedia;
-        Module2["createContext"] = Browser.createContext;
-        var wasmImports = { a: ___assert_fail, s: ___cxa_throw, A: ___syscall_fcntl64, N: ___syscall_ioctl, O: ___syscall_openat, Q: __abort_js, E: __embind_register_bigint, Y: __embind_register_bool, W: __embind_register_emval, D: __embind_register_float, q: __embind_register_function, j: __embind_register_integer, f: __embind_register_memory_view, X: __embind_register_std_string, v: __embind_register_std_wstring, Z: __embind_register_void, F: __emscripten_throw_longjmp, i: __emval_decref, o: __emval_new_cstring, da: __emval_new_object, n: __emval_set_property, p: __emval_take_value, H: __localtime_js, I: __tzset_js, P: _emscripten_date_now, x: _emscripten_get_now, V: _emscripten_get_preloaded_image_data_from_FILE, S: _emscripten_has_asyncify, G: _emscripten_resize_heap, R: _emscripten_sleep, K: _environ_get, L: _environ_sizes_get, T: _exit, y: _fd_close, M: _fd_read, J: _fd_seek, z: _fd_write, e: invoke_ii, c: invoke_iii, l: invoke_iiii, m: invoke_iiiii, U: invoke_iiiiii, t: invoke_iiiiiiiii, B: invoke_iiiiiiiiii, aa: invoke_iiiiiiiiiii, ca: invoke_iiiiiiiiiiii, ba: invoke_iiiijj, C: invoke_ji, u: invoke_jiji, d: invoke_vi, g: invoke_vii, h: invoke_viii, b: invoke_viiii, k: invoke_viiiii, r: invoke_viiiiiii, $: invoke_viiiiiiii, w: invoke_viiiiiiiii, _: invoke_viiiiiiiiiii };
-        var wasmExports = await createWasm();
-        var ___wasm_call_ctors = wasmExports["fa"];
-        var _malloc = wasmExports["ha"];
-        var _free = wasmExports["ia"];
-        var ___getTypeName = wasmExports["ja"];
-        var _fileno = wasmExports["ka"];
-        var _setThrew = wasmExports["la"];
-        var __emscripten_stack_restore = wasmExports["ma"];
-        var _emscripten_stack_get_current = wasmExports["na"];
+        {
+          if (Module2["noExitRuntime"]) noExitRuntime = Module2["noExitRuntime"];
+          if (Module2["preloadPlugins"]) preloadPlugins = Module2["preloadPlugins"];
+          if (Module2["print"]) out = Module2["print"];
+          if (Module2["printErr"]) err = Module2["printErr"];
+          if (Module2["wasmBinary"]) wasmBinary = Module2["wasmBinary"];
+          if (Module2["arguments"]) arguments_ = Module2["arguments"];
+          if (Module2["thisProgram"]) thisProgram = Module2["thisProgram"];
+          if (Module2["preInit"]) {
+            if (typeof Module2["preInit"] == "function") Module2["preInit"] = [Module2["preInit"]];
+            while (Module2["preInit"].length > 0) {
+              Module2["preInit"].shift()();
+            }
+          }
+        }
+        Module2["createContext"] = createContext;
+        var _malloc, _free, ___getTypeName, _fileno, _setThrew, __emscripten_stack_restore, _emscripten_stack_get_current;
+        function assignWasmExports(wasmExports2) {
+          _malloc = wasmExports2["ja"];
+          _free = wasmExports2["ka"];
+          ___getTypeName = wasmExports2["la"];
+          _fileno = wasmExports2["ma"];
+          _setThrew = wasmExports2["na"];
+          __emscripten_stack_restore = wasmExports2["oa"];
+          _emscripten_stack_get_current = wasmExports2["pa"];
+        }
+        var wasmImports = { a: ___assert_fail, p: ___cxa_throw, x: ___syscall_fcntl64, P: ___syscall_ioctl, Q: ___syscall_openat, S: __abort_js, D: __embind_register_bigint, _: __embind_register_bool, Y: __embind_register_emval, B: __embind_register_float, n: __embind_register_function, i: __embind_register_integer, f: __embind_register_memory_view, Z: __embind_register_std_string, s: __embind_register_std_wstring, $: __embind_register_void, H: __emscripten_throw_longjmp, G: __emval_create_invoker, j: __emval_decref, E: __emval_invoke, y: __emval_new_cstring, fa: __emval_new_object, C: __emval_run_destructors, v: __emval_set_property, J: __localtime_js, K: __tzset_js, R: _emscripten_date_now, t: _emscripten_get_now, X: _emscripten_get_preloaded_image_data_from_FILE, U: _emscripten_has_asyncify, I: _emscripten_resize_heap, T: _emscripten_sleep, M: _environ_get, N: _environ_sizes_get, V: _exit, u: _fd_close, O: _fd_read, L: _fd_seek, w: _fd_write, e: invoke_ii, c: invoke_iii, l: invoke_iiii, m: invoke_iiiii, W: invoke_iiiiii, q: invoke_iiiiiiiii, z: invoke_iiiiiiiiii, ca: invoke_iiiiiiiiiii, ea: invoke_iiiiiiiiiiii, da: invoke_iiiijj, A: invoke_ji, r: invoke_jiji, d: invoke_vi, g: invoke_vii, h: invoke_viii, b: invoke_viiii, k: invoke_viiiii, o: invoke_viiiiiii, ba: invoke_viiiiiiii, F: invoke_viiiiiiiii, aa: invoke_viiiiiiiiiii };
         function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
           var sp = stackSave();
           try {
@@ -4006,7 +3956,7 @@ var require_libImage = __commonJS({
             Module2["calledRun"] = true;
             if (ABORT) return;
             initRuntime();
-            readyPromiseResolve(Module2);
+            readyPromiseResolve?.(Module2);
             Module2["onRuntimeInitialized"]?.();
             postRun();
           }
@@ -4020,22 +3970,25 @@ var require_libImage = __commonJS({
             doRun();
           }
         }
-        if (Module2["preInit"]) {
-          if (typeof Module2["preInit"] == "function") Module2["preInit"] = [Module2["preInit"]];
-          while (Module2["preInit"].length > 0) {
-            Module2["preInit"].pop()();
-          }
-        }
+        var wasmExports;
+        wasmExports = await createWasm();
         run();
-        moduleRtn = readyPromise;
+        if (runtimeInitialized) {
+          moduleRtn = Module2;
+        } else {
+          moduleRtn = new Promise((resolve, reject) => {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+          });
+        }
+        ;
         return moduleRtn;
       };
     })();
     if (typeof exports2 === "object" && typeof module2 === "object") {
       module2.exports = Module;
       module2.exports.default = Module;
-    } else if (typeof define === "function" && define["amd"])
-      define([], () => Module);
+    } else if (typeof define === "function" && define["amd"]) define([], () => Module);
   }
 });
 
@@ -4050,17 +4003,18 @@ var require_optimizeImage = __commonJS({
       releaseResult();
       return r;
     };
-    var _optimizeImage = async ({ image, width = 0, height = 0, quality = 100, format = "avif", speed = 6, libImage }) => (0, exports2._optimizeImageExt)({
+    var _optimizeImage = async ({ image, width = 0, height = 0, quality = 100, format = "avif", speed = 6, filter = true, libImage }) => (0, exports2._optimizeImageExt)({
       image,
       width,
       height,
       quality,
       format,
       speed,
+      filter,
       libImage
     }).then((r) => r?.data);
     exports2._optimizeImage = _optimizeImage;
-    var _optimizeImageExt = async ({ image, width = 0, height = 0, quality = 100, format = "avif", speed = 6, libImage }) => libImage.then(({ optimize, releaseResult }) => result(optimize(image, width, height, quality, format, speed), releaseResult));
+    var _optimizeImageExt = async ({ image, width = 0, height = 0, quality = 100, format = "avif", speed = 6, filter = true, libImage }) => libImage.then(({ optimize, releaseResult }) => result(optimize(image, width, height, quality, format, speed, filter), releaseResult));
     exports2._optimizeImageExt = _optimizeImageExt;
   }
 });