opfs-worker 1.3.0 → 1.3.1

package/dist/index.js

@@ -1,12 +1,12 @@
 import { wrap as u } from "comlink";
-import { i as h, d as l, e as c } from "./helpers-BuGfPAg0.js";
-import { A as E, N as S, D as P, E as O, F, j as A, c as T, I as R, h as I, O as C, a as $, f as D, g as _, P as N, k as z, b as k, S as M, T as j, V as W, W as L, p as U, C as H, B, L as G, n as q, G as Y, z as V, l as X, M as Z, q as J, y as K, v as Q, o as nn, m as tn, u as en, t as rn, r as sn, H as an, x as on, K as cn, s as hn, J as ln, w as pn } from "./helpers-BuGfPAg0.js";
+import { i as h, d as l, e as c } from "./helpers-CKOebsbw.js";
+import { A as E, M as S, D as P, E as O, F, j as A, c as T, I as R, h as C, O as I, a as $, f as D, g as _, P as N, b as z, S as k, V as M, W as j, o as L, B as W, z as U, K as H, l as B, C as G, y as q, k as V, L as Y, p as J, x as X, u as Z, n as K, m as Q, t as nn, r as tn, q as en, G as rn, v as sn, J as an, s as on, H as cn, w as hn } from "./helpers-CKOebsbw.js";
 const f = `/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const bt = Symbol("Comlink.proxy"), Ht = Symbol("Comlink.endpoint"), Wt = Symbol("Comlink.releaseProxy"), J = Symbol("Comlink.finalizer"), U = Symbol("Comlink.thrown"), Ot = (s) => typeof s == "object" && s !== null || typeof s == "function", _t = {
+const bt = Symbol("Comlink.proxy"), Ht = Symbol("Comlink.endpoint"), Wt = Symbol("Comlink.releaseProxy"), J = Symbol("Comlink.finalizer"), U = Symbol("Comlink.thrown"), Ot = (s) => typeof s == "object" && s !== null || typeof s == "function", jt = {
   canHandle: (s) => Ot(s) && s[bt],
   serialize(s) {
     const { port1: t, port2: e } = new MessageChannel();
@@ -15,7 +15,7 @@ const bt = Symbol("Comlink.proxy"), Ht = Symbol("Comlink.endpoint"), Wt = Symbol
   deserialize(s) {
     return s.start(), Gt(s);
   }
-}, jt = {
+}, _t = {
   canHandle: (s) => Ot(s) && U in s,
   serialize({ value: s }) {
     let t;
@@ -32,8 +32,8 @@ const bt = Symbol("Comlink.proxy"), Ht = Symbol("Comlink.endpoint"), Wt = Symbol
     throw s.isError ? Object.assign(new Error(s.value.message), s.value) : s.value;
   }
 }, Dt = /* @__PURE__ */ new Map([
-  ["proxy", _t],
-  ["throw", jt]
+  ["proxy", jt],
+  ["throw", _t]
 ]);
 function Ut(s, t) {
   for (const e of s)
@@ -291,7 +291,7 @@ class w extends Error {
 }
 class Qt extends w {
   constructor(t) {
-    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED", void 0, void 0, t);
+    super("OPFS is not supported in this browser", "ENOTSUP", void 0, void 0, t);
   }
 }
 class Kt extends w {
@@ -311,7 +311,7 @@ class F extends w {
 }
 class te extends w {
   constructor(t, e, n) {
-    super(\`Permission denied for \${e} on: \${t}\`, "PERMISSION_DENIED", t, e, n);
+    super(\`Permission denied for \${e} on: \${t}\`, "EACCES", t, e, n);
   }
 }
 class ee extends w {
@@ -324,10 +324,10 @@ class se extends w {
     super(\`File is busy: \${t}\`, "EBUSY", t, "open", e);
   }
 }
-class L extends w {
-  constructor(t, e, n, r) {
-    const i = e === "directory" ? \`Is a directory: \${n}\` : \`Not a directory: \${n}\`, o = e === "directory" ? "EISDIR" : "ENOTDIR";
-    super(i, o, n, "access", r);
+class z extends w {
+  constructor(t, e, n) {
+    const r = t === "directory" ? \`Is a directory: \${e}\` : \`Not a directory: \${e}\`, i = t === "directory" ? "EISDIR" : "ENOTDIR";
+    super(r, i, e, "access", n);
   }
 }
 class N extends w {
@@ -359,15 +359,11 @@ class Ct extends w {
 class rt extends w {
   constructor(t, e, n) {
     const r = {
-      remove: \`Failed to remove entry: \${e}\`,
-      clear: \`Directory not empty: \${e}. Use recursive option to force removal.\`,
-      root: "Cannot remove root directory"
-    }, i = {
-      remove: "RM_FAILED",
-      clear: "ENOTEMPTY",
-      root: "EROOT"
+      RM_FAILED: \`Failed to remove entry: \${e}\`,
+      ENOTEMPTY: \`Directory not empty: \${e}. Use recursive option to force removal.\`,
+      EROOT: "Cannot remove root directory"
     };
-    super(r[t], i[t], e, "unlink", n);
+    super(r[t] || \`Directory operation failed: \${e}\`, t, e, "unlink", n);
   }
 }
 class re extends w {
@@ -385,7 +381,7 @@ class K extends w {
     super(\`Destination already exists: \${t}\`, "EEXIST", t, "open", e);
   }
 }
-function _(s, t, e, n) {
+function j(s, t, e, n) {
   const r = \`\${s.toUpperCase()}_FAILED\`;
   return new w(\`Failed to \${s} file descriptor: \${t}\`, r, e, s, n);
 }
@@ -399,7 +395,7 @@ function A(s, t) {
     case "NotFoundError":
       return new F("file", e, s);
     case "TypeMismatchError":
-      return n !== void 0 ? n ? new L("file", "directory", e || "unknown", s) : new L("directory", "file", e || "unknown", s) : new N("argument", \`Type mismatch: \${e || "unknown"}\`, e, s);
+      return n !== void 0 ? n ? new z("directory", e || "unknown", s) : new z("file", e || "unknown", s) : new N("argument", \`Type mismatch: \${e || "unknown"}\`, e, s);
     case "NotAllowedError":
     case "SecurityError":
       return new te(e, "unknown", s);
@@ -606,7 +602,7 @@ const Oe = 1024 * 64, Z = (s) => {
   }
   const u = "[" + (h ? "^" : "") + dt(n) + "]", d = "[" + (h ? "" : "^") + dt(r) + "]";
   return [n.length && r.length ? "(" + u + "|" + d + ")" : n.length ? u : d, a, c - e, !0];
-}, k = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/\\[([^\\/\\\\])\\]/g, "$1") : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, "$1$2").replace(/\\\\([^\\/])/g, "$1"), Ne = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), pt = (s) => Ne.has(s), Ce = "(?!(?:^|/)\\\\.\\\\.?(?:$|/))", j = "(?!\\\\.)", Fe = /* @__PURE__ */ new Set(["[", "."]), $e = /* @__PURE__ */ new Set(["..", "."]), Me = new Set("().*{}+?[]^$\\\\!"), Pe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), ct = "[^/]", gt = ct + "*?", wt = ct + "+?";
+}, k = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/\\[([^\\/\\\\])\\]/g, "$1") : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, "$1$2").replace(/\\\\([^\\/])/g, "$1"), Ne = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), pt = (s) => Ne.has(s), Ce = "(?!(?:^|/)\\\\.\\\\.?(?:$|/))", _ = "(?!\\\\.)", Fe = /* @__PURE__ */ new Set(["[", "."]), $e = /* @__PURE__ */ new Set(["..", "."]), Me = new Set("().*{}+?[]^$\\\\!"), Pe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), ct = "[^/]", gt = ct + "*?", wt = ct + "+?";
 class E {
   type;
   #s;
@@ -870,7 +866,7 @@ class E {
           h.startsWith("\\\\.") && g.has(h.charAt(2)) || // the pattern starts with \\.\\., and then [ or .
           h.startsWith("\\\\.\\\\.") && g.has(h.charAt(4))
         ), S = !e && !t && g.has(h.charAt(0));
-        c = p ? Ce : S ? j : "";
+        c = p ? Ce : S ? _ : "";
       }
       let f = "";
       return this.isEnd() && this.#s.#a && this.#e?.type === "!" && (f = "(?:$|\\\\/)"), [
@@ -886,15 +882,15 @@ class E {
       const l = this.toString();
       return this.#t = [l], this.type = null, this.#n = void 0, [l, k(this.toString()), !1, !1];
     }
-    let o = !n || t || e || !j ? "" : this.#f(!0);
+    let o = !n || t || e || !_ ? "" : this.#f(!0);
     o === i && (o = ""), o && (i = \`(?:\${i})(?:\${o})*?\`);
     let a = "";
     if (this.type === "!" && this.#u)
-      a = (this.isStart() && !e ? j : "") + wt;
+      a = (this.isStart() && !e ? _ : "") + wt;
     else {
       const l = this.type === "!" ? (
         // !() must match something,but !(x) can match ''
-        "))" + (this.isStart() && !e && !t ? j : "") + gt + ")"
+        "))" + (this.isStart() && !e && !t ? _ : "") + gt + ")"
       ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : \`)\${this.type}\`;
       a = r + i + l;
     }
@@ -945,7 +941,7 @@ class E {
     return [i, k(t), !!e, o];
   }
 }
-const Te = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\]]/g, "[$&]") : s.replace(/[?*()[\\]\\\\]/g, "\\\\$&"), y = (s, t, e = {}) => (Z(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new X(t, e).match(s)), Re = /^\\*+([^+@!?\\*\\[\\(]*)$/, Ie = (s) => (t) => !t.startsWith(".") && t.endsWith(s), ke = (s) => (t) => t.endsWith(s), ze = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), Le = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), He = /^\\*+\\.\\*+$/, We = (s) => !s.startsWith(".") && s.includes("."), _e = (s) => s !== "." && s !== ".." && s.includes("."), je = /^\\.\\*+$/, Ue = (s) => s !== "." && s !== ".." && s.startsWith("."), Be = /^\\*+$/, Ge = (s) => s.length !== 0 && !s.startsWith("."), qe = (s) => s.length !== 0 && s !== "." && s !== "..", Ve = /^\\?+([^+@!?\\*\\[\\(]*)?$/, Ye = ([s, t = ""]) => {
+const Te = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\]]/g, "[$&]") : s.replace(/[?*()[\\]\\\\]/g, "\\\\$&"), y = (s, t, e = {}) => (Z(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new X(t, e).match(s)), Re = /^\\*+([^+@!?\\*\\[\\(]*)$/, Ie = (s) => (t) => !t.startsWith(".") && t.endsWith(s), ke = (s) => (t) => t.endsWith(s), Le = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), ze = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), He = /^\\*+\\.\\*+$/, We = (s) => !s.startsWith(".") && s.includes("."), je = (s) => s !== "." && s !== ".." && s.includes("."), _e = /^\\.\\*+$/, Ue = (s) => s !== "." && s !== ".." && s.startsWith("."), Be = /^\\*+$/, Ge = (s) => s.length !== 0 && !s.startsWith("."), qe = (s) => s.length !== 0 && s !== "." && s !== "..", Ve = /^\\?+([^+@!?\\*\\[\\(]*)?$/, Ye = ([s, t = ""]) => {
   const e = It([s]);
   return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
 }, Ze = ([s, t = ""]) => {
@@ -963,10 +959,10 @@ const Te = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\
 }, kt = ([s]) => {
   const t = s.length;
   return (e) => e.length === t && e !== "." && e !== "..";
-}, zt = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", mt = {
+}, Lt = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", mt = {
   win32: { sep: "\\\\" },
   posix: { sep: "/" }
-}, Qe = zt === "win32" ? mt.win32.sep : mt.posix.sep;
+}, Qe = Lt === "win32" ? mt.win32.sep : mt.posix.sep;
 y.sep = Qe;
 const O = Symbol("globstar **");
 y.GLOBSTAR = O;
@@ -1007,8 +1003,8 @@ const b = (s, t = {}) => Object.assign({}, s, t), rs = (s) => {
   });
 };
 y.defaults = rs;
-const Lt = (s, t = {}) => (Z(s), t.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(s) ? [s] : ye(s));
-y.braceExpand = Lt;
+const zt = (s, t = {}) => (Z(s), t.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(s) ? [s] : ye(s));
+y.braceExpand = zt;
 const is = (s, t = {}) => new X(s, t).makeRe();
 y.makeRe = is;
 const os = (s, t, e = {}) => {
@@ -1036,7 +1032,7 @@ class X {
   windowsNoMagicRoot;
   regexp;
   constructor(t, e = {}) {
-    Z(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || zt, this.isWindows = this.platform === "win32", this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+    Z(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || Lt, this.isWindows = this.platform === "win32", this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
   }
   hasMagic() {
     if (this.options.magicalBraces && this.set.length > 1)
@@ -1293,7 +1289,7 @@ globstar while\`, t, u, e, d, g), this.matchOne(t.slice(u), e.slice(d), n))
     throw new Error("wtf?");
   }
   braceExpand() {
-    return Lt(this.pattern, this.options);
+    return zt(this.pattern, this.options);
   }
   parse(t) {
     Z(t);
@@ -1303,7 +1299,7 @@ globstar while\`, t, u, e, d, g), this.matchOne(t.slice(u), e.slice(d), n))
     if (t === "")
       return "";
     let n, r = null;
-    (n = t.match(Be)) ? r = e.dot ? qe : Ge : (n = t.match(Re)) ? r = (e.nocase ? e.dot ? Le : ze : e.dot ? ke : Ie)(n[1]) : (n = t.match(Ve)) ? r = (e.nocase ? e.dot ? Ze : Ye : e.dot ? Xe : Je)(n) : (n = t.match(He)) ? r = e.dot ? _e : We : (n = t.match(je)) && (r = Ue);
+    (n = t.match(Be)) ? r = e.dot ? qe : Ge : (n = t.match(Re)) ? r = (e.nocase ? e.dot ? ze : Le : e.dot ? ke : Ie)(n[1]) : (n = t.match(Ve)) ? r = (e.nocase ? e.dot ? Ze : Ye : e.dot ? Xe : Je)(n) : (n = t.match(He)) ? r = e.dot ? je : We : (n = t.match(_e)) && (r = Ue);
     const i = E.fromGlob(t, this.options).toMMPattern();
     return r && typeof i == "object" && Reflect.defineProperty(i, "test", { value: r }), i;
   }
@@ -1375,7 +1371,7 @@ function cs() {
   if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
     throw new Qt();
 }
-async function z(s, t, e) {
+async function L(s, t, e) {
   return typeof navigator < "u" && navigator.locks?.request ? navigator.locks.request(\`opfs:\${s.replace(/\\/+/g, "/")}\`, { mode: t }, e) : e();
 }
 function M(s) {
@@ -1428,7 +1424,7 @@ async function us(s) {
 }
 async function fs(s, t, e = {}) {
   const n = it(t);
-  return z(t, "exclusive", async () => {
+  return L(t, "exclusive", async () => {
     const r = e.recursive ?? !1, i = e.force ?? !1;
     try {
       await s.removeEntry(n, { recursive: r });
@@ -1436,7 +1432,7 @@ async function fs(s, t, e = {}) {
       if (o.name === "NotFoundError") {
         if (!i)
           throw new F("file", t, o);
-      } else throw o.name === "InvalidModificationError" ? new rt("clear", t, o) : o.name === "TypeMismatchError" && !r ? new L("file", "directory", t, o) : new rt("remove", t, o);
+      } else throw o.name === "InvalidModificationError" ? new rt("ENOTEMPTY", t, o) : o.name === "TypeMismatchError" && !r ? new z("directory", t, o) : new rt("RM_FAILED", t, o);
     }
   });
 }
@@ -1709,7 +1705,7 @@ class gs {
   async readFile(t) {
     await this.mount();
     try {
-      return await z(t, "shared", async () => {
+      return await L(t, "shared", async () => {
         const e = await this.open(t);
         try {
           const { size: n } = await this.fstat(e), r = new Uint8Array(n);
@@ -1747,7 +1743,7 @@ class gs {
   async writeFile(t, e) {
     await this.mount();
     const n = e instanceof Uint8Array ? e : new Uint8Array(e);
-    await z(t, "exclusive", async () => {
+    await L(t, "exclusive", async () => {
       const r = await this.exists(t), i = await this.open(t, { create: !0, truncate: !0 });
       try {
         await this.write(i, n, 0, n.length, null, !1), await this.fsync(i);
@@ -1782,7 +1778,7 @@ class gs {
   async appendFile(t, e) {
     await this.mount();
     const n = e instanceof Uint8Array ? e : new Uint8Array(e);
-    await z(t, "exclusive", async () => {
+    await L(t, "exclusive", async () => {
       const r = await this.open(t, { create: !0 });
       try {
         const { size: i } = await this.fstat(r);
@@ -1823,7 +1819,7 @@ class gs {
       try {
         i = await i.getDirectoryHandle(a, { create: n || o === r.length - 1 });
       } catch (l) {
-        throw l.name === "NotFoundError" ? new F("directory", lt(r.slice(0, o + 1)), l) : l.name === "TypeMismatchError" ? new L("directory", "file", a, l) : new Q("create directory", a, l);
+        throw l.name === "NotFoundError" ? new F("directory", lt(r.slice(0, o + 1)), l) : l.name === "TypeMismatchError" ? new z("file", a, l) : new Q("create directory", a, l);
       }
     }
     await this.notifyChange({ path: t, type: D.Added, isDirectory: !0 });
@@ -2032,7 +2028,7 @@ class gs {
    */
   async remove(t, e) {
     if (await this.mount(), t === "/")
-      throw new rt("root", t);
+      throw new rt("EROOT", t);
     const { recursive: n = !1, force: r = !1 } = e || {}, i = await this.getDirectoryHandle(et(t), !1), o = await this.stat(t);
     await fs(i, t, { recursive: n, force: r }), await this.notifyChange({ path: t, type: D.Removed, isDirectory: o.isDirectory });
   }
@@ -2136,7 +2132,7 @@ class gs {
         await this.writeFile(e, h);
       } else {
         if (!r)
-          throw new L("file", "directory", t);
+          throw new z("directory", t);
         await this.mkdir(e, { recursive: !0 });
         const h = await this.readDir(t);
         for (const c of h) {
@@ -2220,7 +2216,7 @@ class gs {
     await this.mount();
     const { create: n = !1, exclusive: r = !1, truncate: i = !1 } = e || {}, o = G(Et(t));
     try {
-      return n && r ? await z(o, "exclusive", async () => {
+      return n && r ? await L(o, "exclusive", async () => {
         if (await this.exists(o))
           throw new K(o);
         return this._openFile(o, n, i);
@@ -2302,7 +2298,7 @@ class gs {
       const f = e.subarray(n, n + c), u = o.syncHandle.read(f, { at: a });
       return i == null && (o.position = a + u), B({ bytesRead: u, buffer: e }, [e.buffer]);
     } catch (a) {
-      throw _("read", t, o.path, a);
+      throw j("read", t, o.path, a);
     }
   }
   /**
@@ -2333,7 +2329,7 @@ class gs {
       const h = i ?? a.position, c = e.subarray(n, n + l), f = a.syncHandle.write(c, { at: h });
       return (i == null || i === a.position) && (a.position = h + f), o && await this.notifyChange({ path: a.path, type: D.Changed, isDirectory: !1 }), f;
     } catch (h) {
-      throw _("write", t, a.path, h);
+      throw j("write", t, a.path, h);
     }
   }
   /**
@@ -2381,7 +2377,7 @@ class gs {
     try {
       n.syncHandle.truncate(e), n.syncHandle.flush(), n.position > e && (n.position = e), await this.notifyChange({ path: n.path, type: D.Changed, isDirectory: !1 });
     } catch (r) {
-      throw _("truncate", t, n.path, r);
+      throw j("truncate", t, n.path, r);
     }
   }
   /**
@@ -2403,7 +2399,7 @@ class gs {
     try {
       e.syncHandle.flush();
     } catch (n) {
-      throw _("sync", t, e.path, n);
+      throw j("sync", t, e.path, n);
     }
   }
   /**
@@ -2460,7 +2456,7 @@ class gs {
   }
 }
 typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && ot(new gs());
-//# sourceMappingURL=worker-1Wh1cr7P.js.map
+//# sourceMappingURL=worker-BeJaVyBV.js.map
 `, p = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", f], { type: "text/javascript;charset=utf-8" });
 function m(a) {
   let n;
@@ -2747,45 +2743,43 @@ export {
   A as FileSystemOperationError,
   T as FileTypeError,
   R as IOError,
-  I as InitializationFailedError,
-  C as OPFSError,
+  C as InitializationFailedError,
+  I as OPFSError,
   y as OPFSFileSystem,
   $ as OPFSNotSupportedError,
   D as OperationAbortedError,
   _ as OperationNotSupportedError,
   N as PathError,
-  z as PathResolutionFailedError,
-  k as PermissionError,
-  M as StorageError,
-  j as TimeoutError,
-  W as ValidationError,
-  L as WatchEventType,
-  U as basename,
-  H as buffersEqual,
-  B as calculateFileHash,
-  G as calculateReadLength,
-  q as checkOPFSSupport,
-  Y as convertBlobToUint8Array,
-  V as createBuffer,
-  X as createFDError,
-  Z as createSyncHandleSafe,
+  z as PermissionError,
+  k as StorageError,
+  M as ValidationError,
+  j as WatchEventType,
+  L as basename,
+  W as buffersEqual,
+  U as calculateFileHash,
+  H as calculateReadLength,
+  B as checkOPFSSupport,
+  G as convertBlobToUint8Array,
+  q as createBuffer,
+  V as createFDError,
+  Y as createSyncHandleSafe,
   b as createWorker,
   l as decodeBuffer,
   J as dirname,
   c as encodeString,
-  K as extname,
+  X as extname,
   h as isBinaryFileExtension,
-  Q as isPathExcluded,
-  nn as joinPath,
-  tn as mapDomError,
-  en as matchMinimatch,
-  rn as normalizeMinimatch,
-  sn as normalizePath,
-  an as removeEntry,
-  on as resolvePath,
-  cn as safeCloseSyncHandle,
-  hn as splitPath,
-  ln as validateReadWriteArgs,
-  pn as withLock
+  Z as isPathExcluded,
+  K as joinPath,
+  Q as mapDomError,
+  nn as matchMinimatch,
+  tn as normalizeMinimatch,
+  en as normalizePath,
+  rn as removeEntry,
+  sn as resolvePath,
+  an as safeCloseSyncHandle,
+  on as splitPath,
+  cn as validateReadWriteArgs,
+  hn as withLock
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    BinaryEncoding,\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    PathLike,\n    RemoteOPFSWorker,\n    RenameOptions,\n    StringEncoding,\n    WatchOptions\n} from './types';\n\n/**\n * Utility function to convert a PathLike to a string path\n * If it's a URI, extracts the pathname; otherwise returns the string as-is\n */\nfunction normalizePath(path: PathLike): string {\n    if (path instanceof URL) {\n        return path.pathname;\n    }\n\n    return path;\n}\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n    promises: OPFSFileSystem = this;\n\n    constructor(options?: OPFSOptions) {\n        this.#worker = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: PathLike, options?: WatchOptions): () => void {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.watch(normalizedPath, options);\n\n        return () => this.unwatch(normalizedPath);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: PathLike) {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.unwatch(normalizedPath);\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    // Overload for explicit string encoding - returns string\n    async readFile(path: PathLike, encoding: StringEncoding): Promise<string>;\n    // Overload for explicit binary encoding - returns Uint8Array\n    async readFile(path: PathLike, encoding: BinaryEncoding): Promise<Uint8Array>;\n    // Overload for options object with string encoding - returns string\n    async readFile(path: PathLike, options: { encoding: StringEncoding }): Promise<string>;\n    // Overload for options object with binary encoding - returns Uint8Array\n    async readFile(path: PathLike, options: { encoding: BinaryEncoding }): Promise<Uint8Array>;\n    // Overload for no encoding (auto-detected) - returns string | Uint8Array based on file extension\n    async readFile(path: PathLike): Promise<string | Uint8Array>;\n    // Implementation\n    async readFile(\n        path: PathLike,\n        optionsOrEncoding?: Encoding | { encoding?: Encoding }\n    ): Promise<string | Uint8Array> {\n        const normalizedPath = normalizePath(path);\n\n        // Handle both options object and direct encoding parameter for backward compatibility\n        let encoding: Encoding | undefined;\n\n        if (typeof optionsOrEncoding === 'string') {\n            encoding = optionsOrEncoding;\n        }\n        else if (optionsOrEncoding && typeof optionsOrEncoding === 'object') {\n            encoding = optionsOrEncoding.encoding;\n        }\n\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(normalizedPath) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        options?: { encoding?: Encoding } | Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        let encoding: Encoding | undefined;\n\n        if (typeof options === 'string') {\n            encoding = options;\n        }\n        else if (options && typeof options === 'object') {\n            encoding = options.encoding;\n        }\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: PathLike, mode?: number | { recursive?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        let options: { recursive?: boolean } | undefined;\n\n        // OPFS doesn't support file modes, so we ignore the mode parameter\n        if (typeof mode === 'number') {\n            options = { recursive: false };\n        }\n        else {\n            options = mode;\n        }\n\n        return this.#worker.mkdir(normalizedPath, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: PathLike): Promise<FileStat> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.stat(normalizedPath);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: PathLike): Promise<DirentData[]> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.readDir(normalizedPath);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: PathLike): Promise<boolean> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.exists(normalizedPath);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: PathLike): Promise<void> {\n        const normalizedPath = path ? normalizePath(path) : undefined;\n\n        return this.#worker.clear(normalizedPath);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.remove(normalizedPath, options);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async unlink(path: PathLike): Promise<void> {\n        return this.remove(path);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async rm(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        return this.remove(path, options);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async rmdir(path: PathLike): Promise<void> {\n        return this.remove(path);\n    }\n\n    /**\n     * Alias for readDir() for NodeJS like API compatibility\n     */\n    async readdir(path: PathLike, _options?: unknown): Promise<DirentData[]> {\n        return this.readDir(path);\n    }\n\n    /**\n     * Alias for stat() for NodeJS like API compatibility\n     */\n    async lstat(path: PathLike): Promise<FileStat> {\n        return this.stat(path);\n    }\n\n    /**\n     * Note: OPFS doesn't support file modes, so this is a no-op and exists only for compatibility with tools like isomorphic-git\n     */\n    async chmod(_path: PathLike, _mode: number): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: PathLike): Promise<string> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.realpath(normalizedPath);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: PathLike, newPath: PathLike, options?: RenameOptions): Promise<void> {\n        const normalizedOldPath = normalizePath(oldPath);\n        const normalizedNewPath = normalizePath(newPath);\n\n        return this.#worker.rename(normalizedOldPath, normalizedNewPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: PathLike, destination: PathLike, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        const normalizedSource = normalizePath(source);\n        const normalizedDestination = normalizePath(destination);\n\n        return this.#worker.copy(normalizedSource, normalizedDestination, options);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: PathLike, options?: FileOpenOptions): Promise<number> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.open(normalizedPath, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async createIndex(entries: [PathLike, string | Uint8Array | Blob][]): Promise<void> {\n        const normalizedEntries = entries.map(([path, data]) => [normalizePath(path), data] as [string, string | Uint8Array | Blob]);\n\n        return this.#worker.createIndex(normalizedEntries);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: PathLike, encoding: Encoding = 'utf-8'): Promise<string> {\n        const normalizedPath = normalizePath(path);\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\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): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["normalizePath","path","OPFSFileSystem","#worker","options","wrap","WorkerCtor","normalizedPath","optionsOrEncoding","encoding","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","mode","_options","_path","_mode","oldPath","newPath","normalizedOldPath","normalizedNewPath","source","destination","normalizedSource","normalizedDestination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","normalizedEntries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.js","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    BinaryEncoding,\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    PathLike,\n    RemoteOPFSWorker,\n    RenameOptions,\n    StringEncoding,\n    WatchOptions\n} from './types';\n\n/**\n * Utility function to convert a PathLike to a string path\n * If it's a URI, extracts the pathname; otherwise returns the string as-is\n */\nfunction normalizePath(path: PathLike): string {\n    if (path instanceof URL) {\n        return path.pathname;\n    }\n\n    return path;\n}\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n    promises: OPFSFileSystem = this;\n\n    constructor(options?: OPFSOptions) {\n        this.#worker = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: PathLike, options?: WatchOptions): () => void {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.watch(normalizedPath, options);\n\n        return () => this.unwatch(normalizedPath);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: PathLike) {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.unwatch(normalizedPath);\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    // Overload for explicit string encoding - returns string\n    async readFile(path: PathLike, encoding: StringEncoding): Promise<string>;\n    // Overload for explicit binary encoding - returns Uint8Array\n    async readFile(path: PathLike, encoding: BinaryEncoding): Promise<Uint8Array>;\n    // Overload for options object with string encoding - returns string\n    async readFile(path: PathLike, options: { encoding: StringEncoding }): Promise<string>;\n    // Overload for options object with binary encoding - returns Uint8Array\n    async readFile(path: PathLike, options: { encoding: BinaryEncoding }): Promise<Uint8Array>;\n    // Overload for no encoding (auto-detected) - returns string | Uint8Array based on file extension\n    async readFile(path: PathLike): Promise<string | Uint8Array>;\n    // Implementation\n    async readFile(\n        path: PathLike,\n        optionsOrEncoding?: Encoding | { encoding?: Encoding }\n    ): Promise<string | Uint8Array> {\n        const normalizedPath = normalizePath(path);\n\n        // Handle both options object and direct encoding parameter for backward compatibility\n        let encoding: Encoding | undefined;\n\n        if (typeof optionsOrEncoding === 'string') {\n            encoding = optionsOrEncoding;\n        }\n        else if (optionsOrEncoding && typeof optionsOrEncoding === 'object') {\n            encoding = optionsOrEncoding.encoding;\n        }\n\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(normalizedPath) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        options?: { encoding?: Encoding } | Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        let encoding: Encoding | undefined;\n\n        if (typeof options === 'string') {\n            encoding = options;\n        }\n        else if (options && typeof options === 'object') {\n            encoding = options.encoding;\n        }\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: PathLike, mode?: number | { recursive?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        let options: { recursive?: boolean } | undefined;\n\n        // OPFS doesn't support file modes, so we ignore the mode parameter\n        if (typeof mode === 'number') {\n            options = { recursive: false };\n        }\n        else {\n            options = mode;\n        }\n\n        return this.#worker.mkdir(normalizedPath, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: PathLike): Promise<FileStat> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.stat(normalizedPath);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: PathLike): Promise<DirentData[]> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.readDir(normalizedPath);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: PathLike): Promise<boolean> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.exists(normalizedPath);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: PathLike): Promise<void> {\n        const normalizedPath = path ? normalizePath(path) : undefined;\n\n        return this.#worker.clear(normalizedPath);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.remove(normalizedPath, options);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async unlink(path: PathLike): Promise<void> {\n        return this.remove(path);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async rm(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        return this.remove(path, options);\n    }\n\n    /**\n     * Alias for remove() for NodeJS like API compatibility\n     */\n    async rmdir(path: PathLike): Promise<void> {\n        return this.remove(path);\n    }\n\n    /**\n     * Alias for readDir() for NodeJS like API compatibility\n     */\n    async readdir(path: PathLike, _options?: unknown): Promise<DirentData[]> {\n        return this.readDir(path);\n    }\n\n    /**\n     * Alias for stat() for NodeJS like API compatibility\n     */\n    async lstat(path: PathLike): Promise<FileStat> {\n        return this.stat(path);\n    }\n\n    /**\n     * Note: OPFS doesn't support file modes, so this is a no-op and exists only for compatibility with tools like isomorphic-git\n     */\n    async chmod(_path: PathLike, _mode: number): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: PathLike): Promise<string> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.realpath(normalizedPath);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: PathLike, newPath: PathLike, options?: RenameOptions): Promise<void> {\n        const normalizedOldPath = normalizePath(oldPath);\n        const normalizedNewPath = normalizePath(newPath);\n\n        return this.#worker.rename(normalizedOldPath, normalizedNewPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: PathLike, destination: PathLike, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        const normalizedSource = normalizePath(source);\n        const normalizedDestination = normalizePath(destination);\n\n        return this.#worker.copy(normalizedSource, normalizedDestination, options);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: PathLike, options?: FileOpenOptions): Promise<number> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.open(normalizedPath, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async createIndex(entries: [PathLike, string | Uint8Array | Blob][]): Promise<void> {\n        const normalizedEntries = entries.map(([path, data]) => [normalizePath(path), data] as [string, string | Uint8Array | Blob]);\n\n        return this.#worker.createIndex(normalizedEntries);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: PathLike, encoding: Encoding = 'utf-8'): Promise<string> {\n        const normalizedPath = normalizePath(path);\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\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): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["normalizePath","path","OPFSFileSystem","#worker","options","wrap","WorkerCtor","normalizedPath","optionsOrEncoding","encoding","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","mode","_options","_path","_mode","oldPath","newPath","normalizedOldPath","normalizedNewPath","source","destination","normalizedSource","normalizedDestination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","normalizedEntries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/raw.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("comlink"),i=require("./helpers-CF7A2WQG.cjs");class d{root;watchers=new Map;mountingPromise=null;broadcastChannel=null;options={root:"/",namespace:"",maxFileSize:50*1024*1024,hashAlgorithm:"etag",broadcastChannel:"opfs-worker"};openFiles=new Map;nextFd=1;_getFileDescriptor(t){const e=this.openFiles.get(t);if(!e)throw new i.ValidationError("descriptor",`Invalid file descriptor: ${t}`);return e}async notifyChange(t){if(!this.options.broadcastChannel)return;const e=t.path;if(![...this.watchers.values()].some(s=>i.matchMinimatch(e,s.pattern)&&s.include.some(n=>n&&i.matchMinimatch(e,n))&&!s.exclude.some(n=>n&&i.matchMinimatch(e,n))))return;let r;if(this.options.hashAlgorithm)try{r=(await this.stat(e)).hash}catch{}try{this.broadcastChannel||(this.broadcastChannel=new BroadcastChannel(this.options.broadcastChannel));const s={namespace:this.options.namespace,timestamp:new Date().toISOString(),...t,...r&&{hash:r}};this.broadcastChannel.postMessage(s)}catch(s){console.warn("Failed to send event via BroadcastChannel:",s)}}constructor(t){i.checkOPFSSupport(),t&&this.setOptions(t)}async mount(){const t=this.options.root;return this.mountingPromise&&await this.mountingPromise,this.mountingPromise=new Promise(async(e,a)=>{try{const r=await navigator.storage.getDirectory();this.root=t==="/"?r:await this.getDirectoryHandle(t,!0,r),e(!0)}catch(r){a(new i.InitializationFailedError(t,r))}finally{this.mountingPromise=null}}),this.mountingPromise}async setOptions(t){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),t.namespace&&(this.options.namespace=t.namespace),t.root!==void 0&&(this.options.root=i.normalizePath(t.root),this.options.namespace||(this.options.namespace=`opfs-worker:${this.options.root}`),await this.mount())}async getDirectoryHandle(t,e=!1,a=this.root){const r=Array.isArray(t)?t:i.splitPath(t);let s=a;for(const n of r)s=await s.getDirectoryHandle(n,{create:e});return s}async getFileHandle(t,e=!1,a=this.root){const r=i.splitPath(t);if(r.length===0)throw new i.PathError("Path must not be empty",Array.isArray(t)?t.join("/"):t);const s=r.pop();return(await this.getDirectoryHandle(r,e,a)).getFileHandle(s,{create:e})}async index(){const t=new Map,e=async a=>{const r=await this.readDir(a);for(const s of r){const n=`${a==="/"?"":a}/${s.name}`;try{const o=await this.stat(n);t.set(n,o),o.isDirectory&&await e(n)}catch(o){console.warn(`Skipping broken entry: ${n}`,o)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t){await this.mount();try{return await i.withLock(t,"shared",async()=>{const e=await this.open(t);try{const{size:a}=await this.fstat(e),r=new Uint8Array(a);return a>0&&await this.read(e,r,0,a,0),f.transfer(r,[r.buffer])}finally{await this.close(e)}})}catch(e){throw new i.ExistenceError("file",t,e)}}async writeFile(t,e){await this.mount();const a=e instanceof Uint8Array?e:new Uint8Array(e);await i.withLock(t,"exclusive",async()=>{const r=await this.exists(t),s=await this.open(t,{create:!0,truncate:!0});try{await this.write(s,a,0,a.length,null,!1),await this.fsync(s)}finally{await this.close(s)}await this.notifyChange({path:t,type:r?i.WatchEventType.Changed:i.WatchEventType.Added,isDirectory:!1})})}async appendFile(t,e){await this.mount();const a=e instanceof Uint8Array?e:new Uint8Array(e);await i.withLock(t,"exclusive",async()=>{const r=await this.open(t,{create:!0});try{const{size:s}=await this.fstat(r);await this.write(r,a,0,a.length,s,!1),await this.fsync(r)}finally{await this.close(r)}await this.notifyChange({path:t,type:i.WatchEventType.Changed,isDirectory:!1})})}async mkdir(t,e){await this.mount();const a=e?.recursive??!1,r=i.splitPath(t);let s=this.root;for(let n=0;n<r.length;n++){const o=r[n];try{s=await s.getDirectoryHandle(o,{create:a||n===r.length-1})}catch(c){throw c.name==="NotFoundError"?new i.ExistenceError("directory",i.joinPath(r.slice(0,n+1)),c):c.name==="TypeMismatchError"?new i.FileTypeError("directory","file",o,c):new i.FileSystemOperationError("create directory",o,c)}}await this.notifyChange({path:t,type:i.WatchEventType.Added,isDirectory:!0})}async stat(t){if(await this.mount(),t==="/")return{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0};const e=i.basename(t);let a;try{a=await this.getDirectoryHandle(i.dirname(t),!1);const r=this.options.hashAlgorithm,n=await(await a.getFileHandle(e,{create:!1})).getFile(),o={kind:"file",size:n.size,mtime:new Date(n.lastModified).toISOString(),ctime:new Date(n.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(r==="etag")o.hash=`${n.lastModified.toString(36)}-${n.size.toString(36)}`;else if(typeof r=="string")try{const c=await i.calculateFileHash(n,r,this.options.maxFileSize);o.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return o}catch(r){if(r.name==="NotFoundError")throw new i.ExistenceError("file",t,r);if(r.name!=="TypeMismatchError")throw new i.FileSystemOperationError("stat",t,r)}try{return await a.getDirectoryHandle(e,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(r){throw new i.FileSystemOperationError("stat",t,r)}}async readDir(t){await this.mount();const e=await this.getDirectoryHandle(t,!1),a=[];for await(const[r,s]of e.entries()){const n=s.kind==="file";a.push({name:r,kind:s.kind,isFile:n,isDirectory:!n})}return a}async exists(t){if(await this.mount(),t==="/")return!0;const e=i.basename(t);let a=null;try{a=await this.getDirectoryHandle(i.dirname(t),!1)}catch(r){if(a=null,r.name!=="NotFoundError"&&r.name!=="TypeMismatchError")throw r}if(!a||!e)return!1;try{return await a.getFileHandle(e,{create:!1}),!0}catch(r){if(r.name!=="NotFoundError"&&r.name!=="TypeMismatchError")throw r;try{return await a.getDirectoryHandle(e,{create:!1}),!0}catch(s){if(s.name!=="NotFoundError"&&s.name!=="TypeMismatchError")throw s;return!1}}}async clear(t="/"){await this.mount();try{const e=await this.readDir(t);for(const a of e){const r=`${t==="/"?"":t}/${a.name}`;await this.remove(r,{recursive:!0})}await this.notifyChange({path:t,type:i.WatchEventType.Changed,isDirectory:!0})}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e,{path:t,isDirectory:!0})}}async remove(t,e){if(await this.mount(),t==="/")throw new i.DirectoryOperationError("root",t);const{recursive:a=!1,force:r=!1}=e||{},s=await this.getDirectoryHandle(i.dirname(t),!1),n=await this.stat(t);await i.removeEntry(s,t,{recursive:a,force:r}),await this.notifyChange({path:t,type:i.WatchEventType.Removed,isDirectory:n.isDirectory})}async realpath(t){await this.mount();try{const e=i.resolvePath(t);if(!await this.exists(e))throw new i.ExistenceError("file",e);return e}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e,{path:t})}}async rename(t,e,a){await this.mount();try{const r=a?.overwrite??!1,s=await this.stat(t);if(await this.exists(e)&&!r)throw new i.AlreadyExistsError(e);await this.copy(t,e,{recursive:!0,overwrite:r}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:i.WatchEventType.Removed,isDirectory:s.isDirectory}),await this.notifyChange({path:e,type:i.WatchEventType.Added,isDirectory:s.isDirectory})}catch(r){throw r instanceof i.OPFSError?r:i.mapDomError(r,{path:t})}}async copy(t,e,a){await this.mount();try{const r=a?.recursive??!1,s=a?.overwrite??!0;if(!await this.exists(t))throw new i.ExistenceError("source",t);if(await this.exists(e)&&!s)throw new i.AlreadyExistsError(e);if((await this.stat(t)).isFile){const h=await this.readFile(t);await this.writeFile(e,h)}else{if(!r)throw new i.FileTypeError("file","directory",t);await this.mkdir(e,{recursive:!0});const h=await this.readDir(t);for(const l of h){const y=`${t}/${l.name}`,w=`${e}/${l.name}`;await this.copy(y,w,{recursive:!0,overwrite:s})}}}catch(r){throw r instanceof i.OPFSError?r:i.mapDomError(r,{path:t})}}async watch(t,e){if(!this.options.broadcastChannel)throw new i.OperationNotSupportedError("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.");const a={pattern:i.normalizeMinimatch(t,e?.recursive??!0),include:Array.isArray(e?.include)?e.include:[e?.include??"**"],exclude:Array.isArray(e?.exclude)?e.exclude:[e?.exclude??""]};this.watchers.set(t,a)}unwatch(t){this.watchers.delete(t)}async open(t,e){await this.mount();const{create:a=!1,exclusive:r=!1,truncate:s=!1}=e||{},n=i.normalizePath(i.resolvePath(t));try{return a&&r?await i.withLock(n,"exclusive",async()=>{if(await this.exists(n))throw new i.AlreadyExistsError(n);return this._openFile(n,a,s)}):await this._openFile(n,a,s)}catch(o){throw o instanceof i.OPFSError?o:i.mapDomError(o,{path:n,isDirectory:!1})}}async _openFile(t,e,a){const r=await this.getFileHandle(t,e);try{await r.getFile()}catch(o){throw i.mapDomError(o,{path:t,isDirectory:!0})}const s=await i.createSyncHandleSafe(r,t);a&&(s.truncate(0),s.flush());const n=this.nextFd++;return this.openFiles.set(n,{path:t,fileHandle:r,syncHandle:s,position:0}),n}async close(t){const e=this._getFileDescriptor(t);i.safeCloseSyncHandle(t,e.syncHandle,e.path),this.openFiles.delete(t)}async read(t,e,a,r,s){const n=this._getFileDescriptor(t);i.validateReadWriteArgs(e.length,a,r,s);try{const o=s??n.position,c=n.syncHandle.getSize(),{isEOF:h,actualLength:l}=i.calculateReadLength(o,r,c);if(h)return f.transfer({bytesRead:0,buffer:e},[e.buffer]);const y=e.subarray(a,a+l),w=n.syncHandle.read(y,{at:o});return s==null&&(n.position=o+w),f.transfer({bytesRead:w,buffer:e},[e.buffer])}catch(o){throw i.createFDError("read",t,n.path,o)}}async write(t,e,a=0,r,s,n=!0){const o=this._getFileDescriptor(t),c=r??e.length-a;i.validateReadWriteArgs(e.length,a,c,s);try{const h=s??o.position,l=e.subarray(a,a+c),y=o.syncHandle.write(l,{at:h});return(s==null||s===o.position)&&(o.position=h+y),n&&await this.notifyChange({path:o.path,type:i.WatchEventType.Changed,isDirectory:!1}),y}catch(h){throw i.createFDError("write",t,o.path,h)}}async fstat(t){const e=this._getFileDescriptor(t);return this.stat(e.path)}async ftruncate(t,e=0){const a=this._getFileDescriptor(t);if(e<0||!Number.isInteger(e))throw new i.ValidationError("argument","Invalid size");try{a.syncHandle.truncate(e),a.syncHandle.flush(),a.position>e&&(a.position=e),await this.notifyChange({path:a.path,type:i.WatchEventType.Changed,isDirectory:!1})}catch(r){throw i.createFDError("truncate",t,a.path,r)}}async fsync(t){const e=this._getFileDescriptor(t);try{e.syncHandle.flush()}catch(a){throw i.createFDError("sync",t,e.path,a)}}dispose(){this.broadcastChannel&&(this.broadcastChannel.close(),this.broadcastChannel=null),this.watchers.clear();for(const[t,e]of this.openFiles)i.safeCloseSyncHandle(t,e.syncHandle,e.path);this.openFiles.clear(),this.nextFd=1}async createIndex(t){await this.mount();try{for(const[e,a]of t){const r=i.normalizePath(e);let s;a instanceof Blob?s=await i.convertBlobToUint8Array(a):typeof a=="string"?s=new TextEncoder().encode(a):s=a,await this.writeFile(r,s)}}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e)}}}typeof globalThis<"u"&&globalThis.constructor.name==="DedicatedWorkerGlobalScope"&&f.expose(new d);exports.OPFSWorker=d;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("comlink"),i=require("./helpers-CIiblZ8d.cjs");class d{root;watchers=new Map;mountingPromise=null;broadcastChannel=null;options={root:"/",namespace:"",maxFileSize:50*1024*1024,hashAlgorithm:"etag",broadcastChannel:"opfs-worker"};openFiles=new Map;nextFd=1;_getFileDescriptor(t){const e=this.openFiles.get(t);if(!e)throw new i.ValidationError("descriptor",`Invalid file descriptor: ${t}`);return e}async notifyChange(t){if(!this.options.broadcastChannel)return;const e=t.path;if(![...this.watchers.values()].some(s=>i.matchMinimatch(e,s.pattern)&&s.include.some(n=>n&&i.matchMinimatch(e,n))&&!s.exclude.some(n=>n&&i.matchMinimatch(e,n))))return;let r;if(this.options.hashAlgorithm)try{r=(await this.stat(e)).hash}catch{}try{this.broadcastChannel||(this.broadcastChannel=new BroadcastChannel(this.options.broadcastChannel));const s={namespace:this.options.namespace,timestamp:new Date().toISOString(),...t,...r&&{hash:r}};this.broadcastChannel.postMessage(s)}catch(s){console.warn("Failed to send event via BroadcastChannel:",s)}}constructor(t){i.checkOPFSSupport(),t&&this.setOptions(t)}async mount(){const t=this.options.root;return this.mountingPromise&&await this.mountingPromise,this.mountingPromise=new Promise(async(e,a)=>{try{const r=await navigator.storage.getDirectory();this.root=t==="/"?r:await this.getDirectoryHandle(t,!0,r),e(!0)}catch(r){a(new i.InitializationFailedError(t,r))}finally{this.mountingPromise=null}}),this.mountingPromise}async setOptions(t){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),t.namespace&&(this.options.namespace=t.namespace),t.root!==void 0&&(this.options.root=i.normalizePath(t.root),this.options.namespace||(this.options.namespace=`opfs-worker:${this.options.root}`),await this.mount())}async getDirectoryHandle(t,e=!1,a=this.root){const r=Array.isArray(t)?t:i.splitPath(t);let s=a;for(const n of r)s=await s.getDirectoryHandle(n,{create:e});return s}async getFileHandle(t,e=!1,a=this.root){const r=i.splitPath(t);if(r.length===0)throw new i.PathError("Path must not be empty",Array.isArray(t)?t.join("/"):t);const s=r.pop();return(await this.getDirectoryHandle(r,e,a)).getFileHandle(s,{create:e})}async index(){const t=new Map,e=async a=>{const r=await this.readDir(a);for(const s of r){const n=`${a==="/"?"":a}/${s.name}`;try{const o=await this.stat(n);t.set(n,o),o.isDirectory&&await e(n)}catch(o){console.warn(`Skipping broken entry: ${n}`,o)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t){await this.mount();try{return await i.withLock(t,"shared",async()=>{const e=await this.open(t);try{const{size:a}=await this.fstat(e),r=new Uint8Array(a);return a>0&&await this.read(e,r,0,a,0),f.transfer(r,[r.buffer])}finally{await this.close(e)}})}catch(e){throw new i.ExistenceError("file",t,e)}}async writeFile(t,e){await this.mount();const a=e instanceof Uint8Array?e:new Uint8Array(e);await i.withLock(t,"exclusive",async()=>{const r=await this.exists(t),s=await this.open(t,{create:!0,truncate:!0});try{await this.write(s,a,0,a.length,null,!1),await this.fsync(s)}finally{await this.close(s)}await this.notifyChange({path:t,type:r?i.WatchEventType.Changed:i.WatchEventType.Added,isDirectory:!1})})}async appendFile(t,e){await this.mount();const a=e instanceof Uint8Array?e:new Uint8Array(e);await i.withLock(t,"exclusive",async()=>{const r=await this.open(t,{create:!0});try{const{size:s}=await this.fstat(r);await this.write(r,a,0,a.length,s,!1),await this.fsync(r)}finally{await this.close(r)}await this.notifyChange({path:t,type:i.WatchEventType.Changed,isDirectory:!1})})}async mkdir(t,e){await this.mount();const a=e?.recursive??!1,r=i.splitPath(t);let s=this.root;for(let n=0;n<r.length;n++){const o=r[n];try{s=await s.getDirectoryHandle(o,{create:a||n===r.length-1})}catch(c){throw c.name==="NotFoundError"?new i.ExistenceError("directory",i.joinPath(r.slice(0,n+1)),c):c.name==="TypeMismatchError"?new i.FileTypeError("file",o,c):new i.FileSystemOperationError("create directory",o,c)}}await this.notifyChange({path:t,type:i.WatchEventType.Added,isDirectory:!0})}async stat(t){if(await this.mount(),t==="/")return{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0};const e=i.basename(t);let a;try{a=await this.getDirectoryHandle(i.dirname(t),!1);const r=this.options.hashAlgorithm,n=await(await a.getFileHandle(e,{create:!1})).getFile(),o={kind:"file",size:n.size,mtime:new Date(n.lastModified).toISOString(),ctime:new Date(n.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(r==="etag")o.hash=`${n.lastModified.toString(36)}-${n.size.toString(36)}`;else if(typeof r=="string")try{const c=await i.calculateFileHash(n,r,this.options.maxFileSize);o.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return o}catch(r){if(r.name==="NotFoundError")throw new i.ExistenceError("file",t,r);if(r.name!=="TypeMismatchError")throw new i.FileSystemOperationError("stat",t,r)}try{return await a.getDirectoryHandle(e,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(r){throw new i.FileSystemOperationError("stat",t,r)}}async readDir(t){await this.mount();const e=await this.getDirectoryHandle(t,!1),a=[];for await(const[r,s]of e.entries()){const n=s.kind==="file";a.push({name:r,kind:s.kind,isFile:n,isDirectory:!n})}return a}async exists(t){if(await this.mount(),t==="/")return!0;const e=i.basename(t);let a=null;try{a=await this.getDirectoryHandle(i.dirname(t),!1)}catch(r){if(a=null,r.name!=="NotFoundError"&&r.name!=="TypeMismatchError")throw r}if(!a||!e)return!1;try{return await a.getFileHandle(e,{create:!1}),!0}catch(r){if(r.name!=="NotFoundError"&&r.name!=="TypeMismatchError")throw r;try{return await a.getDirectoryHandle(e,{create:!1}),!0}catch(s){if(s.name!=="NotFoundError"&&s.name!=="TypeMismatchError")throw s;return!1}}}async clear(t="/"){await this.mount();try{const e=await this.readDir(t);for(const a of e){const r=`${t==="/"?"":t}/${a.name}`;await this.remove(r,{recursive:!0})}await this.notifyChange({path:t,type:i.WatchEventType.Changed,isDirectory:!0})}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e,{path:t,isDirectory:!0})}}async remove(t,e){if(await this.mount(),t==="/")throw new i.DirectoryOperationError("EROOT",t);const{recursive:a=!1,force:r=!1}=e||{},s=await this.getDirectoryHandle(i.dirname(t),!1),n=await this.stat(t);await i.removeEntry(s,t,{recursive:a,force:r}),await this.notifyChange({path:t,type:i.WatchEventType.Removed,isDirectory:n.isDirectory})}async realpath(t){await this.mount();try{const e=i.resolvePath(t);if(!await this.exists(e))throw new i.ExistenceError("file",e);return e}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e,{path:t})}}async rename(t,e,a){await this.mount();try{const r=a?.overwrite??!1,s=await this.stat(t);if(await this.exists(e)&&!r)throw new i.AlreadyExistsError(e);await this.copy(t,e,{recursive:!0,overwrite:r}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:i.WatchEventType.Removed,isDirectory:s.isDirectory}),await this.notifyChange({path:e,type:i.WatchEventType.Added,isDirectory:s.isDirectory})}catch(r){throw r instanceof i.OPFSError?r:i.mapDomError(r,{path:t})}}async copy(t,e,a){await this.mount();try{const r=a?.recursive??!1,s=a?.overwrite??!0;if(!await this.exists(t))throw new i.ExistenceError("source",t);if(await this.exists(e)&&!s)throw new i.AlreadyExistsError(e);if((await this.stat(t)).isFile){const h=await this.readFile(t);await this.writeFile(e,h)}else{if(!r)throw new i.FileTypeError("directory",t);await this.mkdir(e,{recursive:!0});const h=await this.readDir(t);for(const l of h){const w=`${t}/${l.name}`,y=`${e}/${l.name}`;await this.copy(w,y,{recursive:!0,overwrite:s})}}}catch(r){throw r instanceof i.OPFSError?r:i.mapDomError(r,{path:t})}}async watch(t,e){if(!this.options.broadcastChannel)throw new i.OperationNotSupportedError("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.");const a={pattern:i.normalizeMinimatch(t,e?.recursive??!0),include:Array.isArray(e?.include)?e.include:[e?.include??"**"],exclude:Array.isArray(e?.exclude)?e.exclude:[e?.exclude??""]};this.watchers.set(t,a)}unwatch(t){this.watchers.delete(t)}async open(t,e){await this.mount();const{create:a=!1,exclusive:r=!1,truncate:s=!1}=e||{},n=i.normalizePath(i.resolvePath(t));try{return a&&r?await i.withLock(n,"exclusive",async()=>{if(await this.exists(n))throw new i.AlreadyExistsError(n);return this._openFile(n,a,s)}):await this._openFile(n,a,s)}catch(o){throw o instanceof i.OPFSError?o:i.mapDomError(o,{path:n,isDirectory:!1})}}async _openFile(t,e,a){const r=await this.getFileHandle(t,e);try{await r.getFile()}catch(o){throw i.mapDomError(o,{path:t,isDirectory:!0})}const s=await i.createSyncHandleSafe(r,t);a&&(s.truncate(0),s.flush());const n=this.nextFd++;return this.openFiles.set(n,{path:t,fileHandle:r,syncHandle:s,position:0}),n}async close(t){const e=this._getFileDescriptor(t);i.safeCloseSyncHandle(t,e.syncHandle,e.path),this.openFiles.delete(t)}async read(t,e,a,r,s){const n=this._getFileDescriptor(t);i.validateReadWriteArgs(e.length,a,r,s);try{const o=s??n.position,c=n.syncHandle.getSize(),{isEOF:h,actualLength:l}=i.calculateReadLength(o,r,c);if(h)return f.transfer({bytesRead:0,buffer:e},[e.buffer]);const w=e.subarray(a,a+l),y=n.syncHandle.read(w,{at:o});return s==null&&(n.position=o+y),f.transfer({bytesRead:y,buffer:e},[e.buffer])}catch(o){throw i.createFDError("read",t,n.path,o)}}async write(t,e,a=0,r,s,n=!0){const o=this._getFileDescriptor(t),c=r??e.length-a;i.validateReadWriteArgs(e.length,a,c,s);try{const h=s??o.position,l=e.subarray(a,a+c),w=o.syncHandle.write(l,{at:h});return(s==null||s===o.position)&&(o.position=h+w),n&&await this.notifyChange({path:o.path,type:i.WatchEventType.Changed,isDirectory:!1}),w}catch(h){throw i.createFDError("write",t,o.path,h)}}async fstat(t){const e=this._getFileDescriptor(t);return this.stat(e.path)}async ftruncate(t,e=0){const a=this._getFileDescriptor(t);if(e<0||!Number.isInteger(e))throw new i.ValidationError("argument","Invalid size");try{a.syncHandle.truncate(e),a.syncHandle.flush(),a.position>e&&(a.position=e),await this.notifyChange({path:a.path,type:i.WatchEventType.Changed,isDirectory:!1})}catch(r){throw i.createFDError("truncate",t,a.path,r)}}async fsync(t){const e=this._getFileDescriptor(t);try{e.syncHandle.flush()}catch(a){throw i.createFDError("sync",t,e.path,a)}}dispose(){this.broadcastChannel&&(this.broadcastChannel.close(),this.broadcastChannel=null),this.watchers.clear();for(const[t,e]of this.openFiles)i.safeCloseSyncHandle(t,e.syncHandle,e.path);this.openFiles.clear(),this.nextFd=1}async createIndex(t){await this.mount();try{for(const[e,a]of t){const r=i.normalizePath(e);let s;a instanceof Blob?s=await i.convertBlobToUint8Array(a):typeof a=="string"?s=new TextEncoder().encode(a):s=a,await this.writeFile(r,s)}}catch(e){throw e instanceof i.OPFSError?e:i.mapDomError(e)}}}typeof globalThis<"u"&&globalThis.constructor.name==="DedicatedWorkerGlobalScope"&&f.expose(new d);exports.OPFSWorker=d;
 //# sourceMappingURL=raw.cjs.map