opfs-worker 0.2.5 → 0.3.0

package/dist/index.cjs

@@ -1,19 +1,19 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("comlink"),n=require("./helpers-DjY2OR7f.cjs"),o=`/**
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("comlink"),n=require("./helpers-FvdHLObV.cjs"),i=`/**
  * @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"), A = 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 = {
@@ -28,7 +28,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]
 ]);
@@ -38,7 +38,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;
@@ -46,7 +46,7 @@ function P(e, t = globalThis, r = ["*"]) {
       console.warn(\`Invalid origin '\${i.origin}' for comlink proxy\`);
       return;
     }
-    const { id: a, type: s, path: o } = Object.assign({ path: [] }, i.data), l = (i.data.argumentList || []).map(y);
+    const { id: a, type: s, path: o } = Object.assign({ path: [] }, i.data), l = (i.data.argumentList || []).map(d);
     let h;
     try {
       const u = o.slice(0, -1).reduce((f, g) => f[g], e), w = o.reduce((f, g) => f[g], e);
@@ -55,7 +55,7 @@ function P(e, t = globalThis, r = ["*"]) {
           h = w;
           break;
         case "SET":
-          u[o.slice(-1)[0]] = y(i.data.value), h = !0;
+          u[o.slice(-1)[0]] = d(i.data.value), h = !0;
           break;
         case "APPLY":
           h = w.apply(u, l);
@@ -69,7 +69,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":
@@ -79,15 +79,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) => {
-      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]());
+    Promise.resolve(h).catch((u) => ({ value: u, [E]: 0 })).then((u) => {
+      const [w, f] = D(u);
+      t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f), s === "RELEASE" && (t.removeEventListener("message", n), L(t), A in e && typeof e[A] == "function" && e[A]());
     }).catch((u) => {
-      const [w, f] = A({
+      const [w, f] = D({
         value: new TypeError("Unserializable return value"),
-        [p]: 0
+        [E]: 0
       });
       t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f);
     });
@@ -112,14 +112,14 @@ function Y(e, t) {
       } finally {
         r.delete(a.id);
       }
-  }), I(e, r, [], t);
+  }), x(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) {
-  return d(e, /* @__PURE__ */ new Map(), {
+function U(e) {
+  return y(e, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
     L(e);
@@ -127,7 +127,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;
@@ -136,59 +136,59 @@ function X(e, t) {
 function q(e) {
   S && S.unregister(e);
 }
-function I(e, t, r = [], n = function() {
+function x(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)
           return { then: () => a };
-        const l = d(e, t, {
+        const l = y(e, t, {
           type: "GET",
           path: r.map((h) => h.toString())
-        }).then(y);
+        }).then(d);
         return l.then.bind(l);
       }
-      return I(e, t, [...r, o]);
+      return x(e, t, [...r, o]);
     },
     set(s, o, l) {
-      E(i);
-      const [h, u] = A(l);
-      return d(e, t, {
+      p(i);
+      const [h, u] = D(l);
+      return y(e, t, {
         type: "SET",
         path: [...r, o].map((w) => w.toString()),
         value: h
-      }, u).then(y);
+      }, u).then(d);
     },
     apply(s, o, l) {
-      E(i);
+      p(i);
       const h = r[r.length - 1];
       if (h === R)
-        return d(e, t, {
+        return y(e, t, {
           type: "ENDPOINT"
-        }).then(y);
+        }).then(d);
       if (h === "bind")
-        return I(e, t, r.slice(0, -1));
-      const [u, w] = N(l);
-      return d(e, t, {
+        return x(e, t, r.slice(0, -1));
+      const [u, w] = v(l);
+      return y(e, t, {
         type: "APPLY",
         path: r.map((f) => f.toString()),
         argumentList: u
-      }, w).then(y);
+      }, w).then(d);
     },
     construct(s, o) {
-      E(i);
-      const [l, h] = N(o);
-      return d(e, t, {
+      p(i);
+      const [l, h] = v(o);
+      return y(e, t, {
         type: "CONSTRUCT",
         path: r.map((u) => u.toString()),
         argumentList: l
-      }, h).then(y);
+      }, h).then(d);
     }
   });
   return X(a, e), a;
@@ -196,8 +196,8 @@ function I(e, t, r = [], n = function() {
 function K(e) {
   return Array.prototype.concat.apply([], e);
 }
-function N(e) {
-  const t = e.map(A);
+function v(e) {
+  const t = e.map(D);
   return [t.map((r) => r[0]), K(t.map((r) => r[1]))];
 }
 const _ = /* @__PURE__ */ new WeakMap();
@@ -207,8 +207,8 @@ function J(e, t) {
 function Q(e) {
   return Object.assign(e, { [H]: !0 });
 }
-function A(e) {
-  for (const [t, r] of U)
+function D(e) {
+  for (const [t, r] of z)
     if (r.canHandle(e)) {
       const [n, i] = r.serialize(e);
       return [
@@ -228,15 +228,15 @@ function A(e) {
     _.get(e) || []
   ];
 }
-function y(e) {
+function d(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;
   }
 }
-function d(e, t, r, n) {
+function y(e, t, r, n) {
   return new Promise((i) => {
     const a = Z();
     t.set(a, i), e.start && e.start(), e.postMessage(Object.assign({ id: a }, r), n);
@@ -255,17 +255,17 @@ class tt extends c {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
 }
-class T extends c {
+class C extends c {
   constructor() {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class k extends c {
+class N extends c {
   constructor(t, r) {
     super(t, "INVALID_PATH", r);
   }
 }
-class O extends c {
+class b extends c {
   constructor(t) {
     super(\`File not found: \${t}\`, "FILE_NOT_FOUND", t);
   }
@@ -350,18 +350,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 T(e) {
   const t = m(e);
   return t[t.length - 1] || "";
 }
-function M(e) {
+function O(e) {
   const t = m(e);
-  return t.pop(), x(t);
+  return t.pop(), P(t);
 }
-function b(e) {
+function M(e) {
   return !e || e === "/" ? "/" : e.startsWith("/") ? e : \`/\${e}\`;
 }
 function ct(e) {
@@ -374,7 +374,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);
@@ -388,7 +388,7 @@ async function ht(e) {
     t.close();
   }
 }
-async function v(e, t, r, n = {}) {
+async function k(e, t, r, n = {}) {
   let i = null;
   try {
     i = await e.createSyncAccessHandle();
@@ -406,14 +406,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();
@@ -422,20 +419,23 @@ async function ft(e) {
 class wt {
   /** Root directory handle for the file system */
   root = null;
-  /** Watch event callback */
-  watchCallback = null;
   /** Map of watched paths to their last known state */
   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;
+  /** BroadcastChannel instance for sending events */
+  broadcastChannel = null;
+  /** Configuration options */
+  options = {
+    watchInterval: 1e3,
+    maxFileSize: 50 * 1024 * 1024,
+    hashAlgorithm: null,
+    broadcastChannel: "opfs-worker"
+  };
   /**
    * Notify about internal changes to the file system
    * 
@@ -446,33 +446,39 @@ class wt {
    * @param type - The type of change (create, change, delete)
    */
   async notifyChange(t) {
-    if (!this.watchCallback)
+    if (!this.options.broadcastChannel)
       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);
       } catch (n) {
         console.warn(\`Failed to calculate hash for \${t.path}:\`, n);
       }
-    this.watchCallback({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      ...t,
-      ...r && { hash: r }
-    });
+    try {
+      this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
+      const n = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...t,
+        ...r && { hash: r }
+      };
+      this.broadcastChannel.postMessage(n);
+    } catch (n) {
+      console.warn("Failed to send event via BroadcastChannel:", n);
+    }
   }
   /**
    * Creates a new OPFSFileSystem instance
    * 
-   * @param watchCallback - Optional callback for file change events
    * @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) {
-    ot(), t && (this.watchCallback = t), r && this.setOptions(r), this.mount("/");
+  constructor(t) {
+    ot(), t && this.setOptions(t), this.mount("/");
   }
   /**
    * Initialize the file system within a given directory
@@ -509,22 +515,16 @@ class wt {
     }), this.mountingPromise;
   }
   /**
-   * Set the watch callback for file change events
-   * 
-   * @param callback - The callback function to invoke when files change
-   */
-  setWatchCallback(t) {
-    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
+   * @param options.broadcastChannel - Custom name for the broadcast channel
    */
   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), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel);
   }
   /**
    * Automatically mount the OPFS root if not already mounted
@@ -564,7 +564,7 @@ class wt {
    */
   async getDirectoryHandle(t, r = !1, n = this.root) {
     if (!n)
-      throw new T();
+      throw new C();
     const i = Array.isArray(t) ? t : m(t);
     let a = n;
     for (const s of i)
@@ -592,10 +592,10 @@ class wt {
    */
   async getFileHandle(t, r = !1, n = this.root) {
     if (!n)
-      throw new T();
+      throw new C();
     const i = m(t);
     if (i.length === 0)
-      throw new k("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+      throw new N("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
     const a = i.pop();
     return (await this.getDirectoryHandle(i, r, n)).getFileHandle(a, { create: r });
   }
@@ -646,7 +646,7 @@ class wt {
       const n = await this.getFileHandle(t, !1), i = await ht(n);
       return r === "binary" ? i : rt(i, r);
     } catch (n) {
-      throw console.error(n), new O(t);
+      throw console.error(n), new b(t);
     }
   }
   /**
@@ -677,7 +677,7 @@ class wt {
   async writeFile(t, r, n) {
     await this.ensureMounted();
     const i = await this.getFileHandle(t, !0);
-    await v(i, r, n, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await k(i, r, n, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -704,7 +704,7 @@ class wt {
   async appendFile(t, r, n) {
     await this.ensureMounted();
     const i = await this.getFileHandle(t, !0);
-    await v(i, r, n, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await k(i, r, n, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -729,7 +729,7 @@ class wt {
    */
   async mkdir(t, r) {
     if (await this.ensureMounted(), !this.root)
-      throw new T();
+      throw new C();
     const n = r?.recursive ?? !1, i = m(t);
     let a = this.root;
     for (let s = 0; s < i.length; s++) {
@@ -738,7 +738,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");
       }
@@ -777,7 +777,7 @@ class wt {
         isFile: !1,
         isDirectory: !0
       };
-    const r = C(t), n = await this.getDirectoryHandle(M(t), !1), i = this.hashAlgorithm !== null;
+    const r = T(t), n = await this.getDirectoryHandle(O(t), !1), i = this.options.hashAlgorithm !== null;
     try {
       const s = await (await n.getFileHandle(r, { create: !1 })).getFile(), o = {
         kind: "file",
@@ -787,9 +787,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);
@@ -851,10 +851,10 @@ class wt {
   async exists(t) {
     if (await this.ensureMounted(), t === "/")
       return !0;
-    const r = C(t);
+    const r = T(t);
     let n = null;
     try {
-      n = await this.getDirectoryHandle(M(t), !1);
+      n = await this.getDirectoryHandle(O(t), !1);
     } catch (i) {
       throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
     }
@@ -935,10 +935,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 = T(t);
     if (!a)
-      throw new k("Invalid path", t);
-    const s = await this.getDirectoryHandle(M(t), !1);
+      throw new N("Invalid path", t);
+    const s = await this.getDirectoryHandle(O(t), !1);
     try {
       await s.removeEntry(a, { recursive: n });
     } catch (o) {
@@ -972,7 +972,7 @@ class wt {
     try {
       const r = ct(t);
       if (!await this.exists(r))
-        throw new O(r);
+        throw new b(r);
       return r;
     } catch (r) {
       throw r instanceof c ? r : new c(\`Failed to resolve path: \${t}\`, "REALPATH_FAILED");
@@ -998,7 +998,7 @@ class wt {
     await this.ensureMounted();
     try {
       if (!await this.exists(t))
-        throw new O(t);
+        throw new b(t);
       await this.copy(t, r, { recursive: !0 }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: r, type: "added", isDirectory: !1 });
     } catch (n) {
       throw n instanceof c ? n : new c(\`Failed to rename from \${t} to \${r}\`, "RENAME_FAILED");
@@ -1060,18 +1060,27 @@ class wt {
    */
   async watch(t) {
     await this.ensureMounted();
-    const r = b(t), n = await this.buildSnapshot(r);
+    const r = M(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 = M(t);
     this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
+  /**
+   * Dispose of resources and clean up the file system instance
+   * 
+   * This method should be called when the file system instance is no longer needed
+   * to properly clean up resources like the broadcast channel and watch timers.
+   */
+  dispose() {
+    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null), this.watchers.clear();
+  }
   async buildSnapshot(t) {
     const r = /* @__PURE__ */ new Map(), n = async (i) => {
       const a = await this.stat(i);
@@ -1099,10 +1108,13 @@ class wt {
             }
             for (const [i, a] of n) {
               const s = r.get(i);
-              s ? (s.mtime !== a.mtime || s.size !== a.size) && await this.notifyChange({ path: i, type: "changed", isDirectory: !1 }) : await this.notifyChange({ path: i, type: "added", isDirectory: !1 });
+              s ? (s.mtime !== a.mtime || s.size !== a.size) && await this.notifyChange({ path: i, type: "changed", isDirectory: a.isDirectory }) : await this.notifyChange({ path: i, type: "added", isDirectory: a.isDirectory });
             }
             for (const i of r.keys())
-              n.has(i) || await this.notifyChange({ path: i, type: "removed", isDirectory: !1 });
+              if (!n.has(i)) {
+                const a = r.get(i);
+                await this.notifyChange({ path: i, type: "removed", isDirectory: a?.isDirectory ?? !1 });
+              }
             this.watchers.set(t, n);
           })
         );
@@ -1144,7 +1156,7 @@ class wt {
     try {
       (r?.cleanBefore ?? !1) && await this.clear("/");
       for (const [i, a] of t) {
-        const s = b(i);
+        const s = M(i);
         let o;
         a instanceof Blob ? o = await ft(a) : o = a, await this.writeFile(s, o);
       }
@@ -1154,7 +1166,7 @@ class wt {
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && P(new wt());
-//# sourceMappingURL=worker-BL3varjN.js.map
-`,i=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",o],{type:"text/javascript;charset=utf-8"});function s(r){let t;try{if(t=i&&(self.URL||self.webkitURL).createObjectURL(i),!t)throw"";const e=new Worker(t,{type:"module",name:r?.name});return e.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(t)}),e}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(o),{type:"module",name:r?.name})}}function c(r,t){const e=a.wrap(new s);return r&&e.setWatchCallback(r?a.proxy(r):()=>{}),t&&e.setOptions(t),e}exports.DirectoryNotFoundError=n.DirectoryNotFoundError;exports.FileNotFoundError=n.FileNotFoundError;exports.OPFSError=n.OPFSError;exports.OPFSNotMountedError=n.OPFSNotMountedError;exports.OPFSNotSupportedError=n.OPFSNotSupportedError;exports.PathError=n.PathError;exports.PermissionError=n.PermissionError;exports.StorageError=n.StorageError;exports.TimeoutError=n.TimeoutError;exports.basename=n.basename;exports.calculateFileHash=n.calculateFileHash;exports.checkOPFSSupport=n.checkOPFSSupport;exports.convertBlobToUint8Array=n.convertBlobToUint8Array;exports.createBuffer=n.createBuffer;exports.decodeBuffer=n.decodeBuffer;exports.dirname=n.dirname;exports.encodeString=n.encodeString;exports.extname=n.extname;exports.joinPath=n.joinPath;exports.normalizePath=n.normalizePath;exports.readFileData=n.readFileData;exports.resolvePath=n.resolvePath;exports.splitPath=n.splitPath;exports.writeFileData=n.writeFileData;exports.createWorker=c;
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && I(new wt());
+//# sourceMappingURL=worker-DvdTp4yb.js.map
+`,a=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",i],{type:"text/javascript;charset=utf-8"});function s(e){let t;try{if(t=a&&(self.URL||self.webkitURL).createObjectURL(a),!t)throw"";const r=new Worker(t,{type:"module",name:e?.name});return r.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(t)}),r}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(i),{type:"module",name:e?.name})}}function c(e){const t=o.wrap(new s);return e&&t.setOptions(e),t}exports.DirectoryNotFoundError=n.DirectoryNotFoundError;exports.FileNotFoundError=n.FileNotFoundError;exports.OPFSError=n.OPFSError;exports.OPFSNotMountedError=n.OPFSNotMountedError;exports.OPFSNotSupportedError=n.OPFSNotSupportedError;exports.PathError=n.PathError;exports.PermissionError=n.PermissionError;exports.StorageError=n.StorageError;exports.TimeoutError=n.TimeoutError;exports.basename=n.basename;exports.calculateFileHash=n.calculateFileHash;exports.checkOPFSSupport=n.checkOPFSSupport;exports.convertBlobToUint8Array=n.convertBlobToUint8Array;exports.createBuffer=n.createBuffer;exports.decodeBuffer=n.decodeBuffer;exports.dirname=n.dirname;exports.encodeString=n.encodeString;exports.extname=n.extname;exports.joinPath=n.joinPath;exports.normalizePath=n.normalizePath;exports.readFileData=n.readFileData;exports.resolvePath=n.resolvePath;exports.splitPath=n.splitPath;exports.writeFileData=n.writeFileData;exports.createWorker=c;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAmBO,SAASA,EACZC,EACAC,EAIgB,CAChB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIJ,GACAE,EAAQ,iBACJF,EAAgBK,EAAAA,MAAML,CAAa,EAAI,IAAM,CAAC,CAAA,EAIlDC,GACAC,EAAQ,WAAWD,CAAO,EAGvBC,CACX"}
+{"version":3,"file":"index.cjs","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 options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    options?: OPFSOptions\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up options if provided\n    if (options) {\n        wrapped.setOptions(options);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","options","wrapped","wrap","WorkerCtor"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAgBO,SAASA,EACZC,EACgB,CAChB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIH,GACAC,EAAQ,WAAWD,CAAO,EAGvBC,CACX"}

package/dist/index.d.ts

@@ -1,18 +1,12 @@
-import type { RemoteOPFSWorker, WatchEvent } from './types';
+import type { RemoteOPFSWorker, OPFSOptions } from './types';
 export * from './types';
 export * from './utils/errors';
 export * from './utils/helpers';
 export * from './utils/encoder';
 /**
  * Creates a new file system instance with inline worker
- * @param watchCallback - Optional callback for file change events
  * @param options - Optional configuration options
- * @param options.watchInterval - Polling interval in milliseconds for file watching
- * @param options.hashAlgorithm - Hash algorithm for file hashing
  * @returns Promise resolving to the file system interface
  */
-export declare function createWorker(watchCallback?: (event: WatchEvent) => void, options?: {
-    watchInterval?: number;
-    hashAlgorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
-}): RemoteOPFSWorker;
+export declare function createWorker(options?: OPFSOptions): RemoteOPFSWorker;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,gBAAgB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAExE,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAEhC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CACxB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE;IACN,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;CAC/D,GACF,gBAAgB,CAelB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,gBAAgB,EAAc,WAAW,EAAE,MAAM,SAAS,CAAC;AAErF,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAEhC;;;;GAIG;AACH,wBAAgB,YAAY,CACxB,OAAO,CAAC,EAAE,WAAW,GACtB,gBAAgB,CASlB"}