opfs-worker 0.2.5 → 0.2.6

package/dist/index.js

@@ -1,21 +1,21 @@
 import { wrap as i, proxy as o } from "comlink";
-import { D as d, F as p, O as u, b as y, a as w, P as m, c as g, S as v, T as E, e as F, k as S, d as b, l as P, h as T, o as x, f as A, m as O, g as D, j as _, n as I, i as C, r as k, s as U, w as R } from "./helpers-3TGPHd1h.js";
+import { D as d, F as p, O as u, b as y, a as w, P as m, c as g, S as v, T as F, e as S, k as E, d as b, l as P, h as x, o as T, f as A, m as O, g as D, j as _, n as I, i as C, r as k, s as U, w as R } from "./helpers-C0nyU6hv.js";
 const a = `/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), D = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (e) => typeof e == "object" && e !== null || typeof e == "function", W = {
+const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), D = Symbol("Comlink.finalizer"), E = Symbol("Comlink.thrown"), $ = (e) => typeof e == "object" && e !== null || typeof e == "function", W = {
   canHandle: (e) => $(e) && e[H],
   serialize(e) {
     const { port1: t, port2: r } = new MessageChannel();
-    return P(e, t), [r, [r]];
+    return I(e, t), [r, [r]];
   },
   deserialize(e) {
     return e.start(), Y(e);
   }
 }, j = {
-  canHandle: (e) => $(e) && p in e,
+  canHandle: (e) => $(e) && E in e,
   serialize({ value: e }) {
     let t;
     return e instanceof Error ? t = {
@@ -30,7 +30,7 @@ const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("C
   deserialize(e) {
     throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
   }
-}, U = /* @__PURE__ */ new Map([
+}, z = /* @__PURE__ */ new Map([
   ["proxy", W],
   ["throw", j]
 ]);
@@ -40,7 +40,7 @@ function V(e, t) {
       return !0;
   return !1;
 }
-function P(e, t = globalThis, r = ["*"]) {
+function I(e, t = globalThis, r = ["*"]) {
   t.addEventListener("message", function n(i) {
     if (!i || !i.data)
       return;
@@ -71,7 +71,7 @@ function P(e, t = globalThis, r = ["*"]) {
         case "ENDPOINT":
           {
             const { port1: f, port2: g } = new MessageChannel();
-            P(e, g), h = J(f, [f]);
+            I(e, g), h = J(f, [f]);
           }
           break;
         case "RELEASE":
@@ -81,15 +81,15 @@ function P(e, t = globalThis, r = ["*"]) {
           return;
       }
     } catch (u) {
-      h = { value: u, [p]: 0 };
+      h = { value: u, [E]: 0 };
     }
-    Promise.resolve(h).catch((u) => ({ value: u, [p]: 0 })).then((u) => {
+    Promise.resolve(h).catch((u) => ({ value: u, [E]: 0 })).then((u) => {
       const [w, f] = A(u);
       t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f), s === "RELEASE" && (t.removeEventListener("message", n), L(t), D in e && typeof e[D] == "function" && e[D]());
     }).catch((u) => {
       const [w, f] = A({
         value: new TypeError("Unserializable return value"),
-        [p]: 0
+        [E]: 0
       });
       t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f);
     });
@@ -114,13 +114,13 @@ function Y(e, t) {
       } finally {
         r.delete(a.id);
       }
-  }), I(e, r, [], t);
+  }), M(e, r, [], t);
 }
-function E(e) {
+function p(e) {
   if (e)
     throw new Error("Proxy has been released and is not useable");
 }
-function z(e) {
+function U(e) {
   return d(e, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
@@ -129,7 +129,7 @@ function z(e) {
 }
 const F = /* @__PURE__ */ new WeakMap(), S = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
   const t = (F.get(e) || 0) - 1;
-  F.set(e, t), t === 0 && z(e);
+  F.set(e, t), t === 0 && U(e);
 });
 function X(e, t) {
   const r = (F.get(t) || 0) + 1;
@@ -138,14 +138,14 @@ function X(e, t) {
 function q(e) {
   S && S.unregister(e);
 }
-function I(e, t, r = [], n = function() {
+function M(e, t, r = [], n = function() {
 }) {
   let i = !1;
   const a = new Proxy(n, {
     get(s, o) {
-      if (E(i), o === B)
+      if (p(i), o === B)
         return () => {
-          q(a), z(e), t.clear(), i = !0;
+          q(a), U(e), t.clear(), i = !0;
         };
       if (o === "then") {
         if (r.length === 0)
@@ -156,10 +156,10 @@ function I(e, t, r = [], n = function() {
         }).then(y);
         return l.then.bind(l);
       }
-      return I(e, t, [...r, o]);
+      return M(e, t, [...r, o]);
     },
     set(s, o, l) {
-      E(i);
+      p(i);
       const [h, u] = A(l);
       return d(e, t, {
         type: "SET",
@@ -168,14 +168,14 @@ function I(e, t, r = [], n = function() {
       }, u).then(y);
     },
     apply(s, o, l) {
-      E(i);
+      p(i);
       const h = r[r.length - 1];
       if (h === R)
         return d(e, t, {
           type: "ENDPOINT"
         }).then(y);
       if (h === "bind")
-        return I(e, t, r.slice(0, -1));
+        return M(e, t, r.slice(0, -1));
       const [u, w] = N(l);
       return d(e, t, {
         type: "APPLY",
@@ -184,7 +184,7 @@ function I(e, t, r = [], n = function() {
       }, w).then(y);
     },
     construct(s, o) {
-      E(i);
+      p(i);
       const [l, h] = N(o);
       return d(e, t, {
         type: "CONSTRUCT",
@@ -210,7 +210,7 @@ function Q(e) {
   return Object.assign(e, { [H]: !0 });
 }
 function A(e) {
-  for (const [t, r] of U)
+  for (const [t, r] of z)
     if (r.canHandle(e)) {
       const [n, i] = r.serialize(e);
       return [
@@ -233,7 +233,7 @@ function A(e) {
 function y(e) {
   switch (e.type) {
     case "HANDLER":
-      return U.get(e.name).deserialize(e.value);
+      return z.get(e.name).deserialize(e.value);
     case "RAW":
       return e.value;
   }
@@ -352,18 +352,18 @@ function ot() {
 function m(e) {
   return Array.isArray(e) ? e : e.split("/").filter(Boolean);
 }
-function x(e) {
+function P(e) {
   return typeof e == "string" ? e ?? "/" : \`/\${e.join("/")}\`;
 }
-function C(e) {
+function b(e) {
   const t = m(e);
   return t[t.length - 1] || "";
 }
-function M(e) {
+function x(e) {
   const t = m(e);
-  return t.pop(), x(t);
+  return t.pop(), P(t);
 }
-function b(e) {
+function C(e) {
   return !e || e === "/" ? "/" : e.startsWith("/") ? e : \`/\${e}\`;
 }
 function ct(e) {
@@ -376,7 +376,7 @@ function ct(e) {
         r.pop();
       } else
         r.push(n);
-  return x(r);
+  return P(r);
 }
 function lt(e, t = "utf-8") {
   return typeof e == "string" ? et(e, t) : e instanceof Uint8Array ? e : new Uint8Array(e);
@@ -408,14 +408,11 @@ async function v(e, t, r, n = {}) {
       }
   }
 }
-async function ut(e, t = "SHA-1") {
-  e instanceof File && (e = await e.arrayBuffer());
-  try {
-    const r = new Uint8Array(e), n = await crypto.subtle.digest(t, r);
-    return Array.from(new Uint8Array(n)).map((a) => a.toString(16).padStart(2, "0")).join("");
-  } catch (r) {
-    throw console.warn(\`Failed to calculate \${t} hash:\`, r), r;
-  }
+async function ut(e, t = "SHA-1", r = 50 * 1024 * 1024) {
+  if (e instanceof File && (e = await e.arrayBuffer()), e.byteLength > r)
+    throw new Error(\`File size \${e.byteLength} bytes exceeds maximum allowed size \${r} bytes\`);
+  const n = new Uint8Array(e), i = await crypto.subtle.digest(t, n);
+  return Array.from(new Uint8Array(i)).map((s) => s.toString(16).padStart(2, "0")).join("");
 }
 async function ft(e) {
   const t = await e.arrayBuffer();
@@ -430,14 +427,16 @@ class wt {
   watchers = /* @__PURE__ */ new Map();
   /** Interval handle for polling watched paths */
   watchTimer = null;
-  /** Polling interval in milliseconds */
-  watchInterval = 1e3;
   /** Flag to avoid concurrent scans */
   scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
-  /** Hash algorithm for file hashing (null means no hashing) */
-  hashAlgorithm = null;
+  /** Configuration options */
+  options = {
+    watchInterval: 1e3,
+    maxFileSize: 50 * 1024 * 1024,
+    hashAlgorithm: null
+  };
   /**
    * Notify about internal changes to the file system
    * 
@@ -451,7 +450,7 @@ class wt {
     if (!this.watchCallback)
       return;
     let r;
-    if (this.hashAlgorithm && !t.isDirectory && t.type !== "removed")
+    if (this.options.hashAlgorithm && !t.isDirectory && t.type !== "removed")
       try {
         const n = await this.stat(t.path);
         n.isFile && n.hash && (r = n.hash);
@@ -471,6 +470,7 @@ class wt {
    * @param options - Optional configuration options
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
+   * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t, r) {
@@ -519,14 +519,15 @@ class wt {
     this.watchCallback = t;
   }
   /**
-   * Set configuration options for the file system
+   * Update configuration options
    * 
    * @param options - Configuration options to update
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
+   * @param options.maxFileSize - Maximum file size for hashing in bytes
    */
   setOptions(t) {
-    t.watchInterval !== void 0 && (this.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.hashAlgorithm = t.hashAlgorithm);
+    t.watchInterval !== void 0 && (this.options.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize);
   }
   /**
    * Automatically mount the OPFS root if not already mounted
@@ -740,7 +741,7 @@ class wt {
         a = await a.getDirectoryHandle(o, { create: n || s === i.length - 1 });
       } catch (l) {
         throw l.name === "NotFoundError" ? new c(
-          \`Parent directory does not exist: \${x(i.slice(0, s + 1))}\`,
+          \`Parent directory does not exist: \${P(i.slice(0, s + 1))}\`,
           "ENOENT"
         ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${o}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
       }
@@ -779,7 +780,7 @@ class wt {
         isFile: !1,
         isDirectory: !0
       };
-    const r = C(t), n = await this.getDirectoryHandle(M(t), !1), i = this.hashAlgorithm !== null;
+    const r = b(t), n = await this.getDirectoryHandle(x(t), !1), i = this.options.hashAlgorithm !== null;
     try {
       const s = await (await n.getFileHandle(r, { create: !1 })).getFile(), o = {
         kind: "file",
@@ -789,9 +790,9 @@ class wt {
         isFile: !0,
         isDirectory: !1
       };
-      if (i && this.hashAlgorithm)
+      if (i && this.options.hashAlgorithm)
         try {
-          const l = await ut(s, this.hashAlgorithm);
+          const l = await ut(s, this.options.hashAlgorithm, this.options.maxFileSize);
           o.hash = l;
         } catch (l) {
           console.warn(\`Failed to calculate hash for \${t}:\`, l);
@@ -853,10 +854,10 @@ class wt {
   async exists(t) {
     if (await this.ensureMounted(), t === "/")
       return !0;
-    const r = C(t);
+    const r = b(t);
     let n = null;
     try {
-      n = await this.getDirectoryHandle(M(t), !1);
+      n = await this.getDirectoryHandle(x(t), !1);
     } catch (i) {
       throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
     }
@@ -937,10 +938,10 @@ class wt {
     const n = r?.recursive ?? !1, i = r?.force ?? !1;
     if (t === "/")
       throw new c("Cannot remove root directory", "EROOT");
-    const a = C(t);
+    const a = b(t);
     if (!a)
       throw new k("Invalid path", t);
-    const s = await this.getDirectoryHandle(M(t), !1);
+    const s = await this.getDirectoryHandle(x(t), !1);
     try {
       await s.removeEntry(a, { recursive: n });
     } catch (o) {
@@ -1062,16 +1063,16 @@ class wt {
    */
   async watch(t) {
     await this.ensureMounted();
-    const r = b(t), n = await this.buildSnapshot(r);
+    const r = C(t), n = await this.buildSnapshot(r);
     this.watchers.set(r, n), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
-    }, this.watchInterval));
+    }, this.options.watchInterval));
   }
   /**
    * Stop watching a previously watched path
    */
   unwatch(t) {
-    const r = b(t);
+    const r = C(t);
     this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
   async buildSnapshot(t) {
@@ -1146,7 +1147,7 @@ class wt {
     try {
       (r?.cleanBefore ?? !1) && await this.clear("/");
       for (const [i, a] of t) {
-        const s = b(i);
+        const s = C(i);
         let o;
         a instanceof Blob ? o = await ft(a) : o = a, await this.writeFile(s, o);
       }
@@ -1156,8 +1157,8 @@ class wt {
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && P(new wt());
-//# sourceMappingURL=worker-BL3varjN.js.map
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && I(new wt());
+//# sourceMappingURL=worker-CHy3JxL1.js.map
 `, r = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", a], { type: "text/javascript;charset=utf-8" });
 function s(e) {
   let n;
@@ -1196,14 +1197,14 @@ export {
   m as PathError,
   g as PermissionError,
   v as StorageError,
-  E as TimeoutError,
-  F as basename,
-  S as calculateFileHash,
+  F as TimeoutError,
+  S as basename,
+  E as calculateFileHash,
   b as checkOPFSSupport,
   P as convertBlobToUint8Array,
-  T as createBuffer,
+  x as createBuffer,
   h as createWorker,
-  x as decodeBuffer,
+  T as decodeBuffer,
   A as dirname,
   O as encodeString,
   D as extname,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { wrap, proxy } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSWorker, RemoteOPFSWorker, WatchEvent } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param watchCallback - Optional callback for file change events\n * @param options - Optional configuration options\n * @param options.watchInterval - Polling interval in milliseconds for file watching\n * @param options.hashAlgorithm - Hash algorithm for file hashing\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    options?: { \n        watchInterval?: number;\n        hashAlgorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';\n    }\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback and options if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(\n            watchCallback ? proxy(watchCallback) : () => {}, \n        );\n    }\n    \n    if (options) {\n        wrapped.setOptions(options);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","options","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBO,SAASA,EACZC,GACAC,GAIgB;AAChB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIJ,KACAE,EAAQ;AAAA,IACJF,IAAgBK,EAAML,CAAa,IAAI,MAAM;AAAA,IAAC;AAAA,EAAA,GAIlDC,KACAC,EAAQ,WAAWD,CAAO,GAGvBC;AACX;"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { wrap, proxy } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSWorker, RemoteOPFSWorker, WatchEvent, OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param watchCallback - Optional callback for file change events\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    options?: OPFSOptions\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback and options if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(\n            watchCallback ? proxy(watchCallback) : () => {}, \n        );\n    }\n    \n    if (options) {\n        wrapped.setOptions(options);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","options","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,SAASA,EACZC,GACAC,GACgB;AAChB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIJ,KACAE,EAAQ;AAAA,IACJF,IAAgBK,EAAML,CAAa,IAAI,MAAM;AAAA,IAAC;AAAA,EAAA,GAIlDC,KACAC,EAAQ,WAAWD,CAAO,GAGvBC;AACX;"}

package/dist/raw.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("comlink"),a=require("./helpers-DjY2OR7f.cjs");class w{root=null;watchCallback=null;watchers=new Map;watchTimer=null;watchInterval=1e3;scanning=!1;mountingPromise=null;hashAlgorithm=null;async notifyChange(t){if(!this.watchCallback)return;let e;if(this.hashAlgorithm&&!t.isDirectory&&t.type!=="removed")try{const r=await this.stat(t.path);r.isFile&&r.hash&&(e=r.hash)}catch(r){console.warn(`Failed to calculate hash for ${t.path}:`,r)}this.watchCallback({timestamp:new Date().toISOString(),...t,...e&&{hash:e}})}constructor(t,e){a.checkOPFSSupport(),t&&(this.watchCallback=t),e&&this.setOptions(e),this.mount("/")}async mount(t="/"){return this.mountingPromise&&await this.mountingPromise,this.mountingPromise=new Promise(async(e,r)=>{this.root=null;try{const i=await navigator.storage.getDirectory();t==="/"?this.root=i:this.root=await this.getDirectoryHandle(t,!0,i),e(!0)}catch(i){console.error(i),r(new a.OPFSError("Failed to initialize OPFS","INIT_FAILED"))}finally{this.mountingPromise=null}}),this.mountingPromise}setWatchCallback(t){this.watchCallback=t}setOptions(t){t.watchInterval!==void 0&&(this.watchInterval=t.watchInterval),t.hashAlgorithm!==void 0&&(this.hashAlgorithm=t.hashAlgorithm)}async ensureMounted(){if(!this.root){if(this.mountingPromise){await this.mountingPromise;return}throw new a.OPFSError("OPFS not mounted","NOT_MOUNTED")}}async getDirectoryHandle(t,e=!1,r=this.root){if(!r)throw new a.OPFSNotMountedError;const i=Array.isArray(t)?t:a.splitPath(t);let s=r;for(const o of i)s=await s.getDirectoryHandle(o,{create:e});return s}async getFileHandle(t,e=!1,r=this.root){if(!r)throw new a.OPFSNotMountedError;const i=a.splitPath(t);if(i.length===0)throw new a.PathError("Path must not be empty",Array.isArray(t)?t.join("/"):t);const s=i.pop();return(await this.getDirectoryHandle(i,e,r)).getFileHandle(s,{create:e})}async index(){const t=new Map,e=async r=>{const i=await this.readdir(r,{withFileTypes:!0});for(const s of i){const o=`${r==="/"?"":r}/${s.name}`;try{const n=await this.stat(o);t.set(o,n),n.isDirectory&&await e(o)}catch(n){console.warn(`Skipping broken entry: ${o}`,n)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t,e="utf-8"){await this.ensureMounted();try{const r=await this.getFileHandle(t,!1),i=await a.readFileData(r);return e==="binary"?i:a.decodeBuffer(i,e)}catch(r){throw console.error(r),new a.FileNotFoundError(t)}}async writeFile(t,e,r){await this.ensureMounted();const i=await this.getFileHandle(t,!0);await a.writeFileData(i,e,r,{truncate:!0}),await this.notifyChange({path:t,type:"changed",isDirectory:!1})}async appendFile(t,e,r){await this.ensureMounted();const i=await this.getFileHandle(t,!0);await a.writeFileData(i,e,r,{append:!0}),await this.notifyChange({path:t,type:"changed",isDirectory:!1})}async mkdir(t,e){if(await this.ensureMounted(),!this.root)throw new a.OPFSNotMountedError;const r=e?.recursive??!1,i=a.splitPath(t);let s=this.root;for(let o=0;o<i.length;o++){const n=i[o];try{s=await s.getDirectoryHandle(n,{create:r||o===i.length-1})}catch(c){throw c.name==="NotFoundError"?new a.OPFSError(`Parent directory does not exist: ${a.joinPath(i.slice(0,o+1))}`,"ENOENT"):c.name==="TypeMismatchError"?new a.OPFSError(`Path segment is not a directory: ${n}`,"ENOTDIR"):new a.OPFSError("Failed to create directory","MKDIR_FAILED")}}await this.notifyChange({path:t,type:"added",isDirectory:!0})}async stat(t){if(await this.ensureMounted(),t==="/")return{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0};const e=a.basename(t),r=await this.getDirectoryHandle(a.dirname(t),!1),i=this.hashAlgorithm!==null;try{const o=await(await r.getFileHandle(e,{create:!1})).getFile(),n={kind:"file",size:o.size,mtime:new Date(o.lastModified).toISOString(),ctime:new Date(o.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(i&&this.hashAlgorithm)try{const c=await a.calculateFileHash(o,this.hashAlgorithm);n.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return n}catch(s){if(s.name!=="TypeMismatchError"&&s.name!=="NotFoundError")throw new a.OPFSError("Failed to stat (file)","STAT_FAILED")}try{return await r.getDirectoryHandle(e,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(s){throw s.name==="NotFoundError"?new a.OPFSError(`No such file or directory: ${t}`,"ENOENT"):new a.OPFSError("Failed to stat (directory)","STAT_FAILED")}}async readdir(t,e){await this.ensureMounted();const r=e?.withFileTypes??!1,i=await this.getDirectoryHandle(t,!1);if(r){const s=[];for await(const[o,n]of i.entries()){const c=n.kind==="file";s.push({name:o,kind:n.kind,isFile:c,isDirectory:!c})}return s}else{const s=[];for await(const[o]of i.entries())s.push(o);return s}}async exists(t){if(await this.ensureMounted(),t==="/")return!0;const e=a.basename(t);let r=null;try{r=await this.getDirectoryHandle(a.dirname(t),!1)}catch(i){throw(i.name==="NotFoundError"||i.name==="TypeMismatchError")&&(r=null),i}if(!r||!e)return!1;try{return await r.getFileHandle(e,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}try{return await r.getDirectoryHandle(e,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}return!1}async clear(t="/"){await this.ensureMounted();try{const e=await this.readdir(t,{withFileTypes:!0});for(const r of e){const i=`${t==="/"?"":t}/${r.name}`;await this.remove(i,{recursive:!0})}await this.notifyChange({path:t,type:"changed",isDirectory:!0})}catch(e){throw e instanceof a.OPFSError?e:new a.OPFSError(`Failed to clear directory: ${t}`,"CLEAR_FAILED")}}async remove(t,e){await this.ensureMounted();const r=e?.recursive??!1,i=e?.force??!1;if(t==="/")throw new a.OPFSError("Cannot remove root directory","EROOT");const s=a.basename(t);if(!s)throw new a.PathError("Invalid path",t);const o=await this.getDirectoryHandle(a.dirname(t),!1);try{await o.removeEntry(s,{recursive:r})}catch(n){if(n.name==="NotFoundError"){if(!i)throw new a.OPFSError(`No such file or directory: ${t}`,"ENOENT")}else throw n.name==="InvalidModificationError"?new a.OPFSError(`Directory not empty: ${t}. Use recursive option to force removal.`,"ENOTEMPTY"):n.name==="TypeMismatchError"&&!r?new a.OPFSError(`Cannot remove directory without recursive option: ${t}`,"EISDIR"):new a.OPFSError(`Failed to remove path: ${t}`,"RM_FAILED")}await this.notifyChange({path:t,type:"removed",isDirectory:!1})}async realpath(t){await this.ensureMounted();try{const e=a.resolvePath(t);if(!await this.exists(e))throw new a.FileNotFoundError(e);return e}catch(e){throw e instanceof a.OPFSError?e:new a.OPFSError(`Failed to resolve path: ${t}`,"REALPATH_FAILED")}}async rename(t,e){await this.ensureMounted();try{if(!await this.exists(t))throw new a.FileNotFoundError(t);await this.copy(t,e,{recursive:!0}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:"removed",isDirectory:!1}),await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(r){throw r instanceof a.OPFSError?r:new a.OPFSError(`Failed to rename from ${t} to ${e}`,"RENAME_FAILED")}}async copy(t,e,r){await this.ensureMounted();try{const i=r?.recursive??!1,s=r?.force??!0;if(!await this.exists(t))throw new a.OPFSError(`Source does not exist: ${t}`,"ENOENT");if(await this.exists(e)&&!s)throw new a.OPFSError(`Destination already exists: ${e}`,"EEXIST");if((await this.stat(t)).isFile){const h=await this.readFile(t,"binary");await this.writeFile(e,h)}else{if(!i)throw new a.OPFSError(`Cannot copy directory without recursive option: ${t}`,"EISDIR");await this.mkdir(e,{recursive:!0});const h=await this.readdir(t,{withFileTypes:!0});for(const l of h){const f=`${t}/${l.name}`,u=`${e}/${l.name}`;await this.copy(f,u,{recursive:!0,force:s})}}await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(i){throw i instanceof a.OPFSError?i:new a.OPFSError(`Failed to copy from ${t} to ${e}`,"CP_FAILED")}}async watch(t){await this.ensureMounted();const e=a.normalizePath(t),r=await this.buildSnapshot(e);this.watchers.set(e,r),this.watchTimer||(this.watchTimer=setInterval(()=>{this.scanWatches()},this.watchInterval))}unwatch(t){const e=a.normalizePath(t);this.watchers.delete(e),this.watchers.size===0&&this.watchTimer&&(clearInterval(this.watchTimer),this.watchTimer=null)}async buildSnapshot(t){const e=new Map,r=async i=>{const s=await this.stat(i);if(e.set(i,s),s.isDirectory){const o=await this.readdir(i,{withFileTypes:!0});for(const n of o){const c=`${i==="/"?"":i}/${n.name}`;await r(c)}}};return await r(t),e}async scanWatches(){if(!this.scanning){this.scanning=!0;try{await Promise.all([...this.watchers.entries()].map(async([t,e])=>{let r;try{r=await this.buildSnapshot(t)}catch{r=new Map}for(const[i,s]of r){const o=e.get(i);o?(o.mtime!==s.mtime||o.size!==s.size)&&await this.notifyChange({path:i,type:"changed",isDirectory:!1}):await this.notifyChange({path:i,type:"added",isDirectory:!1})}for(const i of e.keys())r.has(i)||await this.notifyChange({path:i,type:"removed",isDirectory:!1});this.watchers.set(t,r)}))}finally{this.scanning=!1}}}async sync(t,e){await this.ensureMounted();try{(e?.cleanBefore??!1)&&await this.clear("/");for(const[i,s]of t){const o=a.normalizePath(i);let n;s instanceof Blob?n=await a.convertBlobToUint8Array(s):n=s,await this.writeFile(o,n)}await this.notifyChange({path:"/",type:"changed",isDirectory:!0})}catch(r){throw r instanceof a.OPFSError?r:new a.OPFSError("Failed to sync file system","SYNC_FAILED")}}}typeof self<"u"&&self.constructor.name==="DedicatedWorkerGlobalScope"&&y.expose(new w);exports.OPFSWorker=w;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("comlink"),a=require("./helpers-FvdHLObV.cjs");class w{root=null;watchCallback=null;watchers=new Map;watchTimer=null;scanning=!1;mountingPromise=null;options={watchInterval:1e3,maxFileSize:50*1024*1024,hashAlgorithm:null};async notifyChange(t){if(!this.watchCallback)return;let e;if(this.options.hashAlgorithm&&!t.isDirectory&&t.type!=="removed")try{const r=await this.stat(t.path);r.isFile&&r.hash&&(e=r.hash)}catch(r){console.warn(`Failed to calculate hash for ${t.path}:`,r)}this.watchCallback({timestamp:new Date().toISOString(),...t,...e&&{hash:e}})}constructor(t,e){a.checkOPFSSupport(),t&&(this.watchCallback=t),e&&this.setOptions(e),this.mount("/")}async mount(t="/"){return this.mountingPromise&&await this.mountingPromise,this.mountingPromise=new Promise(async(e,r)=>{this.root=null;try{const i=await navigator.storage.getDirectory();t==="/"?this.root=i:this.root=await this.getDirectoryHandle(t,!0,i),e(!0)}catch(i){console.error(i),r(new a.OPFSError("Failed to initialize OPFS","INIT_FAILED"))}finally{this.mountingPromise=null}}),this.mountingPromise}setWatchCallback(t){this.watchCallback=t}setOptions(t){t.watchInterval!==void 0&&(this.options.watchInterval=t.watchInterval),t.hashAlgorithm!==void 0&&(this.options.hashAlgorithm=t.hashAlgorithm),t.maxFileSize!==void 0&&(this.options.maxFileSize=t.maxFileSize)}async ensureMounted(){if(!this.root){if(this.mountingPromise){await this.mountingPromise;return}throw new a.OPFSError("OPFS not mounted","NOT_MOUNTED")}}async getDirectoryHandle(t,e=!1,r=this.root){if(!r)throw new a.OPFSNotMountedError;const i=Array.isArray(t)?t:a.splitPath(t);let s=r;for(const o of i)s=await s.getDirectoryHandle(o,{create:e});return s}async getFileHandle(t,e=!1,r=this.root){if(!r)throw new a.OPFSNotMountedError;const i=a.splitPath(t);if(i.length===0)throw new a.PathError("Path must not be empty",Array.isArray(t)?t.join("/"):t);const s=i.pop();return(await this.getDirectoryHandle(i,e,r)).getFileHandle(s,{create:e})}async index(){const t=new Map,e=async r=>{const i=await this.readdir(r,{withFileTypes:!0});for(const s of i){const o=`${r==="/"?"":r}/${s.name}`;try{const n=await this.stat(o);t.set(o,n),n.isDirectory&&await e(o)}catch(n){console.warn(`Skipping broken entry: ${o}`,n)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t,e="utf-8"){await this.ensureMounted();try{const r=await this.getFileHandle(t,!1),i=await a.readFileData(r);return e==="binary"?i:a.decodeBuffer(i,e)}catch(r){throw console.error(r),new a.FileNotFoundError(t)}}async writeFile(t,e,r){await this.ensureMounted();const i=await this.getFileHandle(t,!0);await a.writeFileData(i,e,r,{truncate:!0}),await this.notifyChange({path:t,type:"changed",isDirectory:!1})}async appendFile(t,e,r){await this.ensureMounted();const i=await this.getFileHandle(t,!0);await a.writeFileData(i,e,r,{append:!0}),await this.notifyChange({path:t,type:"changed",isDirectory:!1})}async mkdir(t,e){if(await this.ensureMounted(),!this.root)throw new a.OPFSNotMountedError;const r=e?.recursive??!1,i=a.splitPath(t);let s=this.root;for(let o=0;o<i.length;o++){const n=i[o];try{s=await s.getDirectoryHandle(n,{create:r||o===i.length-1})}catch(c){throw c.name==="NotFoundError"?new a.OPFSError(`Parent directory does not exist: ${a.joinPath(i.slice(0,o+1))}`,"ENOENT"):c.name==="TypeMismatchError"?new a.OPFSError(`Path segment is not a directory: ${n}`,"ENOTDIR"):new a.OPFSError("Failed to create directory","MKDIR_FAILED")}}await this.notifyChange({path:t,type:"added",isDirectory:!0})}async stat(t){if(await this.ensureMounted(),t==="/")return{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0};const e=a.basename(t),r=await this.getDirectoryHandle(a.dirname(t),!1),i=this.options.hashAlgorithm!==null;try{const o=await(await r.getFileHandle(e,{create:!1})).getFile(),n={kind:"file",size:o.size,mtime:new Date(o.lastModified).toISOString(),ctime:new Date(o.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(i&&this.options.hashAlgorithm)try{const c=await a.calculateFileHash(o,this.options.hashAlgorithm,this.options.maxFileSize);n.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return n}catch(s){if(s.name!=="TypeMismatchError"&&s.name!=="NotFoundError")throw new a.OPFSError("Failed to stat (file)","STAT_FAILED")}try{return await r.getDirectoryHandle(e,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(s){throw s.name==="NotFoundError"?new a.OPFSError(`No such file or directory: ${t}`,"ENOENT"):new a.OPFSError("Failed to stat (directory)","STAT_FAILED")}}async readdir(t,e){await this.ensureMounted();const r=e?.withFileTypes??!1,i=await this.getDirectoryHandle(t,!1);if(r){const s=[];for await(const[o,n]of i.entries()){const c=n.kind==="file";s.push({name:o,kind:n.kind,isFile:c,isDirectory:!c})}return s}else{const s=[];for await(const[o]of i.entries())s.push(o);return s}}async exists(t){if(await this.ensureMounted(),t==="/")return!0;const e=a.basename(t);let r=null;try{r=await this.getDirectoryHandle(a.dirname(t),!1)}catch(i){throw(i.name==="NotFoundError"||i.name==="TypeMismatchError")&&(r=null),i}if(!r||!e)return!1;try{return await r.getFileHandle(e,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}try{return await r.getDirectoryHandle(e,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}return!1}async clear(t="/"){await this.ensureMounted();try{const e=await this.readdir(t,{withFileTypes:!0});for(const r of e){const i=`${t==="/"?"":t}/${r.name}`;await this.remove(i,{recursive:!0})}await this.notifyChange({path:t,type:"changed",isDirectory:!0})}catch(e){throw e instanceof a.OPFSError?e:new a.OPFSError(`Failed to clear directory: ${t}`,"CLEAR_FAILED")}}async remove(t,e){await this.ensureMounted();const r=e?.recursive??!1,i=e?.force??!1;if(t==="/")throw new a.OPFSError("Cannot remove root directory","EROOT");const s=a.basename(t);if(!s)throw new a.PathError("Invalid path",t);const o=await this.getDirectoryHandle(a.dirname(t),!1);try{await o.removeEntry(s,{recursive:r})}catch(n){if(n.name==="NotFoundError"){if(!i)throw new a.OPFSError(`No such file or directory: ${t}`,"ENOENT")}else throw n.name==="InvalidModificationError"?new a.OPFSError(`Directory not empty: ${t}. Use recursive option to force removal.`,"ENOTEMPTY"):n.name==="TypeMismatchError"&&!r?new a.OPFSError(`Cannot remove directory without recursive option: ${t}`,"EISDIR"):new a.OPFSError(`Failed to remove path: ${t}`,"RM_FAILED")}await this.notifyChange({path:t,type:"removed",isDirectory:!1})}async realpath(t){await this.ensureMounted();try{const e=a.resolvePath(t);if(!await this.exists(e))throw new a.FileNotFoundError(e);return e}catch(e){throw e instanceof a.OPFSError?e:new a.OPFSError(`Failed to resolve path: ${t}`,"REALPATH_FAILED")}}async rename(t,e){await this.ensureMounted();try{if(!await this.exists(t))throw new a.FileNotFoundError(t);await this.copy(t,e,{recursive:!0}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:"removed",isDirectory:!1}),await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(r){throw r instanceof a.OPFSError?r:new a.OPFSError(`Failed to rename from ${t} to ${e}`,"RENAME_FAILED")}}async copy(t,e,r){await this.ensureMounted();try{const i=r?.recursive??!1,s=r?.force??!0;if(!await this.exists(t))throw new a.OPFSError(`Source does not exist: ${t}`,"ENOENT");if(await this.exists(e)&&!s)throw new a.OPFSError(`Destination already exists: ${e}`,"EEXIST");if((await this.stat(t)).isFile){const h=await this.readFile(t,"binary");await this.writeFile(e,h)}else{if(!i)throw new a.OPFSError(`Cannot copy directory without recursive option: ${t}`,"EISDIR");await this.mkdir(e,{recursive:!0});const h=await this.readdir(t,{withFileTypes:!0});for(const l of h){const f=`${t}/${l.name}`,u=`${e}/${l.name}`;await this.copy(f,u,{recursive:!0,force:s})}}await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(i){throw i instanceof a.OPFSError?i:new a.OPFSError(`Failed to copy from ${t} to ${e}`,"CP_FAILED")}}async watch(t){await this.ensureMounted();const e=a.normalizePath(t),r=await this.buildSnapshot(e);this.watchers.set(e,r),this.watchTimer||(this.watchTimer=setInterval(()=>{this.scanWatches()},this.options.watchInterval))}unwatch(t){const e=a.normalizePath(t);this.watchers.delete(e),this.watchers.size===0&&this.watchTimer&&(clearInterval(this.watchTimer),this.watchTimer=null)}async buildSnapshot(t){const e=new Map,r=async i=>{const s=await this.stat(i);if(e.set(i,s),s.isDirectory){const o=await this.readdir(i,{withFileTypes:!0});for(const n of o){const c=`${i==="/"?"":i}/${n.name}`;await r(c)}}};return await r(t),e}async scanWatches(){if(!this.scanning){this.scanning=!0;try{await Promise.all([...this.watchers.entries()].map(async([t,e])=>{let r;try{r=await this.buildSnapshot(t)}catch{r=new Map}for(const[i,s]of r){const o=e.get(i);o?(o.mtime!==s.mtime||o.size!==s.size)&&await this.notifyChange({path:i,type:"changed",isDirectory:!1}):await this.notifyChange({path:i,type:"added",isDirectory:!1})}for(const i of e.keys())r.has(i)||await this.notifyChange({path:i,type:"removed",isDirectory:!1});this.watchers.set(t,r)}))}finally{this.scanning=!1}}}async sync(t,e){await this.ensureMounted();try{(e?.cleanBefore??!1)&&await this.clear("/");for(const[i,s]of t){const o=a.normalizePath(i);let n;s instanceof Blob?n=await a.convertBlobToUint8Array(s):n=s,await this.writeFile(o,n)}await this.notifyChange({path:"/",type:"changed",isDirectory:!0})}catch(r){throw r instanceof a.OPFSError?r:new a.OPFSError("Failed to sync file system","SYNC_FAILED")}}}typeof self<"u"&&self.constructor.name==="DedicatedWorkerGlobalScope"&&y.expose(new w);exports.OPFSWorker=w;
 //# sourceMappingURL=raw.cjs.map