opfs-worker 0.2.4 → 0.2.6

package/dist/index.js

@@ -1,258 +1,258 @@
 import { wrap as i, proxy as o } from "comlink";
-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";
+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"), 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 O(t, e), [r, [r]];
+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 I(e, t), [r, [r]];
   },
-  deserialize(t) {
-    return t.start(), Y(t);
+  deserialize(e) {
+    return e.start(), Y(e);
   }
 }, j = {
-  canHandle: (t) => $(t) && p in t,
-  serialize({ value: t }) {
-    let e;
-    return t instanceof Error ? e = {
+  canHandle: (e) => $(e) && E in e,
+  serialize({ value: e }) {
+    let t;
+    return e instanceof Error ? t = {
       isError: !0,
       value: {
-        message: t.message,
-        name: t.name,
-        stack: t.stack
+        message: e.message,
+        name: e.name,
+        stack: e.stack
       }
-    } : e = { isError: !1, value: t }, [e, []];
+    } : t = { isError: !1, value: e }, [t, []];
   },
-  deserialize(t) {
-    throw t.isError ? Object.assign(new Error(t.value.message), t.value) : t.value;
+  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]
 ]);
-function V(t, e) {
-  for (const r of t)
-    if (e === r || r === "*" || r instanceof RegExp && r.test(e))
+function V(e, t) {
+  for (const r of e)
+    if (t === r || r === "*" || r instanceof RegExp && r.test(t))
       return !0;
   return !1;
 }
-function O(t, e = globalThis, r = ["*"]) {
-  e.addEventListener("message", function a(n) {
-    if (!n || !n.data)
+function I(e, t = globalThis, r = ["*"]) {
+  t.addEventListener("message", function n(i) {
+    if (!i || !i.data)
       return;
-    if (!V(r, n.origin)) {
-      console.warn(\`Invalid origin '\${n.origin}' for comlink proxy\`);
+    if (!V(r, i.origin)) {
+      console.warn(\`Invalid origin '\${i.origin}' for comlink proxy\`);
       return;
     }
-    const { id: i, type: o, path: s } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(y);
-    let u;
+    const { id: a, type: s, path: o } = Object.assign({ path: [] }, i.data), l = (i.data.argumentList || []).map(y);
+    let h;
     try {
-      const f = s.slice(0, -1).reduce((h, g) => h[g], t), w = s.reduce((h, g) => h[g], t);
-      switch (o) {
+      const u = o.slice(0, -1).reduce((f, g) => f[g], e), w = o.reduce((f, g) => f[g], e);
+      switch (s) {
         case "GET":
-          u = w;
+          h = w;
           break;
         case "SET":
-          f[s.slice(-1)[0]] = y(n.data.value), u = !0;
+          u[o.slice(-1)[0]] = y(i.data.value), h = !0;
           break;
         case "APPLY":
-          u = w.apply(f, l);
+          h = w.apply(u, l);
           break;
         case "CONSTRUCT":
           {
-            const h = new w(...l);
-            u = Q(h);
+            const f = new w(...l);
+            h = Q(f);
           }
           break;
         case "ENDPOINT":
           {
-            const { port1: h, port2: g } = new MessageChannel();
-            O(t, g), u = J(h, [h]);
+            const { port1: f, port2: g } = new MessageChannel();
+            I(e, g), h = J(f, [f]);
           }
           break;
         case "RELEASE":
-          u = void 0;
+          h = void 0;
           break;
         default:
           return;
       }
-    } catch (f) {
-      u = { value: f, [p]: 0 };
+    } catch (u) {
+      h = { value: u, [E]: 0 };
     }
-    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), I in t && typeof t[I] == "function" && t[I]());
-    }).catch((f) => {
-      const [w, h] = A({
+    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
       });
-      e.postMessage(Object.assign(Object.assign({}, w), { id: i }), h);
+      t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f);
     });
-  }), e.start && e.start();
+  }), t.start && t.start();
 }
-function G(t) {
-  return t.constructor.name === "MessagePort";
+function G(e) {
+  return e.constructor.name === "MessagePort";
 }
-function L(t) {
-  G(t) && t.close();
+function L(e) {
+  G(e) && e.close();
 }
-function Y(t, e) {
+function Y(e, t) {
   const r = /* @__PURE__ */ new Map();
-  return t.addEventListener("message", function(n) {
-    const { data: i } = n;
-    if (!i || !i.id)
+  return e.addEventListener("message", function(i) {
+    const { data: a } = i;
+    if (!a || !a.id)
       return;
-    const o = r.get(i.id);
-    if (o)
+    const s = r.get(a.id);
+    if (s)
       try {
-        o(i);
+        s(a);
       } finally {
-        r.delete(i.id);
+        r.delete(a.id);
       }
-  }), P(t, r, [], e);
+  }), M(e, r, [], t);
 }
-function E(t) {
-  if (t)
+function p(e) {
+  if (e)
     throw new Error("Proxy has been released and is not useable");
 }
-function z(t) {
-  return d(t, /* @__PURE__ */ new Map(), {
+function U(e) {
+  return d(e, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
-    L(t);
+    L(e);
   });
 }
-const F = /* @__PURE__ */ new WeakMap(), S = "FinalizationRegistry" in globalThis && new FinalizationRegistry((t) => {
-  const e = (F.get(t) || 0) - 1;
-  F.set(t, e), e === 0 && z(t);
+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 && U(e);
 });
-function X(t, e) {
-  const r = (F.get(e) || 0) + 1;
-  F.set(e, r), S && S.register(t, e, t);
+function X(e, t) {
+  const r = (F.get(t) || 0) + 1;
+  F.set(t, r), S && S.register(e, t, e);
 }
-function q(t) {
-  S && S.unregister(t);
+function q(e) {
+  S && S.unregister(e);
 }
-function P(t, e, r = [], a = function() {
+function M(e, t, r = [], n = function() {
 }) {
-  let n = !1;
-  const i = new Proxy(a, {
-    get(o, s) {
-      if (E(n), s === B)
+  let i = !1;
+  const a = new Proxy(n, {
+    get(s, o) {
+      if (p(i), o === B)
         return () => {
-          q(i), z(t), e.clear(), n = !0;
+          q(a), U(e), t.clear(), i = !0;
         };
-      if (s === "then") {
+      if (o === "then") {
         if (r.length === 0)
-          return { then: () => i };
-        const l = d(t, e, {
+          return { then: () => a };
+        const l = d(e, t, {
           type: "GET",
-          path: r.map((u) => u.toString())
+          path: r.map((h) => h.toString())
         }).then(y);
         return l.then.bind(l);
       }
-      return P(t, e, [...r, s]);
+      return M(e, t, [...r, o]);
     },
-    set(o, s, l) {
-      E(n);
-      const [u, f] = A(l);
-      return d(t, e, {
+    set(s, o, l) {
+      p(i);
+      const [h, u] = A(l);
+      return d(e, t, {
         type: "SET",
-        path: [...r, s].map((w) => w.toString()),
-        value: u
-      }, f).then(y);
+        path: [...r, o].map((w) => w.toString()),
+        value: h
+      }, u).then(y);
     },
-    apply(o, s, l) {
-      E(n);
-      const u = r[r.length - 1];
-      if (u === R)
-        return d(t, e, {
+    apply(s, o, l) {
+      p(i);
+      const h = r[r.length - 1];
+      if (h === R)
+        return d(e, t, {
           type: "ENDPOINT"
         }).then(y);
-      if (u === "bind")
-        return P(t, e, r.slice(0, -1));
-      const [f, w] = k(l);
-      return d(t, e, {
+      if (h === "bind")
+        return M(e, t, r.slice(0, -1));
+      const [u, w] = N(l);
+      return d(e, t, {
         type: "APPLY",
-        path: r.map((h) => h.toString()),
-        argumentList: f
+        path: r.map((f) => f.toString()),
+        argumentList: u
       }, w).then(y);
     },
-    construct(o, s) {
-      E(n);
-      const [l, u] = k(s);
-      return d(t, e, {
+    construct(s, o) {
+      p(i);
+      const [l, h] = N(o);
+      return d(e, t, {
         type: "CONSTRUCT",
-        path: r.map((f) => f.toString()),
+        path: r.map((u) => u.toString()),
         argumentList: l
-      }, u).then(y);
+      }, h).then(y);
     }
   });
-  return X(i, t), i;
+  return X(a, e), a;
 }
-function K(t) {
-  return Array.prototype.concat.apply([], t);
+function K(e) {
+  return Array.prototype.concat.apply([], e);
 }
-function k(t) {
-  const e = t.map(A);
-  return [e.map((r) => r[0]), K(e.map((r) => r[1]))];
+function N(e) {
+  const t = e.map(A);
+  return [t.map((r) => r[0]), K(t.map((r) => r[1]))];
 }
 const _ = /* @__PURE__ */ new WeakMap();
-function J(t, e) {
-  return _.set(t, e), t;
+function J(e, t) {
+  return _.set(e, t), e;
 }
-function Q(t) {
-  return Object.assign(t, { [H]: !0 });
+function Q(e) {
+  return Object.assign(e, { [H]: !0 });
 }
-function A(t) {
-  for (const [e, r] of U)
-    if (r.canHandle(t)) {
-      const [a, n] = r.serialize(t);
+function A(e) {
+  for (const [t, r] of z)
+    if (r.canHandle(e)) {
+      const [n, i] = r.serialize(e);
       return [
         {
           type: "HANDLER",
-          name: e,
-          value: a
+          name: t,
+          value: n
         },
-        n
+        i
       ];
     }
   return [
     {
       type: "RAW",
-      value: t
+      value: e
     },
-    _.get(t) || []
+    _.get(e) || []
   ];
 }
-function y(t) {
-  switch (t.type) {
+function y(e) {
+  switch (e.type) {
     case "HANDLER":
-      return U.get(t.name).deserialize(t.value);
+      return z.get(e.name).deserialize(e.value);
     case "RAW":
-      return t.value;
+      return e.value;
   }
 }
-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);
+function d(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);
   });
 }
 function Z() {
   return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
 }
 class c extends Error {
-  constructor(e, r, a) {
-    super(e), this.code = r, this.path = a, this.name = "OPFSError";
+  constructor(t, r, n) {
+    super(t), this.code = r, this.path = n, this.name = "OPFSError";
   }
 }
-class ee extends c {
+class tt extends c {
   constructor() {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
@@ -262,165 +262,163 @@ class T extends c {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class v extends c {
-  constructor(e, r) {
-    super(e, "INVALID_PATH", r);
+class k extends c {
+  constructor(t, r) {
+    super(t, "INVALID_PATH", r);
   }
 }
-class D extends c {
-  constructor(e) {
-    super(\`File not found: \${e}\`, "FILE_NOT_FOUND", e);
+class O extends c {
+  constructor(t) {
+    super(\`File not found: \${t}\`, "FILE_NOT_FOUND", t);
   }
 }
-function te(t, e = "utf-8") {
-  switch (e) {
+function et(e, t = "utf-8") {
+  switch (t) {
     case "utf8":
     case "utf-8":
-      return new TextEncoder().encode(t);
+      return new TextEncoder().encode(e);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return ne(t);
+      return nt(e);
     case "ascii":
-      return se(t);
+      return st(e);
     case "latin1":
-      return ie(t);
+      return at(e);
     case "binary":
-      return Uint8Array.from(t, (r) => r.charCodeAt(0));
+      return Uint8Array.from(e, (r) => r.charCodeAt(0));
     case "base64":
-      return Uint8Array.from(atob(t), (r) => r.charCodeAt(0));
+      return Uint8Array.from(atob(e), (r) => r.charCodeAt(0));
     case "hex":
-      if (!/^[\\da-f]+$/i.test(t) || t.length % 2 !== 0)
+      if (!/^[\\da-f]+$/i.test(e) || e.length % 2 !== 0)
         throw new c("Invalid hex string", "INVALID_HEX_FORMAT");
-      return Uint8Array.from(t.match(/.{1,2}/g).map((r) => parseInt(r, 16)));
+      return Uint8Array.from(e.match(/.{1,2}/g).map((r) => parseInt(r, 16)));
     default:
-      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(t);
+      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(e);
   }
 }
-function re(t, e = "utf-8") {
-  switch (e) {
+function rt(e, t = "utf-8") {
+  switch (t) {
     case "utf8":
     case "utf-8":
-      return new TextDecoder().decode(t);
+      return new TextDecoder().decode(e);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return ae(t);
+      return it(e);
     case "latin1":
-      return String.fromCharCode(...t);
+      return String.fromCharCode(...e);
     case "binary":
-      return String.fromCharCode(...t);
+      return String.fromCharCode(...e);
     case "ascii":
-      return String.fromCharCode(...t.map((r) => r & 127));
+      return String.fromCharCode(...e.map((r) => r & 127));
     case "base64":
-      return btoa(String.fromCharCode(...t));
+      return btoa(String.fromCharCode(...e));
     case "hex":
-      return Array.from(t).map((r) => r.toString(16).padStart(2, "0")).join("");
+      return Array.from(e).map((r) => r.toString(16).padStart(2, "0")).join("");
     default:
-      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(t);
+      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(e);
   }
 }
-function ne(t) {
-  const e = new Uint8Array(t.length * 2);
-  for (let r = 0; r < t.length; r++) {
-    const a = t.charCodeAt(r);
-    e[r * 2] = a & 255, e[r * 2 + 1] = a >> 8;
+function nt(e) {
+  const t = new Uint8Array(e.length * 2);
+  for (let r = 0; r < e.length; r++) {
+    const n = e.charCodeAt(r);
+    t[r * 2] = n & 255, t[r * 2 + 1] = n >> 8;
   }
-  return e;
+  return t;
 }
-function ae(t) {
-  t.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), t = t.slice(0, t.length - 1));
-  const e = new Uint16Array(t.buffer, t.byteOffset, t.byteLength / 2);
-  return String.fromCharCode(...e);
+function it(e) {
+  e.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), e = e.slice(0, e.length - 1));
+  const t = new Uint16Array(e.buffer, e.byteOffset, e.byteLength / 2);
+  return String.fromCharCode(...t);
 }
-function ie(t) {
-  const e = new Uint8Array(t.length);
-  for (let r = 0; r < t.length; r++)
-    e[r] = t.charCodeAt(r) & 255;
-  return e;
+function at(e) {
+  const t = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    t[r] = e.charCodeAt(r) & 255;
+  return t;
 }
-function se(t) {
-  const e = new Uint8Array(t.length);
-  for (let r = 0; r < t.length; r++)
-    e[r] = t.charCodeAt(r) & 127;
-  return e;
+function st(e) {
+  const t = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    t[r] = e.charCodeAt(r) & 127;
+  return t;
 }
-function oe() {
+function ot() {
   if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
-    throw new ee();
+    throw new tt();
 }
-function m(t) {
-  return Array.isArray(t) ? t : t.split("/").filter(Boolean);
+function m(e) {
+  return Array.isArray(e) ? e : e.split("/").filter(Boolean);
 }
-function x(t) {
-  return typeof t == "string" ? t ?? "/" : \`/\${t.join("/")}\`;
+function P(e) {
+  return typeof e == "string" ? e ?? "/" : \`/\${e.join("/")}\`;
 }
-function b(t) {
-  const e = m(t);
-  return e[e.length - 1] || "";
+function b(e) {
+  const t = m(e);
+  return t[t.length - 1] || "";
 }
-function M(t) {
-  const e = m(t);
-  return e.pop(), x(e);
+function x(e) {
+  const t = m(e);
+  return t.pop(), P(t);
 }
-function C(t) {
-  return !t || t === "/" ? "/" : t.startsWith("/") ? t : \`/\${t}\`;
+function C(e) {
+  return !e || e === "/" ? "/" : e.startsWith("/") ? e : \`/\${e}\`;
 }
-function ce(t) {
-  const e = m(t), r = [];
-  for (const a of e)
-    if (!(a === "." || a === ""))
-      if (a === "..") {
+function ct(e) {
+  const t = m(e), r = [];
+  for (const n of t)
+    if (!(n === "." || n === ""))
+      if (n === "..") {
         if (r.length === 0)
           continue;
         r.pop();
       } else
-        r.push(a);
-  return x(r);
+        r.push(n);
+  return P(r);
 }
-function le(t, e = "utf-8") {
-  return typeof t == "string" ? te(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
+function lt(e, t = "utf-8") {
+  return typeof e == "string" ? et(e, t) : e instanceof Uint8Array ? e : new Uint8Array(e);
 }
-async function ue(t) {
-  const e = await t.createSyncAccessHandle();
+async function ht(e) {
+  const t = await e.createSyncAccessHandle();
   try {
-    const r = e.getSize(), a = new Uint8Array(r);
-    return e.read(a, { at: 0 }), a;
+    const r = t.getSize(), n = new Uint8Array(r);
+    return t.read(n, { at: 0 }), n;
   } finally {
-    e.close();
+    t.close();
   }
 }
-async function N(t, e, r, a = {}) {
-  let n = null;
+async function v(e, t, r, n = {}) {
+  let i = null;
   try {
-    n = await t.createSyncAccessHandle();
-    const i = le(e, r), o = a.append ? n.getSize() : 0;
-    n.write(i, { at: o }), a.truncate && !a.append && n.truncate(i.byteLength), n.flush();
-  } catch (i) {
-    console.error(i);
-    const o = a.append ? "append" : "write";
-    throw new c(\`Failed to \${o} file\`, \`\${o.toUpperCase()}_FAILED\`);
+    i = await e.createSyncAccessHandle();
+    const a = lt(t, r), s = n.append ? i.getSize() : 0;
+    i.write(a, { at: s }), n.truncate && !n.append && i.truncate(a.byteLength), i.flush();
+  } catch (a) {
+    console.error(a);
+    const s = n.append ? "append" : "write";
+    throw new c(\`Failed to \${s} file\`, \`\${s.toUpperCase()}_FAILED\`);
   } finally {
-    if (n)
+    if (i)
       try {
-        n.close();
+        i.close();
       } catch {
       }
   }
 }
-async function fe(t, e = "SHA-1") {
-  try {
-    const r = new Uint8Array(t), a = await crypto.subtle.digest(e, r);
-    return Array.from(new Uint8Array(a)).map((i) => i.toString(16).padStart(2, "0")).join("");
-  } catch (r) {
-    throw console.warn(\`Failed to calculate \${e} 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 he(t) {
-  const e = await t.arrayBuffer();
-  return new Uint8Array(e);
+async function ft(e) {
+  const t = await e.arrayBuffer();
+  return new Uint8Array(t);
 }
-class we {
+class wt {
   /** Root directory handle for the file system */
   root = null;
   /** Watch event callback */
@@ -429,12 +427,16 @@ class we {
   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;
+  /** Configuration options */
+  options = {
+    watchInterval: 1e3,
+    maxFileSize: 50 * 1024 * 1024,
+    hashAlgorithm: null
+  };
   /**
    * Notify about internal changes to the file system
    * 
@@ -444,21 +446,35 @@ class we {
    * @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
+  async notifyChange(t) {
+    if (!this.watchCallback)
+      return;
+    let r;
+    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 }
     });
   }
   /**
    * Creates a new OPFSFileSystem instance
    * 
    * @param watchCallback - Optional callback for file change events
-   * @param watchOptions - Optional configuration for watching
+   * @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(e, r) {
-    oe(), e && (this.watchCallback = e, r?.watchInterval && (this.watchInterval = r.watchInterval)), this.mount("/");
+  constructor(t, r) {
+    ot(), t && (this.watchCallback = t), r && this.setOptions(r), this.mount("/");
   }
   /**
    * Initialize the file system within a given directory
@@ -481,14 +497,14 @@ class we {
    * await fs.mount('/my-app');
    * \`\`\`
    */
-  async mount(e = "/") {
-    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (r, a) => {
+  async mount(t = "/") {
+    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (r, n) => {
       this.root = null;
       try {
-        const n = await navigator.storage.getDirectory();
-        e === "/" ? this.root = n : this.root = await this.getDirectoryHandle(e, !0, n), r(!0);
-      } catch (n) {
-        console.error(n), a(new c("Failed to initialize OPFS", "INIT_FAILED"));
+        const i = await navigator.storage.getDirectory();
+        t === "/" ? this.root = i : this.root = await this.getDirectoryHandle(t, !0, i), r(!0);
+      } catch (i) {
+        console.error(i), n(new c("Failed to initialize OPFS", "INIT_FAILED"));
       } finally {
         this.mountingPromise = null;
       }
@@ -498,10 +514,20 @@ class we {
    * Set the watch callback for file change events
    * 
    * @param callback - The callback function to invoke when files change
-   * @param options - Optional configuration for watching
    */
-  setWatchCallback(e, r) {
-    this.watchCallback = e, r?.watchInterval && (this.watchInterval = r.watchInterval);
+  setWatchCallback(t) {
+    this.watchCallback = t;
+  }
+  /**
+   * 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.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
@@ -539,14 +565,14 @@ class we {
    * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
    * \`\`\`
    */
-  async getDirectoryHandle(e, r = !1, a = this.root) {
-    if (!a)
+  async getDirectoryHandle(t, r = !1, n = this.root) {
+    if (!n)
       throw new T();
-    const n = Array.isArray(e) ? e : m(e);
-    let i = a;
-    for (const o of n)
-      i = await i.getDirectoryHandle(o, { create: r });
-    return i;
+    const i = Array.isArray(t) ? t : m(t);
+    let a = n;
+    for (const s of i)
+      a = await a.getDirectoryHandle(s, { create: r });
+    return a;
   }
   /**
    * Get a file handle from a path
@@ -567,45 +593,27 @@ class we {
    * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
    * \`\`\`
    */
-  async getFileHandle(e, r = !1, a = this.root) {
-    if (!a)
+  async getFileHandle(t, r = !1, n = this.root) {
+    if (!n)
       throw new T();
-    const n = m(e);
-    if (n.length === 0)
-      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 });
+    const i = m(t);
+    if (i.length === 0)
+      throw new k("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 });
   }
   /**
-   * Recursively list all files and directories with their stats
+   * Get a complete index of all files and directories in the file system
    * 
-   * Traverses the entire file system starting from the root and returns
-   * a Map containing all paths and their corresponding file statistics.
+   * This method recursively traverses the entire file system and returns
+   * a Map containing FileStat objects for every file and directory.
    * 
-   * @param options - Options for indexing
-   * @param options.includeHash - Whether to calculate file hash (default: false)
-   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
-   * @returns Promise that resolves to a Map of path => FileStat
-   * @throws {OPFSError} If the indexing operation fails
+   * @returns Promise that resolves to a Map of paths to FileStat objects
+   * @throws {OPFSError} If the file system is not mounted
    * 
    * @example
    * \`\`\`typescript
-   * // Basic index without hash
    * const index = await fs.index();
-   * 
-   * // Index with file hash
-   * const indexWithHash = await fs.index({ 
-   *   includeHash: true,
-   *   hashAlgorithm: 'SHA-1'
-   * });
-   * 
-   * // Iterate through all files and directories
-   * for (const [path, stat] of index) {
-   *   console.log(\`\${path}: \${stat.isFile ? 'file' : 'directory'} (\${stat.size} bytes)\`);
-   *   if (stat.hash) console.log(\`  Hash: \${stat.hash}\`);
-   * }
-   * 
-   * // Get specific file stats
    * const fileStats = index.get('/data/config.json');
    * if (fileStats) {
    *   console.log(\`File size: \${fileStats.size} bytes\`);
@@ -613,35 +621,35 @@ class we {
    * }
    * \`\`\`
    */
-  async index(e) {
-    const r = /* @__PURE__ */ new Map(), a = async (n) => {
+  async index() {
+    const t = /* @__PURE__ */ new Map(), r = async (n) => {
       const i = await this.readdir(n, { withFileTypes: !0 });
-      for (const o of i) {
-        const s = \`\${n === "/" ? "" : n}/\${o.name}\`;
+      for (const a of i) {
+        const s = \`\${n === "/" ? "" : n}/\${a.name}\`;
         try {
-          const l = await this.stat(s, e);
-          r.set(s, l), l.isDirectory && await a(s);
-        } catch (l) {
-          console.warn(\`Skipping broken entry: \${s}\`, l);
+          const o = await this.stat(s);
+          t.set(s, o), o.isDirectory && await r(s);
+        } catch (o) {
+          console.warn(\`Skipping broken entry: \${s}\`, o);
         }
       }
     };
-    return r.set("/", {
+    return t.set("/", {
       kind: "directory",
       size: 0,
       mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await a("/"), r;
+    }), await r("/"), t;
   }
-  async readFile(e, r = "utf-8") {
+  async readFile(t, r = "utf-8") {
     await this.ensureMounted();
     try {
-      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 D(e);
+      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);
     }
   }
   /**
@@ -669,10 +677,10 @@ class we {
    * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
    * \`\`\`
    */
-  async writeFile(e, r, a) {
+  async writeFile(t, r, n) {
     await this.ensureMounted();
-    const n = await this.getFileHandle(e, !0);
-    await N(n, r, a, { truncate: !0 }), this.notifyInternalChange(e, "change");
+    const i = await this.getFileHandle(t, !0);
+    await v(i, r, n, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -696,10 +704,10 @@ class we {
    * await fs.appendFile('/data/binary.dat', additionalData);
    * \`\`\`
    */
-  async appendFile(e, r, a) {
+  async appendFile(t, r, n) {
     await this.ensureMounted();
-    const n = await this.getFileHandle(e, !0);
-    await N(n, r, a, { append: !0 }), this.notifyInternalChange(e, "change");
+    const i = await this.getFileHandle(t, !0);
+    await v(i, r, n, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -722,55 +730,48 @@ class we {
    * await fs.mkdir('/users/john/documents/projects', { recursive: true });
    * \`\`\`
    */
-  async mkdir(e, r) {
+  async mkdir(t, r) {
     if (await this.ensureMounted(), !this.root)
       throw new T();
-    const a = r?.recursive ?? !1, n = m(e);
-    let i = this.root;
-    for (let o = 0; o < n.length; o++) {
-      const s = n[o];
+    const n = r?.recursive ?? !1, i = m(t);
+    let a = this.root;
+    for (let s = 0; s < i.length; s++) {
+      const o = i[s];
       try {
-        i = await i.getDirectoryHandle(s, { create: a || o === n.length - 1 });
+        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(n.slice(0, o + 1))}\`,
+          \`Parent directory does not exist: \${P(i.slice(0, s + 1))}\`,
           "ENOENT"
-        ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${s}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
+        ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${o}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
       }
     }
-    this.notifyInternalChange(e, "create");
+    await this.notifyChange({ path: t, type: "added", isDirectory: !0 });
   }
   /**
-   * Get file or directory stats
+   * Get file or directory statistics
    * 
-   * Retrieves metadata about a file or directory, including size, modification time,
-   * type information, and optionally file hashes.
+   * Returns detailed information about a file or directory, including
+   * size, modification time, and optionally a hash of the file content.
    * 
    * @param path - The path to the file or directory
-   * @param options - Options for stat operation
-   * @param options.includeHash - Whether to calculate file hash (default: false, only for files)
-   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
-   * @returns Promise that resolves to file/directory statistics
-   * @throws {OPFSError} If the file or directory does not exist or cannot be accessed
+   * @returns Promise that resolves to FileStat object
+   * @throws {OPFSError} If the path does not exist or cannot be accessed
    * 
    * @example
    * \`\`\`typescript
-   * // Basic stats
-   * const stats = await fs.stat('/config/settings.json');
+   * const stats = await fs.stat('/data/config.json');
    * console.log(\`File size: \${stats.size} bytes\`);
-   * console.log(\`Is file: \${stats.isFile}\`);
-   * console.log(\`Modified: \${stats.mtime}\`);
-   * 
-   * // Stats with hash (SHA-1 is fastest)
-   * const statsWithHash = await fs.stat('/config/settings.json', { 
-   *   includeHash: true,
-   *   hashAlgorithm: 'SHA-1'
-   * });
-   * console.log(\`Hash: \${statsWithHash.hash}\`);
+   * console.log(\`Last modified: \${stats.mtime}\`);
+   * 
+   * // If hashing is enabled, hash will be included
+   * if (stats.hash) {
+   *   console.log(\`Hash: \${stats.hash}\`);
+   * }
    * \`\`\`
    */
-  async stat(e, r) {
-    if (await this.ensureMounted(), e === "/")
+  async stat(t) {
+    if (await this.ensureMounted(), t === "/")
       return {
         kind: "directory",
         size: 0,
@@ -779,30 +780,30 @@ class we {
         isFile: !1,
         isDirectory: !0
       };
-    const a = b(e), n = await this.getDirectoryHandle(M(e), !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
+    const r = b(t), n = await this.getDirectoryHandle(x(t), !1), i = this.options.hashAlgorithm !== null;
     try {
-      const l = await (await n.getFileHandle(a, { create: !1 })).getFile(), u = {
+      const s = await (await n.getFileHandle(r, { create: !1 })).getFile(), o = {
         kind: "file",
-        size: l.size,
-        mtime: new Date(l.lastModified).toISOString(),
-        ctime: new Date(l.lastModified).toISOString(),
+        size: s.size,
+        mtime: new Date(s.lastModified).toISOString(),
+        ctime: new Date(s.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (i)
+      if (i && this.options.hashAlgorithm)
         try {
-          const f = new Uint8Array(await l.arrayBuffer()), w = await fe(f, o);
-          u.hash = w;
-        } catch (f) {
-          console.warn(\`Failed to calculate hash for \${e}:\`, f);
+          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);
         }
-      return u;
-    } catch (s) {
-      if (s.name !== "TypeMismatchError" && s.name !== "NotFoundError")
+      return o;
+    } catch (a) {
+      if (a.name !== "TypeMismatchError" && a.name !== "NotFoundError")
         throw new c("Failed to stat (file)", "STAT_FAILED");
     }
     try {
-      return await n.getDirectoryHandle(a, { create: !1 }), {
+      return await n.getDirectoryHandle(r, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
@@ -810,30 +811,30 @@ class we {
         isFile: !1,
         isDirectory: !0
       };
-    } catch (s) {
-      throw s.name === "NotFoundError" ? new c(\`No such file or directory: \${e}\`, "ENOENT") : new c("Failed to stat (directory)", "STAT_FAILED");
+    } catch (a) {
+      throw a.name === "NotFoundError" ? new c(\`No such file or directory: \${t}\`, "ENOENT") : new c("Failed to stat (directory)", "STAT_FAILED");
     }
   }
-  async readdir(e, r) {
+  async readdir(t, r) {
     await this.ensureMounted();
-    const a = r?.withFileTypes ?? !1, n = await this.getDirectoryHandle(e, !1);
-    if (a) {
-      const i = [];
-      for await (const [o, s] of n.entries()) {
-        const l = s.kind === "file";
-        i.push({
-          name: o,
-          kind: s.kind,
+    const n = r?.withFileTypes ?? !1, i = await this.getDirectoryHandle(t, !1);
+    if (n) {
+      const a = [];
+      for await (const [s, o] of i.entries()) {
+        const l = o.kind === "file";
+        a.push({
+          name: s,
+          kind: o.kind,
           isFile: l,
           isDirectory: !l
         });
       }
-      return i;
+      return a;
     } else {
-      const i = [];
-      for await (const [o] of n.entries())
-        i.push(o);
-      return i;
+      const a = [];
+      for await (const [s] of i.entries())
+        a.push(s);
+      return a;
     }
   }
   /**
@@ -850,29 +851,29 @@ class we {
    * console.log(\`File exists: \${exists}\`);
    * \`\`\`
    */
-  async exists(e) {
-    if (await this.ensureMounted(), e === "/")
+  async exists(t) {
+    if (await this.ensureMounted(), t === "/")
       return !0;
-    const r = b(e);
-    let a = null;
+    const r = b(t);
+    let n = null;
     try {
-      a = await this.getDirectoryHandle(M(e), !1);
-    } catch (n) {
-      throw (n.name === "NotFoundError" || n.name === "TypeMismatchError") && (a = null), n;
+      n = await this.getDirectoryHandle(x(t), !1);
+    } catch (i) {
+      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
     }
-    if (!a || !r)
+    if (!n || !r)
       return !1;
     try {
-      return await a.getFileHandle(r, { create: !1 }), !0;
-    } catch (n) {
-      if (n.name !== "NotFoundError" && n.name !== "TypeMismatchError")
-        throw n;
+      return await n.getFileHandle(r, { create: !1 }), !0;
+    } catch (i) {
+      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+        throw i;
     }
     try {
-      return await a.getDirectoryHandle(r, { create: !1 }), !0;
-    } catch (n) {
-      if (n.name !== "NotFoundError" && n.name !== "TypeMismatchError")
-        throw n;
+      return await n.getDirectoryHandle(r, { create: !1 }), !0;
+    } catch (i) {
+      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+        throw i;
     }
     return !1;
   }
@@ -895,17 +896,17 @@ class we {
    * await fs.clear('/data');
    * \`\`\`
    */
-  async clear(e = "/") {
+  async clear(t = "/") {
     await this.ensureMounted();
     try {
-      const r = await this.readdir(e, { withFileTypes: !0 });
-      for (const a of r) {
-        const n = \`\${e === "/" ? "" : e}/\${a.name}\`;
-        await this.remove(n, { recursive: !0 });
+      const r = await this.readdir(t, { withFileTypes: !0 });
+      for (const n of r) {
+        const i = \`\${t === "/" ? "" : t}/\${n.name}\`;
+        await this.remove(i, { recursive: !0 });
       }
-      this.notifyInternalChange(e, "change");
+      await this.notifyChange({ path: t, type: "changed", isDirectory: !0 });
     } catch (r) {
-      throw r instanceof c ? r : new c(\`Failed to clear directory: \${e}\`, "CLEAR_FAILED");
+      throw r instanceof c ? r : new c(\`Failed to clear directory: \${t}\`, "CLEAR_FAILED");
     }
   }
   /**
@@ -932,24 +933,24 @@ class we {
    * await fs.rm('/maybe/exists', { force: true });
    * \`\`\`
    */
-  async remove(e, r) {
+  async remove(t, r) {
     await this.ensureMounted();
-    const a = r?.recursive ?? !1, n = r?.force ?? !1;
-    if (e === "/")
+    const n = r?.recursive ?? !1, i = r?.force ?? !1;
+    if (t === "/")
       throw new c("Cannot remove root directory", "EROOT");
-    const i = b(e);
-    if (!i)
-      throw new v("Invalid path", e);
-    const o = await this.getDirectoryHandle(M(e), !1);
+    const a = b(t);
+    if (!a)
+      throw new k("Invalid path", t);
+    const s = await this.getDirectoryHandle(x(t), !1);
     try {
-      await o.removeEntry(i, { recursive: a });
-    } catch (s) {
-      if (s.name === "NotFoundError") {
-        if (!n)
-          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");
+      await s.removeEntry(a, { recursive: n });
+    } catch (o) {
+      if (o.name === "NotFoundError") {
+        if (!i)
+          throw new c(\`No such file or directory: \${t}\`, "ENOENT");
+      } else throw o.name === "InvalidModificationError" ? new c(\`Directory not empty: \${t}. Use recursive option to force removal.\`, "ENOTEMPTY") : o.name === "TypeMismatchError" && !n ? new c(\`Cannot remove directory without recursive option: \${t}\`, "EISDIR") : new c(\`Failed to remove path: \${t}\`, "RM_FAILED");
     }
-    this.notifyInternalChange(e, "delete");
+    await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
   }
   /**
    * Resolve a path to an absolute path
@@ -969,15 +970,15 @@ class we {
    * console.log(absolute); // '/data/file.txt'
    * \`\`\`
    */
-  async realpath(e) {
+  async realpath(t) {
     await this.ensureMounted();
     try {
-      const r = ce(e);
+      const r = ct(t);
       if (!await this.exists(r))
-        throw new D(r);
+        throw new O(r);
       return r;
     } catch (r) {
-      throw r instanceof c ? r : new c(\`Failed to resolve path: \${e}\`, "REALPATH_FAILED");
+      throw r instanceof c ? r : new c(\`Failed to resolve path: \${t}\`, "REALPATH_FAILED");
     }
   }
   /**
@@ -996,14 +997,14 @@ class we {
    * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
    * \`\`\`
    */
-  async rename(e, r) {
+  async rename(t, r) {
     await this.ensureMounted();
     try {
-      if (!await this.exists(e))
-        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");
+      if (!await this.exists(t))
+        throw new O(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");
     }
   }
   /**
@@ -1031,85 +1032,81 @@ class we {
    * await fs.copy('/source', '/dest', { recursive: true, force: false });
    * \`\`\`
    */
-  async copy(e, r, a) {
+  async copy(t, r, n) {
     await this.ensureMounted();
     try {
-      const n = a?.recursive ?? !1, i = a?.force ?? !0;
-      if (!await this.exists(e))
-        throw new c(\`Source does not exist: \${e}\`, "ENOENT");
-      if (await this.exists(r) && !i)
+      const i = n?.recursive ?? !1, a = n?.force ?? !0;
+      if (!await this.exists(t))
+        throw new c(\`Source does not exist: \${t}\`, "ENOENT");
+      if (await this.exists(r) && !a)
         throw new c(\`Destination already exists: \${r}\`, "EEXIST");
-      if ((await this.stat(e)).isFile) {
-        const u = await this.readFile(e, "binary");
-        await this.writeFile(r, u);
+      if ((await this.stat(t)).isFile) {
+        const h = await this.readFile(t, "binary");
+        await this.writeFile(r, h);
       } else {
-        if (!n)
-          throw new c(\`Cannot copy directory without recursive option: \${e}\`, "EISDIR");
+        if (!i)
+          throw new c(\`Cannot copy directory without recursive option: \${t}\`, "EISDIR");
         await this.mkdir(r, { recursive: !0 });
-        const u = await this.readdir(e, { withFileTypes: !0 });
-        for (const f of u) {
-          const w = \`\${e}/\${f.name}\`, h = \`\${r}/\${f.name}\`;
-          await this.copy(w, h, { recursive: !0, force: i });
+        const h = await this.readdir(t, { withFileTypes: !0 });
+        for (const u of h) {
+          const w = \`\${t}/\${u.name}\`, f = \`\${r}/\${u.name}\`;
+          await this.copy(w, f, { recursive: !0, force: a });
         }
       }
-      this.notifyInternalChange(r, "create");
-    } catch (n) {
-      throw n instanceof c ? n : new c(\`Failed to copy from \${e} to \${r}\`, "CP_FAILED");
+      await this.notifyChange({ path: r, type: "added", isDirectory: !1 });
+    } catch (i) {
+      throw i instanceof c ? i : new c(\`Failed to copy from \${t} to \${r}\`, "CP_FAILED");
     }
   }
   /**
    * Start watching a file or directory for changes
    */
-  async watch(e) {
+  async watch(t) {
     await this.ensureMounted();
-    const r = C(e), a = await this.buildSnapshot(r);
-    this.watchers.set(r, a), this.watchTimer || (this.watchTimer = setInterval(() => {
+    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(e) {
-    const r = C(e);
+  unwatch(t) {
+    const r = C(t);
     this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
-  async buildSnapshot(e) {
-    const r = /* @__PURE__ */ new Map(), a = async (n) => {
-      const i = await this.stat(n);
-      if (r.set(n, i), i.isDirectory) {
-        const o = await this.readdir(n, { withFileTypes: !0 });
-        for (const s of o) {
-          const l = \`\${n === "/" ? "" : n}/\${s.name}\`;
-          await a(l);
+  async buildSnapshot(t) {
+    const r = /* @__PURE__ */ new Map(), n = async (i) => {
+      const a = await this.stat(i);
+      if (r.set(i, a), a.isDirectory) {
+        const s = await this.readdir(i, { withFileTypes: !0 });
+        for (const o of s) {
+          const l = \`\${i === "/" ? "" : i}/\${o.name}\`;
+          await n(l);
         }
       }
     };
-    return await a(e), r;
+    return await n(t), r;
   }
   async scanWatches() {
     if (!this.scanning) {
       this.scanning = !0;
       try {
         await Promise.all(
-          [...this.watchers.entries()].map(async ([e, r]) => {
-            let a;
+          [...this.watchers.entries()].map(async ([t, r]) => {
+            let n;
             try {
-              a = await this.buildSnapshot(e);
+              n = await this.buildSnapshot(t);
             } catch {
-              a = /* @__PURE__ */ new Map();
+              n = /* @__PURE__ */ new Map();
             }
-            const n = [];
-            for (const [i, o] of a) {
+            for (const [i, a] of n) {
               const s = r.get(i);
-              s ? (s.mtime !== o.mtime || s.size !== o.size) && n.push({ path: i, type: "change" }) : n.push({ path: i, type: "create" });
+              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 });
             }
             for (const i of r.keys())
-              a.has(i) || n.push({ path: i, type: "delete" });
-            if (n.length && this.watchCallback)
-              for (const i of n)
-                this.watchCallback(i);
-            this.watchers.set(e, a);
+              n.has(i) || await this.notifyChange({ path: i, type: "removed", isDirectory: !1 });
+            this.watchers.set(t, n);
           })
         );
       } finally {
@@ -1145,72 +1142,75 @@ class we {
    * await fs.sync(entries, { cleanBefore: true });
    * \`\`\`
    */
-  async sync(e, r) {
+  async sync(t, r) {
     await this.ensureMounted();
     try {
       (r?.cleanBefore ?? !1) && await this.clear("/");
-      for (const [n, i] of e) {
-        const o = C(n);
-        let s;
-        i instanceof Blob ? s = await he(i) : s = i, await this.writeFile(o, s);
+      for (const [i, a] of t) {
+        const s = C(i);
+        let o;
+        a instanceof Blob ? o = await ft(a) : o = a, await this.writeFile(s, o);
       }
-      this.notifyInternalChange("/", "change");
-    } catch (a) {
-      throw a instanceof c ? a : new c("Failed to sync file system", "SYNC_FAILED");
+      await this.notifyChange({ path: "/", type: "changed", isDirectory: !0 });
+    } catch (n) {
+      throw n instanceof c ? n : new c("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && O(new we());
-//# sourceMappingURL=worker-DCm4BiWM.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(t) {
+function s(e) {
   let n;
   try {
     if (n = r && (self.URL || self.webkitURL).createObjectURL(r), !n) throw "";
-    const e = new Worker(n, {
+    const t = new Worker(n, {
       type: "module",
-      name: t?.name
+      name: e?.name
     });
-    return e.addEventListener("error", () => {
+    return t.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(n);
-    }), e;
+    }), t;
   } catch {
     return new Worker(
       "data:text/javascript;charset=utf-8," + encodeURIComponent(a),
       {
         type: "module",
-        name: t?.name
+        name: e?.name
       }
     );
   }
 }
-function l(t, n) {
-  const e = i(new s());
-  return t && e.setWatchCallback(o(t), n), e;
+function h(e, n) {
+  const t = i(new s());
+  return e && t.setWatchCallback(
+    e ? o(e) : () => {
+    }
+  ), n && t.setOptions(n), t;
 }
 export {
   d as DirectoryNotFoundError,
-  u as FileNotFoundError,
-  p as OPFSError,
-  w as OPFSNotMountedError,
-  y as OPFSNotSupportedError,
+  p as FileNotFoundError,
+  u as OPFSError,
+  y as OPFSNotMountedError,
+  w as OPFSNotSupportedError,
   m as PathError,
   g as PermissionError,
   v as StorageError,
-  E as TimeoutError,
+  F as TimeoutError,
   S as basename,
-  F as calculateFileHash,
+  E as calculateFileHash,
   b as checkOPFSSupport,
   P as convertBlobToUint8Array,
   x as createBuffer,
-  l as createWorker,
+  h as createWorker,
   T as decodeBuffer,
-  I as dirname,
-  A as encodeString,
-  O as extname,
+  A as dirname,
+  O as encodeString,
+  D as extname,
   _ as joinPath,
-  C as normalizePath,
-  D as readFileData,
+  I as normalizePath,
+  C as readFileData,
   k as resolvePath,
   U as splitPath,
   R as writeFileData