opfs-worker 0.2.3 → 0.2.4

package/dist/index.js

@@ -1,15 +1,15 @@
 import { wrap as i, proxy as o } from "comlink";
-import { D as u, F as d, O as p, b as w, a as y, P as m, c as g, S as v, T as E, e as S, k as F, d as b, l as P, h as x, o as A, f as T, m as O, g as I, j as _, n as D, i as k, r as R, s as U, w as C } from "./helpers-Co-qCBmA.js";
+import { D as d, F as u, O as p, b as w, a as y, P as m, c as g, S as v, T as E, e as S, k as F, d as b, l as P, h as x, o as T, f as I, m as A, g as O, j as _, n as C, i as D, r as k, s as U, w as R } from "./helpers-Co-qCBmA.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"), T = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (t) => typeof t == "object" && t !== null || typeof t == "function", W = {
+const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), I = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (t) => typeof t == "object" && t !== null || typeof t == "function", W = {
   canHandle: (t) => $(t) && t[H],
   serialize(t) {
     const { port1: e, port2: r } = new MessageChannel();
-    return x(t, e), [r, [r]];
+    return O(t, e), [r, [r]];
   },
   deserialize(t) {
     return t.start(), Y(t);
@@ -40,7 +40,7 @@ function V(t, e) {
       return !0;
   return !1;
 }
-function x(t, e = globalThis, r = ["*"]) {
+function O(t, e = globalThis, r = ["*"]) {
   e.addEventListener("message", function a(n) {
     if (!n || !n.data)
       return;
@@ -48,7 +48,7 @@ function x(t, e = globalThis, r = ["*"]) {
       console.warn(\`Invalid origin '\${n.origin}' for comlink proxy\`);
       return;
     }
-    const { id: i, type: o, path: s } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(d);
+    const { id: i, type: o, path: s } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(y);
     let u;
     try {
       const f = s.slice(0, -1).reduce((h, g) => h[g], t), w = s.reduce((h, g) => h[g], t);
@@ -57,7 +57,7 @@ function x(t, e = globalThis, r = ["*"]) {
           u = w;
           break;
         case "SET":
-          f[s.slice(-1)[0]] = d(n.data.value), u = !0;
+          f[s.slice(-1)[0]] = y(n.data.value), u = !0;
           break;
         case "APPLY":
           u = w.apply(f, l);
@@ -71,7 +71,7 @@ function x(t, e = globalThis, r = ["*"]) {
         case "ENDPOINT":
           {
             const { port1: h, port2: g } = new MessageChannel();
-            x(t, g), u = J(h, [h]);
+            O(t, g), u = J(h, [h]);
           }
           break;
         case "RELEASE":
@@ -85,7 +85,7 @@ function x(t, e = globalThis, r = ["*"]) {
     }
     Promise.resolve(u).catch((f) => ({ value: f, [p]: 0 })).then((f) => {
       const [w, h] = A(f);
-      e.postMessage(Object.assign(Object.assign({}, w), { id: i }), h), o === "RELEASE" && (e.removeEventListener("message", a), L(e), T in t && typeof t[T] == "function" && t[T]());
+      e.postMessage(Object.assign(Object.assign({}, w), { id: i }), h), o === "RELEASE" && (e.removeEventListener("message", a), L(e), I in t && typeof t[I] == "function" && t[I]());
     }).catch((f) => {
       const [w, h] = A({
         value: new TypeError("Unserializable return value"),
@@ -114,14 +114,14 @@ function Y(t, e) {
       } finally {
         r.delete(i.id);
       }
-  }), O(t, r, [], e);
+  }), P(t, r, [], e);
 }
 function E(t) {
   if (t)
     throw new Error("Proxy has been released and is not useable");
 }
 function z(t) {
-  return y(t, /* @__PURE__ */ new Map(), {
+  return d(t, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
     L(t);
@@ -138,7 +138,7 @@ function X(t, e) {
 function q(t) {
   S && S.unregister(t);
 }
-function O(t, e, r = [], a = function() {
+function P(t, e, r = [], a = function() {
 }) {
   let n = !1;
   const i = new Proxy(a, {
@@ -150,47 +150,47 @@ function O(t, e, r = [], a = function() {
       if (s === "then") {
         if (r.length === 0)
           return { then: () => i };
-        const l = y(t, e, {
+        const l = d(t, e, {
           type: "GET",
           path: r.map((u) => u.toString())
-        }).then(d);
+        }).then(y);
         return l.then.bind(l);
       }
-      return O(t, e, [...r, s]);
+      return P(t, e, [...r, s]);
     },
     set(o, s, l) {
       E(n);
       const [u, f] = A(l);
-      return y(t, e, {
+      return d(t, e, {
         type: "SET",
         path: [...r, s].map((w) => w.toString()),
         value: u
-      }, f).then(d);
+      }, f).then(y);
     },
     apply(o, s, l) {
       E(n);
       const u = r[r.length - 1];
       if (u === R)
-        return y(t, e, {
+        return d(t, e, {
           type: "ENDPOINT"
-        }).then(d);
+        }).then(y);
       if (u === "bind")
-        return O(t, e, r.slice(0, -1));
-      const [f, w] = N(l);
-      return y(t, e, {
+        return P(t, e, r.slice(0, -1));
+      const [f, w] = k(l);
+      return d(t, e, {
         type: "APPLY",
         path: r.map((h) => h.toString()),
         argumentList: f
-      }, w).then(d);
+      }, w).then(y);
     },
     construct(o, s) {
       E(n);
-      const [l, u] = N(s);
-      return y(t, e, {
+      const [l, u] = k(s);
+      return d(t, e, {
         type: "CONSTRUCT",
         path: r.map((f) => f.toString()),
         argumentList: l
-      }, u).then(d);
+      }, u).then(y);
     }
   });
   return X(i, t), i;
@@ -198,7 +198,7 @@ function O(t, e, r = [], a = function() {
 function K(t) {
   return Array.prototype.concat.apply([], t);
 }
-function N(t) {
+function k(t) {
   const e = t.map(A);
   return [e.map((r) => r[0]), K(e.map((r) => r[1]))];
 }
@@ -230,7 +230,7 @@ function A(t) {
     _.get(t) || []
   ];
 }
-function d(t) {
+function y(t) {
   switch (t.type) {
     case "HANDLER":
       return U.get(t.name).deserialize(t.value);
@@ -238,7 +238,7 @@ function d(t) {
       return t.value;
   }
 }
-function y(t, e, r, a) {
+function d(t, e, r, a) {
   return new Promise((n) => {
     const i = Z();
     e.set(i, n), t.start && t.start(), t.postMessage(Object.assign({ id: i }, r), a);
@@ -257,17 +257,17 @@ class ee extends c {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
 }
-class D extends c {
+class T extends c {
   constructor() {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class k extends c {
+class v extends c {
   constructor(e, r) {
     super(e, "INVALID_PATH", r);
   }
 }
-class b extends c {
+class D extends c {
   constructor(e) {
     super(\`File not found: \${e}\`, "FILE_NOT_FOUND", e);
   }
@@ -352,18 +352,18 @@ function oe() {
 function m(t) {
   return Array.isArray(t) ? t : t.split("/").filter(Boolean);
 }
-function v(t) {
+function x(t) {
   return typeof t == "string" ? t ?? "/" : \`/\${t.join("/")}\`;
 }
-function I(t) {
+function b(t) {
   const e = m(t);
   return e[e.length - 1] || "";
 }
-function P(t) {
+function M(t) {
   const e = m(t);
-  return e.pop(), v(e);
+  return e.pop(), x(e);
 }
-function M(t) {
+function C(t) {
   return !t || t === "/" ? "/" : t.startsWith("/") ? t : \`/\${t}\`;
 }
 function ce(t) {
@@ -376,7 +376,7 @@ function ce(t) {
         r.pop();
       } else
         r.push(a);
-  return v(r);
+  return x(r);
 }
 function le(t, e = "utf-8") {
   return typeof t == "string" ? te(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
@@ -390,7 +390,7 @@ async function ue(t) {
     e.close();
   }
 }
-async function C(t, e, r, a = {}) {
+async function N(t, e, r, a = {}) {
   let n = null;
   try {
     n = await t.createSyncAccessHandle();
@@ -435,6 +435,21 @@ class we {
   scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
+  /**
+   * Notify about internal changes to the file system
+   * 
+   * This method is called by internal operations to notify clients about
+   * changes, even when no specific paths are being watched.
+   * 
+   * @param path - The path that was changed
+   * @param type - The type of change (create, change, delete)
+   */
+  notifyInternalChange(e, r) {
+    this.watchCallback && this.watchCallback({
+      path: e,
+      type: r
+    });
+  }
   /**
    * Creates a new OPFSFileSystem instance
    * 
@@ -526,7 +541,7 @@ class we {
    */
   async getDirectoryHandle(e, r = !1, a = this.root) {
     if (!a)
-      throw new D();
+      throw new T();
     const n = Array.isArray(e) ? e : m(e);
     let i = a;
     for (const o of n)
@@ -554,10 +569,10 @@ class we {
    */
   async getFileHandle(e, r = !1, a = this.root) {
     if (!a)
-      throw new D();
+      throw new T();
     const n = m(e);
     if (n.length === 0)
-      throw new k("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
+      throw new v("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
     const i = n.pop();
     return (await this.getDirectoryHandle(n, r, a)).getFileHandle(i, { create: r });
   }
@@ -626,7 +641,7 @@ class we {
       const a = await this.getFileHandle(e, !1), n = await ue(a);
       return r === "binary" ? n : re(n, r);
     } catch (a) {
-      throw console.error(a), new b(e);
+      throw console.error(a), new D(e);
     }
   }
   /**
@@ -657,7 +672,7 @@ class we {
   async writeFile(e, r, a) {
     await this.ensureMounted();
     const n = await this.getFileHandle(e, !0);
-    await C(n, r, a, { truncate: !0 });
+    await N(n, r, a, { truncate: !0 }), this.notifyInternalChange(e, "change");
   }
   /**
    * Append data to a file
@@ -684,7 +699,7 @@ class we {
   async appendFile(e, r, a) {
     await this.ensureMounted();
     const n = await this.getFileHandle(e, !0);
-    await C(n, r, a, { append: !0 });
+    await N(n, r, a, { append: !0 }), this.notifyInternalChange(e, "change");
   }
   /**
    * Create a directory
@@ -709,7 +724,7 @@ class we {
    */
   async mkdir(e, r) {
     if (await this.ensureMounted(), !this.root)
-      throw new D();
+      throw new T();
     const a = r?.recursive ?? !1, n = m(e);
     let i = this.root;
     for (let o = 0; o < n.length; o++) {
@@ -718,11 +733,12 @@ class we {
         i = await i.getDirectoryHandle(s, { create: a || o === n.length - 1 });
       } catch (l) {
         throw l.name === "NotFoundError" ? new c(
-          \`Parent directory does not exist: \${v(n.slice(0, o + 1))}\`,
+          \`Parent directory does not exist: \${x(n.slice(0, o + 1))}\`,
           "ENOENT"
         ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${s}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
       }
     }
+    this.notifyInternalChange(e, "create");
   }
   /**
    * Get file or directory stats
@@ -763,7 +779,7 @@ class we {
         isFile: !1,
         isDirectory: !0
       };
-    const a = I(e), n = await this.getDirectoryHandle(P(e), !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
+    const a = b(e), n = await this.getDirectoryHandle(M(e), !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
     try {
       const l = await (await n.getFileHandle(a, { create: !1 })).getFile(), u = {
         kind: "file",
@@ -837,10 +853,10 @@ class we {
   async exists(e) {
     if (await this.ensureMounted(), e === "/")
       return !0;
-    const r = I(e);
+    const r = b(e);
     let a = null;
     try {
-      a = await this.getDirectoryHandle(P(e), !1);
+      a = await this.getDirectoryHandle(M(e), !1);
     } catch (n) {
       throw (n.name === "NotFoundError" || n.name === "TypeMismatchError") && (a = null), n;
     }
@@ -887,6 +903,7 @@ class we {
         const n = \`\${e === "/" ? "" : e}/\${a.name}\`;
         await this.remove(n, { recursive: !0 });
       }
+      this.notifyInternalChange(e, "change");
     } catch (r) {
       throw r instanceof c ? r : new c(\`Failed to clear directory: \${e}\`, "CLEAR_FAILED");
     }
@@ -920,10 +937,10 @@ class we {
     const a = r?.recursive ?? !1, n = r?.force ?? !1;
     if (e === "/")
       throw new c("Cannot remove root directory", "EROOT");
-    const i = I(e);
+    const i = b(e);
     if (!i)
-      throw new k("Invalid path", e);
-    const o = await this.getDirectoryHandle(P(e), !1);
+      throw new v("Invalid path", e);
+    const o = await this.getDirectoryHandle(M(e), !1);
     try {
       await o.removeEntry(i, { recursive: a });
     } catch (s) {
@@ -932,6 +949,7 @@ class we {
           throw new c(\`No such file or directory: \${e}\`, "ENOENT");
       } else throw s.name === "InvalidModificationError" ? new c(\`Directory not empty: \${e}. Use recursive option to force removal.\`, "ENOTEMPTY") : s.name === "TypeMismatchError" && !a ? new c(\`Cannot remove directory without recursive option: \${e}\`, "EISDIR") : new c(\`Failed to remove path: \${e}\`, "RM_FAILED");
     }
+    this.notifyInternalChange(e, "delete");
   }
   /**
    * Resolve a path to an absolute path
@@ -956,7 +974,7 @@ class we {
     try {
       const r = ce(e);
       if (!await this.exists(r))
-        throw new b(r);
+        throw new D(r);
       return r;
     } catch (r) {
       throw r instanceof c ? r : new c(\`Failed to resolve path: \${e}\`, "REALPATH_FAILED");
@@ -982,8 +1000,8 @@ class we {
     await this.ensureMounted();
     try {
       if (!await this.exists(e))
-        throw new b(e);
-      await this.copy(e, r, { recursive: !0 }), await this.remove(e, { recursive: !0 });
+        throw new D(e);
+      await this.copy(e, r, { recursive: !0 }), await this.remove(e, { recursive: !0 }), this.notifyInternalChange(e, "delete"), this.notifyInternalChange(r, "create");
     } catch (a) {
       throw a instanceof c ? a : new c(\`Failed to rename from \${e} to \${r}\`, "RENAME_FAILED");
     }
@@ -1034,6 +1052,7 @@ class we {
           await this.copy(w, h, { recursive: !0, force: i });
         }
       }
+      this.notifyInternalChange(r, "create");
     } catch (n) {
       throw n instanceof c ? n : new c(\`Failed to copy from \${e} to \${r}\`, "CP_FAILED");
     }
@@ -1043,7 +1062,7 @@ class we {
    */
   async watch(e) {
     await this.ensureMounted();
-    const r = M(e), a = await this.buildSnapshot(r);
+    const r = C(e), a = await this.buildSnapshot(r);
     this.watchers.set(r, a), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
     }, this.watchInterval));
@@ -1052,7 +1071,7 @@ class we {
    * Stop watching a previously watched path
    */
   unwatch(e) {
-    const r = M(e);
+    const r = C(e);
     this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
   async buildSnapshot(e) {
@@ -1131,46 +1150,47 @@ class we {
     try {
       (r?.cleanBefore ?? !1) && await this.clear("/");
       for (const [n, i] of e) {
-        const o = M(n);
+        const o = C(n);
         let s;
         i instanceof Blob ? s = await he(i) : s = i, await this.writeFile(o, s);
       }
+      this.notifyInternalChange("/", "change");
     } catch (a) {
       throw a instanceof c ? a : new c("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && x(new we());
-//# sourceMappingURL=worker-CRHhlrlS.js.map
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && O(new we());
+//# sourceMappingURL=worker-DCm4BiWM.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) {
+function s(t) {
   let n;
   try {
     if (n = r && (self.URL || self.webkitURL).createObjectURL(r), !n) throw "";
-    const t = new Worker(n, {
+    const e = new Worker(n, {
       type: "module",
-      name: e?.name
+      name: t?.name
     });
-    return t.addEventListener("error", () => {
+    return e.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(n);
-    }), t;
+    }), e;
   } catch {
     return new Worker(
       "data:text/javascript;charset=utf-8," + encodeURIComponent(a),
       {
         type: "module",
-        name: e?.name
+        name: t?.name
       }
     );
   }
 }
-function l(e, n) {
-  const t = i(new s());
-  return e && t.setWatchCallback(o(e), n), t;
+function l(t, n) {
+  const e = i(new s());
+  return t && e.setWatchCallback(o(t), n), e;
 }
 export {
-  u as DirectoryNotFoundError,
-  d as FileNotFoundError,
+  d as DirectoryNotFoundError,
+  u as FileNotFoundError,
   p as OPFSError,
   w as OPFSNotMountedError,
   y as OPFSNotSupportedError,
@@ -1184,15 +1204,15 @@ export {
   P as convertBlobToUint8Array,
   x as createBuffer,
   l as createWorker,
-  A as decodeBuffer,
-  T as dirname,
-  O as encodeString,
-  I as extname,
+  T as decodeBuffer,
+  I as dirname,
+  A as encodeString,
+  O as extname,
   _ as joinPath,
-  D as normalizePath,
-  k as readFileData,
-  R as resolvePath,
+  C as normalizePath,
+  D as readFileData,
+  k as resolvePath,
   U as splitPath,
-  C as writeFileData
+  R as writeFileData
 };
 //# sourceMappingURL=index.js.map

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 watchOptions - Optional configuration for watching\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    watchOptions?: { watchInterval?: number }\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(proxy(watchCallback), watchOptions);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","watchOptions","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,SAASA,EACZC,GACAC,GACgB;AAChB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIJ,KACAE,EAAQ,iBAAiBG,EAAML,CAAa,GAAGC,CAAY,GAGxDC;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 } 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 watchOptions - Optional configuration for watching\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    watchOptions?: { watchInterval?: number }\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(proxy(watchCallback), watchOptions);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","watchOptions","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,SAASA,EACZC,GACAC,GACgB;AAChB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIJ,KACAE,EAAQ,iBAAiBG,EAAML,CAAa,GAAGC,CAAY,GAGxDC;AACX;"}

package/dist/raw.cjs

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