wasm-image-optimization 1.4.4 → 1.4.6

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

@@ -4,65 +4,200 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
-// node_modules/.pnpm/worker-lib@2.0.8/node_modules/worker-lib/dist/cjs/node.js
-var require_node = __commonJS({
-  "node_modules/.pnpm/worker-lib@2.0.8/node_modules/worker-lib/dist/cjs/node.js"(exports2) {
+// node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/common.js
+var require_common = __commonJS({
+  "node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/common.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.initWorker = exports2.createWorker = void 0;
-    var node_worker_threads_1 = require("node:worker_threads");
-    var init = (worker) => {
-      return new Promise((resolve) => {
-        worker.once("message", () => {
-          resolve(worker);
-        });
-      });
+    exports2.createRegistry = exports2.getTransferables = exports2.isPlainObject = exports2.isPlaceholder = exports2.FUNCTION_PLACEHOLDER = void 0;
+    exports2.FUNCTION_PLACEHOLDER = "__worker_lib_function__";
+    var isPlaceholder = (v) => v && typeof v === "object" && exports2.FUNCTION_PLACEHOLDER in v;
+    exports2.isPlaceholder = isPlaceholder;
+    var isPlainObject = (v) => {
+      return v && typeof v === "object" && Object.prototype.toString.call(v) === "[object Object]" && !(v instanceof Uint8Array) && !(v instanceof ArrayBuffer) && !ArrayBuffer.isView(v);
     };
-    var exec = (worker, name, ...value) => {
+    exports2.isPlainObject = isPlainObject;
+    var getTransferables = (v, result = []) => {
+      if (v instanceof ArrayBuffer) {
+        result.push(v);
+      } else if (ArrayBuffer.isView(v)) {
+        result.push(v.buffer);
+      } else if (Array.isArray(v)) {
+        for (const item of v)
+          (0, exports2.getTransferables)(item, result);
+      } else if (v && typeof v === "object") {
+        for (const key in v)
+          (0, exports2.getTransferables)(v[key], result);
+      }
+      return result;
+    };
+    exports2.getTransferables = getTransferables;
+    var createRegistry = () => {
+      const callbacks = /* @__PURE__ */ new Map();
+      const callbackProxies = /* @__PURE__ */ new Map();
+      const registerCallback = (requestId, fn) => {
+        const id = `${requestId}:${Math.random().toString(36).slice(2)}`;
+        callbacks.set(id, fn);
+        return id;
+      };
+      const clearCallbacks = (requestId) => {
+        for (const key of callbacks.keys()) {
+          if (key.startsWith(`${requestId}:`)) {
+            callbacks.delete(key);
+          }
+        }
+        for (const key of callbackProxies.keys()) {
+          if (key.startsWith(`${requestId}:`)) {
+            callbackProxies.delete(key);
+          }
+        }
+      };
+      const transformArgs = (requestId, args) => {
+        if (typeof args === "function") {
+          return { [exports2.FUNCTION_PLACEHOLDER]: registerCallback(requestId, args) };
+        }
+        if (ArrayBuffer.isView(args) || args instanceof ArrayBuffer) {
+          return args;
+        }
+        if (Array.isArray(args)) {
+          return args.map((v) => transformArgs(requestId, v));
+        }
+        if ((0, exports2.isPlainObject)(args)) {
+          const result = {};
+          for (const key in args) {
+            result[key] = transformArgs(requestId, args[key]);
+          }
+          return result;
+        }
+        return args;
+      };
+      const resolveArgs = (requestId, args, createProxy) => {
+        if ((0, exports2.isPlaceholder)(args)) {
+          return createProxy(args[exports2.FUNCTION_PLACEHOLDER]);
+        }
+        if (Array.isArray(args)) {
+          return args.map((v) => resolveArgs(requestId, v, createProxy));
+        }
+        if ((0, exports2.isPlainObject)(args)) {
+          const result = {};
+          for (const key in args) {
+            result[key] = resolveArgs(requestId, args[key], createProxy);
+          }
+          return result;
+        }
+        return args;
+      };
+      return {
+        callbacks,
+        callbackProxies,
+        registerCallback,
+        clearCallbacks,
+        transformArgs,
+        resolveArgs
+      };
+    };
+    exports2.createRegistry = createRegistry;
+  }
+});
+
+// node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/pool.js
+var require_pool = __commonJS({
+  "node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/pool.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.initUniversalWorker = exports2.createWorkerPool = exports2.exec = void 0;
+    var common_1 = require_common();
+    var requestIdCounter = 0;
+    var exec = (worker, name, registry, ...args) => {
+      const requestId = requestIdCounter++;
+      const { callbacks, callbackProxies, clearCallbacks, transformArgs, resolveArgs } = registry;
       return new Promise((resolve, reject) => {
-        const p = async (data) => {
-          switch (data.type) {
-            case "callback":
-              const r = value[data.payload.index](data.payload.value);
+        const createProxy = (callbackId) => {
+          const key = `${requestId}:${callbackId}`;
+          if (callbackProxies.has(key))
+            return callbackProxies.get(key);
+          const proxy = (...proxyArgs) => {
+            const callId = Math.random().toString(36).slice(2);
+            return new Promise((res) => {
+              const handler = (data) => {
+                if (data.type === "callback_result" && data.payload.id === callId) {
+                  worker.removeEventListener("message", handler);
+                  res(resolveArgs(requestId, data.payload.result, createProxy));
+                }
+              };
+              worker.addEventListener("message", handler);
+              const transformedProxyArgs = transformArgs(requestId, proxyArgs);
               worker.postMessage({
-                type: "callback_result",
-                payload: { id: data.payload.id, result: await r }
-              });
-              break;
-            case "result":
-              worker.removeListener("message", p);
-              resolve(data.payload);
-              break;
-            case "error":
-              worker.removeListener("message", p);
-              reject(data.payload);
-              break;
+                type: "callback_call",
+                payload: {
+                  id: requestId,
+                  callbackId,
+                  args: transformedProxyArgs,
+                  callId
+                }
+              }, (0, common_1.getTransferables)(transformedProxyArgs));
+            });
+          };
+          callbackProxies.set(key, proxy);
+          return proxy;
+        };
+        const messageHandler = async (data) => {
+          if (!data || typeof data !== "object")
+            return;
+          const payload = data.payload;
+          if (payload?.id !== requestId)
+            return;
+          if (data.type === "result") {
+            worker.removeEventListener("message", messageHandler);
+            const result = resolveArgs(requestId, payload.result, createProxy);
+            clearCallbacks(requestId);
+            resolve(result);
+          } else if (data.type === "error") {
+            worker.removeEventListener("message", messageHandler);
+            clearCallbacks(requestId);
+            reject(payload.error);
+          } else if (data.type === "callback_call") {
+            const { callbackId, args: callArgs, callId } = payload;
+            const fn = callbacks.get(callbackId);
+            if (fn) {
+              try {
+                const result = await fn(...resolveArgs(requestId, callArgs, createProxy));
+                const transformedResult = transformArgs(requestId, result);
+                worker.postMessage({
+                  type: "callback_result",
+                  payload: { id: callId, result: transformedResult }
+                }, (0, common_1.getTransferables)(transformedResult));
+              } catch (e) {
+                console.error("[worker-lib] Callback execution failed:", e);
+              }
+            }
           }
         };
-        worker.addListener("message", p);
+        worker.addEventListener("message", messageHandler);
+        const transformedArgs = transformArgs(requestId, args);
         worker.postMessage({
           type: "function",
           payload: {
+            id: requestId,
             name,
-            value: value.map((v) => !(typeof v === "function") && v),
-            callback: value.map((v) => typeof v === "function")
+            args: transformedArgs
           }
-        });
+        }, (0, common_1.getTransferables)(transformedArgs));
       });
     };
-    var createWorker = (builder, limit = 4) => {
+    exports2.exec = exec;
+    var createWorkerPool = (builder, limit = 4) => {
       let workers = Array(limit).fill(void 0).map(() => ({}));
       const emptyWaits = [];
       let isEmptyWait = false;
+      const registry = (0, common_1.createRegistry)();
       const getResolver = async () => {
         while (true) {
           const target = workers.find(({ resultResolver }) => !resultResolver);
           if (target) {
             target.resultResolver = Promise.withResolvers();
             if (!target.worker) {
-              const result = builder();
-              const worker = result instanceof node_worker_threads_1.Worker ? result : new node_worker_threads_1.Worker(result);
-              target.worker = await init(worker);
+              target.worker = await builder();
             }
             return target;
           }
@@ -74,7 +209,7 @@ var require_node = __commonJS({
         const { resultResolver } = target;
         if (!resultResolver)
           throw new Error("Unexpected error");
-        exec(target.worker, name, ...value).then(resultResolver.resolve).catch(resultResolver.reject).finally(() => {
+        (0, exports2.exec)(target.worker, name, registry, ...value).then(resultResolver.resolve).catch(resultResolver.reject).finally(() => {
           target.resultResolver = void 0;
         });
         return resultResolver.promise;
@@ -82,9 +217,7 @@ var require_node = __commonJS({
       const launchWorker = async () => {
         return Promise.all(workers.map(async (target) => {
           if (!target.worker) {
-            const result = builder();
-            const worker = result instanceof node_worker_threads_1.Worker ? result : new node_worker_threads_1.Worker(result);
-            target.worker = await init(worker);
+            target.worker = await builder();
           }
         }));
       };
@@ -115,58 +248,155 @@ var require_node = __commonJS({
         return p.promise;
       };
       const close = () => {
-        for (const { worker } of workers) {
-          worker?.terminate();
+        for (const target of workers) {
+          target.worker?.terminate();
+          target.worker = void 0;
+          target.resultResolver = void 0;
         }
       };
-      const setLimit = (limit2) => {
+      const setLimit = (newLimit) => {
         workers.forEach((w) => w.worker?.terminate());
-        workers = Array(limit2).fill(void 0).map(() => ({}));
+        workers = Array(newLimit).fill(void 0).map(() => ({}));
       };
       return { execute, waitAll, waitReady, close, setLimit, launchWorker };
     };
-    exports2.createWorker = createWorker;
-    var initWorker = (WorkerProc) => {
-      const worker = node_worker_threads_1.parentPort;
-      if (!worker) {
-        throw new Error("This is not a worker thread");
-      }
-      worker.addListener("message", async (data) => {
+    exports2.createWorkerPool = createWorkerPool;
+    var initUniversalWorker = (worker, WorkerProc) => {
+      const { callbacks, callbackProxies, registerCallback, clearCallbacks, transformArgs, resolveArgs } = (0, common_1.createRegistry)();
+      const createProxy = (callbackId, requestId) => {
+        const key = `${requestId}:${callbackId}`;
+        if (callbackProxies.has(key))
+          return callbackProxies.get(key);
+        const proxy = (...proxyArgs) => {
+          const callId = Math.random().toString(36).slice(2);
+          return new Promise((res) => {
+            const handler = (data) => {
+              if (data.type === "callback_result" && data.payload.id === callId) {
+                worker.removeEventListener("message", handler);
+                res(resolveArgs(requestId, data.payload.result, (cbId) => createProxy(cbId, requestId)));
+              }
+            };
+            worker.addEventListener("message", handler);
+            const transformedArgs = transformArgs(requestId, proxyArgs);
+            worker.postMessage({
+              type: "callback_call",
+              payload: {
+                id: requestId,
+                callbackId,
+                args: transformedArgs,
+                callId
+              }
+            }, (0, common_1.getTransferables)(transformedArgs));
+          });
+        };
+        callbackProxies.set(key, proxy);
+        return proxy;
+      };
+      worker.addEventListener("message", async (data) => {
+        if (!data)
+          return;
         if (data.type === "function") {
-          const { name, value, callback } = data.payload;
+          const { id, name, args } = data.payload;
           const proc = WorkerProc[name];
           if (proc) {
             try {
-              const params = value.map((v, index) => callback[index] ? (...params2) => callbackProc(worker, index, params2) : v);
+              const resolvedArgs = resolveArgs(id, args, (cbId) => createProxy(cbId, id));
+              const result = await proc(...resolvedArgs);
+              const transformedResult = transformArgs(id, result);
               worker.postMessage({
                 type: "result",
-                payload: await proc(...params)
+                payload: { id, result: transformedResult }
+              }, (0, common_1.getTransferables)(transformedResult));
+              clearCallbacks(id);
+            } catch (error) {
+              worker.postMessage({
+                type: "error",
+                payload: { id, error: String(error) }
               });
+              clearCallbacks(id);
+            }
+          }
+        } else if (data.type === "callback_call") {
+          const { id, callbackId, args, callId } = data.payload;
+          const fn = callbacks.get(callbackId);
+          if (fn) {
+            try {
+              const result = await fn(...resolveArgs(id, args, (cbId) => createProxy(cbId, id)));
+              const transformedResult = transformArgs(id, result);
+              worker.postMessage({
+                type: "callback_result",
+                payload: { id: callId, result: transformedResult }
+              }, (0, common_1.getTransferables)(transformedResult));
             } catch (e) {
-              worker.postMessage({ type: "error", payload: String(e) });
+              console.error("[worker-lib] Worker-side callback failed:", e);
             }
           }
         }
       });
-      worker.postMessage(void 0);
+      worker.postMessage("ready");
       return WorkerProc;
     };
-    exports2.initWorker = initWorker;
-    var callbackProc = (worker, index, params) => {
-      const id = WorkerValue.id++;
+    exports2.initUniversalWorker = initUniversalWorker;
+  }
+});
+
+// node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/node.js
+var require_node = __commonJS({
+  "node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/cjs/node.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.initWorker = exports2.createWorker = exports2.Worker = void 0;
+    var node_worker_threads_1 = require("node:worker_threads");
+    var pool_1 = require_pool();
+    var node_worker_threads_2 = require("node:worker_threads");
+    Object.defineProperty(exports2, "Worker", { enumerable: true, get: function() {
+      return node_worker_threads_2.Worker;
+    } });
+    var wrapWorker = (worker) => ({
+      postMessage: (message, transfer) => worker.postMessage(message, transfer),
+      addEventListener: (type, listener) => {
+        worker.on(type, listener);
+      },
+      removeEventListener: (type, listener) => {
+        worker.removeListener(type, listener);
+      },
+      terminate: () => worker.terminate()
+    });
+    var init = (worker) => {
       return new Promise((resolve) => {
-        worker.once("message", (data) => {
-          if (data.type === "callback_result" && data.payload.id === id) {
-            resolve(data.payload.result);
-          }
-        });
-        worker.postMessage({
-          type: "callback",
-          payload: { id, index, value: params }
+        worker.once("message", () => {
+          resolve(worker);
         });
       });
     };
-    var WorkerValue = { id: 0, promises: {} };
+    var createWorker = (builder, limit = 4) => {
+      return (0, pool_1.createWorkerPool)(async () => {
+        const result = builder();
+        const worker = result instanceof node_worker_threads_1.Worker ? result : new node_worker_threads_1.Worker(result);
+        await init(worker);
+        return wrapWorker(worker);
+      }, limit);
+    };
+    exports2.createWorker = createWorker;
+    var initWorker = (WorkerProc) => {
+      const worker = node_worker_threads_1.parentPort;
+      if (!worker) {
+        throw new Error("This is not a worker thread");
+      }
+      const universalWorker = {
+        postMessage: (message, transfer) => worker.postMessage(message, transfer),
+        addEventListener: (type, listener) => {
+          worker.on(type, listener);
+        },
+        removeEventListener: (type, listener) => {
+          worker.removeListener(type, listener);
+        },
+        terminate: () => {
+        }
+      };
+      return (0, pool_1.initUniversalWorker)(universalWorker, WorkerProc);
+    };
+    exports2.initWorker = initWorker;
   }
 });
 
@@ -1008,7 +1238,7 @@ var require_libImage = __commonJS({
         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 {
+        var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, ErrnoError: class {
           name = "ErrnoError";
           constructor(errno) {
             this.errno = errno;
@@ -1220,9 +1450,11 @@ var require_libImage = __commonJS({
           }
           if (perms.includes("r") && !(node.mode & 292)) {
             return 2;
-          } else if (perms.includes("w") && !(node.mode & 146)) {
+          }
+          if (perms.includes("w") && !(node.mode & 146)) {
             return 2;
-          } else if (perms.includes("x") && !(node.mode & 73)) {
+          }
+          if (perms.includes("x") && !(node.mode & 73)) {
             return 2;
           }
           return 0;
@@ -1260,10 +1492,8 @@ var require_libImage = __commonJS({
             if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
               return 10;
             }
-          } else {
-            if (FS.isDir(node.mode)) {
-              return 31;
-            }
+          } else if (FS.isDir(node.mode)) {
+            return 31;
           }
           return 0;
         }, mayOpen(node, flags) {
@@ -1272,12 +1502,14 @@ var require_libImage = __commonJS({
           }
           if (FS.isLink(node.mode)) {
             return 32;
-          } else if (FS.isDir(node.mode)) {
-            if (FS.flagsToPermissionString(flags) !== "r" || flags & (512 | 64)) {
+          }
+          var mode = FS.flagsToPermissionString(flags);
+          if (FS.isDir(node.mode)) {
+            if (mode !== "r" || flags & (512 | 64)) {
               return 31;
             }
           }
-          return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+          return FS.nodePermissions(node, mode);
         }, checkOpExists(op, err2) {
           if (!op) {
             throw new FS.ErrnoError(err2);
@@ -1747,11 +1979,6 @@ var require_libImage = __commonJS({
           if (created) {
             FS.chmod(node, mode & 511);
           }
-          if (Module2["logReadFiles"] && !(flags & 1)) {
-            if (!(path in FS.readFiles)) {
-              FS.readFiles[path] = 1;
-            }
-          }
           return stream;
         }, close(stream) {
           if (FS.isClosed(stream)) {
@@ -3173,10 +3400,11 @@ var require_libImage = __commonJS({
             return;
           }
           try {
-            func();
-            maybeExit();
+            return func();
           } catch (e) {
             handleException(e);
+          } finally {
+            maybeExit();
           }
         };
         function getFullscreenElement() {
@@ -3196,10 +3424,8 @@ var require_libImage = __commonJS({
           if (Browser.initted) return;
           Browser.initted = true;
           var imagePlugin = {};
-          imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
-            return !Module2["noImageDecoding"] && /\.(jpg|jpeg|png|bmp|webp)$/i.test(name);
-          };
-          imagePlugin["handle"] = async function imagePlugin_handle(byteArray, name) {
+          imagePlugin["canHandle"] = (name) => !Module2["noImageDecoding"] && /\.(jpg|jpeg|png|bmp|webp)$/i.test(name);
+          imagePlugin["handle"] = async (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) });
@@ -3226,58 +3452,54 @@ var require_libImage = __commonJS({
           };
           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"] = 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;
+          audioPlugin["canHandle"] = (name) => !Module2["noAudioDecoding"] && name.slice(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 };
+          audioPlugin["handle"] = async (byteArray, name) => 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 = (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];
                   }
-                  return ret;
                 }
-                audio.src = "data:audio/x-" + name.slice(-3) + ";base64," + encode64(byteArray);
-                finish(audio);
-              };
-              audio.src = url;
-              safeSetTimeout(() => {
-                finish(audio);
-              }, 1e4);
-            });
-          };
+                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);
+          });
           preloadPlugins.push(audioPlugin);
           function pointerLockChange() {
             var canvas2 = Browser.getCanvas();