opfs-worker 0.5.1 → 1.0.1

package/dist/index.js

@@ -1,11 +1,11 @@
 import { wrap as i } from "comlink";
-import { B as p, D as f, F as d, O as u, b as g, a as m, P as w, c as y, S as b, T as v, e as x, t as S, q as E, d as A, u as P, l as F, y as O, f as C, x as T, k as R, i as $, h as _, j as D, m as I, g as j, n as N, o as M, v as k, r as L, s as z, w as U, p as W } from "./helpers-DcIl7KL0.js";
+import { B as p, D as f, F as d, O as u, b as g, a as m, P as w, c as y, S as b, T as v, e as x, t as S, q as E, d as P, u as A, l as F, y as O, f as C, x as T, k as R, i as $, h as _, j as D, m as I, g as j, n as N, o as M, v as k, r as L, s as z, w as W, p as U } from "./helpers-CTCvNFs1.js";
 const r = `/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const ut = Symbol("Comlink.proxy"), Dt = Symbol("Comlink.endpoint"), Nt = Symbol("Comlink.releaseProxy"), U = Symbol("Comlink.finalizer"), L = Symbol("Comlink.thrown"), ft = (s) => typeof s == "object" && s !== null || typeof s == "function", Ft = {
+const ut = Symbol("Comlink.proxy"), Dt = Symbol("Comlink.endpoint"), Nt = Symbol("Comlink.releaseProxy"), U = Symbol("Comlink.finalizer"), L = Symbol("Comlink.thrown"), ft = (s) => typeof s == "object" && s !== null || typeof s == "function", Tt = {
   canHandle: (s) => ft(s) && s[ut],
   serialize(s) {
     const { port1: t, port2: e } = new MessageChannel();
@@ -14,7 +14,7 @@ const ut = Symbol("Comlink.proxy"), Dt = Symbol("Comlink.endpoint"), Nt = Symbol
   deserialize(s) {
     return s.start(), Pt(s);
   }
-}, Tt = {
+}, Ft = {
   canHandle: (s) => ft(s) && L in s,
   serialize({ value: s }) {
     let t;
@@ -31,8 +31,8 @@ const ut = Symbol("Comlink.proxy"), Dt = Symbol("Comlink.endpoint"), Nt = Symbol
     throw s.isError ? Object.assign(new Error(s.value.message), s.value) : s.value;
   }
 }, dt = /* @__PURE__ */ new Map([
-  ["proxy", Ft],
-  ["throw", Tt]
+  ["proxy", Tt],
+  ["throw", Ft]
 ]);
 function Mt(s, t) {
   for (const e of s)
@@ -298,13 +298,12 @@ function _t(s, t = "utf-8") {
     case "utf-8":
       return new TextDecoder().decode(s);
     case "utf16le":
+    case "utf-16le":
     case "ucs2":
     case "ucs-2":
       return Gt(s);
     case "latin1":
       return String.fromCharCode(...s);
-    case "binary":
-      return String.fromCharCode(...s);
     case "ascii":
       return String.fromCharCode(...s.map((e) => e & 127));
     case "base64":
@@ -370,17 +369,17 @@ const wt = (s, t, e) => {
     n.length && o !== void 0 && (a = [r, o]);
   }
   return a;
-}, yt = "\\0SLASH" + Math.random() + "\\0", Et = "\\0OPEN" + Math.random() + "\\0", K = "\\0CLOSE" + Math.random() + "\\0", St = "\\0COMMA" + Math.random() + "\\0", bt = "\\0PERIOD" + Math.random() + "\\0", Yt = new RegExp(yt, "g"), Zt = new RegExp(Et, "g"), Jt = new RegExp(K, "g"), Kt = new RegExp(St, "g"), Qt = new RegExp(bt, "g"), te = /\\\\\\\\/g, ee = /\\\\{/g, se = /\\\\}/g, ne = /\\\\,/g, ie = /\\\\./g;
+}, yt = "\\0SLASH" + Math.random() + "\\0", Et = "\\0OPEN" + Math.random() + "\\0", K = "\\0CLOSE" + Math.random() + "\\0", St = "\\0COMMA" + Math.random() + "\\0", xt = "\\0PERIOD" + Math.random() + "\\0", Yt = new RegExp(yt, "g"), Zt = new RegExp(Et, "g"), Jt = new RegExp(K, "g"), Kt = new RegExp(St, "g"), Qt = new RegExp(xt, "g"), te = /\\\\\\\\/g, ee = /\\\\{/g, se = /\\\\}/g, ne = /\\\\,/g, ie = /\\\\./g;
 function B(s) {
   return isNaN(s) ? s.charCodeAt(0) : parseInt(s, 10);
 }
 function re(s) {
-  return s.replace(te, yt).replace(ee, Et).replace(se, K).replace(ne, St).replace(ie, bt);
+  return s.replace(te, yt).replace(ee, Et).replace(se, K).replace(ne, St).replace(ie, xt);
 }
 function oe(s) {
   return s.replace(Yt, "\\\\").replace(Zt, "{").replace(Jt, "}").replace(Kt, ",").replace(Qt, ".");
 }
-function xt(s) {
+function bt(s) {
   if (!s)
     return [""];
   const t = [], e = wt("{", "}", s);
@@ -388,7 +387,7 @@ function xt(s) {
     return s.split(",");
   const { pre: n, body: i, post: r } = e, o = n.split(",");
   o[o.length - 1] += "{" + i + "}";
-  const a = xt(r);
+  const a = bt(r);
   return r.length && (o[o.length - 1] += a.shift(), o.push.apply(o, a)), t.push.apply(t, o), t;
 }
 function ae(s) {
@@ -423,7 +422,7 @@ function M(s, t) {
     let c;
     if (l)
       c = n.body.split(/\\.\\./);
-    else if (c = xt(n.body), c.length === 1 && c[0] !== void 0 && (c = M(c[0], !1).map(ce), c.length === 1))
+    else if (c = bt(n.body), c.length === 1 && c[0] !== void 0 && (c = M(c[0], !1).map(ce), c.length === 1))
       return r.map((u) => n.pre + c[0] + u);
     let f;
     if (l && c[0] !== void 0 && c[1] !== void 0) {
@@ -432,15 +431,15 @@ function M(s, t) {
       d < u && (p *= -1, S = ue);
       const N = c.some(le);
       f = [];
-      for (let b = u; S(b, d); b += p) {
+      for (let x = u; S(x, d); x += p) {
         let w;
         if (a)
-          w = String.fromCharCode(b), w === "\\\\" && (w = "");
-        else if (w = String(b), N) {
-          const F = m - w.length;
-          if (F > 0) {
-            const P = new Array(F + 1).join("0");
-            b < 0 ? w = "-" + P + w.slice(1) : w = P + w;
+          w = String.fromCharCode(x), w === "\\\\" && (w = "");
+        else if (w = String(x), N) {
+          const T = m - w.length;
+          if (T > 0) {
+            const P = new Array(T + 1).join("0");
+            x < 0 ? w = "-" + P + w.slice(1) : w = P + w;
           }
         }
         f.push(w);
@@ -478,7 +477,7 @@ const fe = 1024 * 64, W = (s) => {
   "[:upper:]": ["\\\\p{Lu}", !0],
   "[:word:]": ["\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}", !0],
   "[:xdigit:]": ["A-Fa-f0-9", !1]
-}, T = (s) => s.replace(/[[\\]\\\\-]/g, "\\\\$&"), pe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), it = (s) => s.join(""), ge = (s, t) => {
+}, F = (s) => s.replace(/[[\\]\\\\-]/g, "\\\\$&"), pe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), it = (s) => s.join(""), ge = (s, t) => {
   const e = t;
   if (s.charAt(e) !== "[")
     throw new Error("not in a brace expression");
@@ -499,27 +498,27 @@ const fe = 1024 * 64, W = (s) => {
       continue;
     }
     if (p === "[" && !l) {
-      for (const [S, [v, N, b]] of Object.entries(de))
+      for (const [S, [A, N, x]] of Object.entries(de))
         if (s.startsWith(S, r)) {
           if (f)
             return ["$.", !1, s.length - e, !0];
-          r += S.length, b ? i.push(v) : n.push(v), a = a || N;
+          r += S.length, x ? i.push(A) : n.push(A), a = a || N;
           continue t;
         }
     }
     if (l = !1, f) {
-      p > f ? n.push(T(f) + "-" + T(p)) : p === f && n.push(T(p)), f = "", r++;
+      p > f ? n.push(F(f) + "-" + F(p)) : p === f && n.push(F(p)), f = "", r++;
       continue;
     }
     if (s.startsWith("-]", r + 1)) {
-      n.push(T(p + "-")), r += 2;
+      n.push(F(p + "-")), r += 2;
       continue;
     }
     if (s.startsWith("-", r + 1)) {
       f = p, r += 2;
       continue;
     }
-    n.push(T(p)), r++;
+    n.push(F(p)), r++;
   }
   if (c < r)
     return ["", !1, 0, !1];
@@ -531,7 +530,7 @@ const fe = 1024 * 64, W = (s) => {
   }
   const u = "[" + (h ? "^" : "") + it(n) + "]", d = "[" + (h ? "" : "^") + it(i) + "]";
   return [n.length && i.length ? "(" + u + "|" + d + ")" : n.length ? u : d, a, c - e, !0];
-}, $ = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/\\[([^\\/\\\\])\\]/g, "$1") : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, "$1$2").replace(/\\\\([^\\/])/g, "$1"), me = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), rt = (s) => me.has(s), we = "(?!(?:^|/)\\\\.\\\\.?(?:$|/))", k = "(?!\\\\.)", ye = /* @__PURE__ */ new Set(["[", "."]), Ee = /* @__PURE__ */ new Set(["..", "."]), Se = new Set("().*{}+?[]^$\\\\!"), be = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), Q = "[^/]", ot = Q + "*?", at = Q + "+?";
+}, $ = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/\\[([^\\/\\\\])\\]/g, "$1") : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, "$1$2").replace(/\\\\([^\\/])/g, "$1"), me = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), rt = (s) => me.has(s), we = "(?!(?:^|/)\\\\.\\\\.?(?:$|/))", k = "(?!\\\\.)", ye = /* @__PURE__ */ new Set(["[", "."]), Ee = /* @__PURE__ */ new Set(["..", "."]), Se = new Set("().*{}+?[]^$\\\\!"), xe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), Q = "[^/]", ot = Q + "*?", at = Q + "+?";
 class E {
   type;
   #s;
@@ -784,8 +783,8 @@ class E {
     const e = t ?? !!this.#i.dot;
     if (this.#s === this && this.#d(), !this.type) {
       const l = this.isStart() && this.isEnd(), h = this.#t.map((d) => {
-        const [m, p, S, v] = typeof d == "string" ? E.#p(d, this.#n, l) : d.toRegExpSource(t);
-        return this.#n = this.#n || S, this.#r = this.#r || v, m;
+        const [m, p, S, A] = typeof d == "string" ? E.#p(d, this.#n, l) : d.toRegExpSource(t);
+        return this.#n = this.#n || S, this.#r = this.#r || A, m;
       }).join("");
       let c = "";
       if (this.isStart() && typeof this.#t[0] == "string" && !(this.#t.length === 1 && Ee.has(this.#t[0]))) {
@@ -865,27 +864,27 @@ class E {
         r += Q, e = !0;
         continue;
       }
-      r += be(l);
+      r += xe(l);
     }
     return [r, $(t), !!e, o];
   }
 }
-const xe = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\]]/g, "[$&]") : s.replace(/[?*()[\\]\\\\]/g, "\\\\$&"), y = (s, t, e = {}) => (W(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new j(t, e).match(s)), Ae = /^\\*+([^+@!?\\*\\[\\(]*)$/, ve = (s) => (t) => !t.startsWith(".") && t.endsWith(s), Ce = (s) => (t) => t.endsWith(s), Oe = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), De = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), Ne = /^\\*+\\.\\*+$/, Fe = (s) => !s.startsWith(".") && s.includes("."), Te = (s) => s !== "." && s !== ".." && s.includes("."), Me = /^\\.\\*+$/, $e = (s) => s !== "." && s !== ".." && s.startsWith("."), Pe = /^\\*+$/, Re = (s) => s.length !== 0 && !s.startsWith("."), ke = (s) => s.length !== 0 && s !== "." && s !== "..", Le = /^\\?+([^+@!?\\*\\[\\(]*)?$/, Ie = ([s, t = ""]) => {
-  const e = At([s]);
+const be = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\]]/g, "[$&]") : s.replace(/[?*()[\\]\\\\]/g, "\\\\$&"), y = (s, t, e = {}) => (W(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new j(t, e).match(s)), ve = /^\\*+([^+@!?\\*\\[\\(]*)$/, Ae = (s) => (t) => !t.startsWith(".") && t.endsWith(s), Ce = (s) => (t) => t.endsWith(s), Oe = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), De = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), Ne = /^\\*+\\.\\*+$/, Te = (s) => !s.startsWith(".") && s.includes("."), Fe = (s) => s !== "." && s !== ".." && s.includes("."), Me = /^\\.\\*+$/, $e = (s) => s !== "." && s !== ".." && s.startsWith("."), Pe = /^\\*+$/, Re = (s) => s.length !== 0 && !s.startsWith("."), ke = (s) => s.length !== 0 && s !== "." && s !== "..", Le = /^\\?+([^+@!?\\*\\[\\(]*)?$/, Ie = ([s, t = ""]) => {
+  const e = vt([s]);
   return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
 }, ze = ([s, t = ""]) => {
-  const e = vt([s]);
+  const e = At([s]);
   return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
 }, He = ([s, t = ""]) => {
-  const e = vt([s]);
+  const e = At([s]);
   return t ? (n) => e(n) && n.endsWith(t) : e;
 }, We = ([s, t = ""]) => {
-  const e = At([s]);
+  const e = vt([s]);
   return t ? (n) => e(n) && n.endsWith(t) : e;
-}, At = ([s]) => {
+}, vt = ([s]) => {
   const t = s.length;
   return (e) => e.length === t && !e.startsWith(".");
-}, vt = ([s]) => {
+}, At = ([s]) => {
   const t = s.length;
   return (e) => e.length === t && e !== "." && e !== "..";
 }, Ct = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", ct = {
@@ -893,42 +892,42 @@ const xe = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\\
   posix: { sep: "/" }
 }, je = Ct === "win32" ? ct.win32.sep : ct.posix.sep;
 y.sep = je;
-const A = Symbol("globstar **");
-y.GLOBSTAR = A;
+const v = Symbol("globstar **");
+y.GLOBSTAR = v;
 const Ue = "[^/]", _e = Ue + "*?", Be = "(?:(?!(?:\\\\/|^)(?:\\\\.{1,2})($|\\\\/)).)*?", Ge = "(?:(?!(?:\\\\/|^)\\\\.).)*?", qe = (s, t = {}) => (e) => y(e, s, t);
 y.filter = qe;
-const x = (s, t = {}) => Object.assign({}, s, t), Ve = (s) => {
+const b = (s, t = {}) => Object.assign({}, s, t), Ve = (s) => {
   if (!s || typeof s != "object" || !Object.keys(s).length)
     return y;
   const t = y;
-  return Object.assign((n, i, r = {}) => t(n, i, x(s, r)), {
+  return Object.assign((n, i, r = {}) => t(n, i, b(s, r)), {
     Minimatch: class extends t.Minimatch {
       constructor(i, r = {}) {
-        super(i, x(s, r));
+        super(i, b(s, r));
       }
       static defaults(i) {
-        return t.defaults(x(s, i)).Minimatch;
+        return t.defaults(b(s, i)).Minimatch;
       }
     },
     AST: class extends t.AST {
       /* c8 ignore start */
       constructor(i, r, o = {}) {
-        super(i, r, x(s, o));
+        super(i, r, b(s, o));
       }
       /* c8 ignore stop */
       static fromGlob(i, r = {}) {
-        return t.AST.fromGlob(i, x(s, r));
+        return t.AST.fromGlob(i, b(s, r));
       }
     },
-    unescape: (n, i = {}) => t.unescape(n, x(s, i)),
-    escape: (n, i = {}) => t.escape(n, x(s, i)),
-    filter: (n, i = {}) => t.filter(n, x(s, i)),
-    defaults: (n) => t.defaults(x(s, n)),
-    makeRe: (n, i = {}) => t.makeRe(n, x(s, i)),
-    braceExpand: (n, i = {}) => t.braceExpand(n, x(s, i)),
-    match: (n, i, r = {}) => t.match(n, i, x(s, r)),
+    unescape: (n, i = {}) => t.unescape(n, b(s, i)),
+    escape: (n, i = {}) => t.escape(n, b(s, i)),
+    filter: (n, i = {}) => t.filter(n, b(s, i)),
+    defaults: (n) => t.defaults(b(s, n)),
+    makeRe: (n, i = {}) => t.makeRe(n, b(s, i)),
+    braceExpand: (n, i = {}) => t.braceExpand(n, b(s, i)),
+    match: (n, i, r = {}) => t.match(n, i, b(s, r)),
     sep: t.sep,
-    GLOBSTAR: A
+    GLOBSTAR: v
   });
 };
 y.defaults = Ve;
@@ -1169,10 +1168,10 @@ class j {
   matchOne(t, e, n = !1) {
     const i = this.options;
     if (this.isWindows) {
-      const p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), S = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), v = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), N = !v && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), b = S ? 3 : p ? 0 : void 0, w = N ? 3 : v ? 0 : void 0;
-      if (typeof b == "number" && typeof w == "number") {
-        const [F, P] = [t[b], e[w]];
-        F.toLowerCase() === P.toLowerCase() && (e[w] = F, w > b ? e = e.slice(w) : b > w && (t = t.slice(b)));
+      const p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), S = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), A = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), N = !A && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), x = S ? 3 : p ? 0 : void 0, w = N ? 3 : A ? 0 : void 0;
+      if (typeof x == "number" && typeof w == "number") {
+        const [T, P] = [t[x], e[w]];
+        T.toLowerCase() === P.toLowerCase() && (e[w] = T, w > x ? e = e.slice(w) : x > w && (t = t.slice(x)));
       }
     }
     const { optimizationLevel: r = 1 } = this.options;
@@ -1182,7 +1181,7 @@ class j {
       var c = e[a], f = t[o];
       if (this.debug(e, c, f), c === !1)
         return !1;
-      if (c === A) {
+      if (c === v) {
         this.debug("GLOBSTAR", [e, c, f]);
         var u = o, d = a + 1;
         if (d === h) {
@@ -1224,11 +1223,11 @@ globstar while\`, t, u, e, d, m), this.matchOne(t.slice(u), e.slice(d), n))
     W(t);
     const e = this.options;
     if (t === "**")
-      return A;
+      return v;
     if (t === "")
       return "";
     let n, i = null;
-    (n = t.match(Pe)) ? i = e.dot ? ke : Re : (n = t.match(Ae)) ? i = (e.nocase ? e.dot ? De : Oe : e.dot ? Ce : ve)(n[1]) : (n = t.match(Le)) ? i = (e.nocase ? e.dot ? ze : Ie : e.dot ? He : We)(n) : (n = t.match(Ne)) ? i = e.dot ? Te : Fe : (n = t.match(Me)) && (i = $e);
+    (n = t.match(Pe)) ? i = e.dot ? ke : Re : (n = t.match(ve)) ? i = (e.nocase ? e.dot ? De : Oe : e.dot ? Ce : Ae)(n[1]) : (n = t.match(Le)) ? i = (e.nocase ? e.dot ? ze : Ie : e.dot ? He : We)(n) : (n = t.match(Ne)) ? i = e.dot ? Fe : Te : (n = t.match(Me)) && (i = $e);
     const r = E.fromGlob(t, this.options).toMMPattern();
     return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
   }
@@ -1244,12 +1243,12 @@ globstar while\`, t, u, e, d, m), this.matchOne(t.slice(u), e.slice(d), n))
         if (c instanceof RegExp)
           for (const f of c.flags.split(""))
             i.add(f);
-        return typeof c == "string" ? Ze(c) : c === A ? A : c._src;
+        return typeof c == "string" ? Ze(c) : c === v ? v : c._src;
       });
       return h.forEach((c, f) => {
         const u = h[f + 1], d = h[f - 1];
-        c !== A || d === A || (d === void 0 ? u !== void 0 && u !== A ? h[f + 1] = "(?:\\\\/|" + n + "\\\\/)?" + u : h[f] = n : u === void 0 ? h[f - 1] = d + "(?:\\\\/|" + n + ")?" : u !== A && (h[f - 1] = d + "(?:\\\\/|\\\\/" + n + "\\\\/)" + u, h[f + 1] = A));
-      }), h.filter((c) => c !== A).join("/");
+        c !== v || d === v || (d === void 0 ? u !== void 0 && u !== v ? h[f + 1] = "(?:\\\\/|" + n + "\\\\/)?" + u : h[f] = n : u === void 0 ? h[f - 1] = d + "(?:\\\\/|" + n + ")?" : u !== v && (h[f - 1] = d + "(?:\\\\/|\\\\/" + n + "\\\\/)" + u, h[f + 1] = v));
+      }), h.filter((c) => c !== v).join("/");
     }).join("|");
     const [o, a] = t.length > 1 ? ["(?:", ")"] : ["", ""];
     r = "^" + o + r + a + "$", this.negate && (r = "^(?!" + r + ").+$");
@@ -1294,7 +1293,7 @@ globstar while\`, t, u, e, d, m), this.matchOne(t.slice(u), e.slice(d), n))
 }
 y.AST = E;
 y.Minimatch = j;
-y.escape = xe;
+y.escape = be;
 y.unescape = $;
 const Je = [
   // Images
@@ -1448,6 +1447,7 @@ async function rs(s, t, e = {}) {
   const n = Y(t);
   return tt(t, "exclusive", async () => {
     const i = e.recursive ?? !1, r = e.force ?? !1;
+    e.useTrash;
     try {
       await s.removeEntry(n, { recursive: i });
     } catch (o) {
@@ -1460,7 +1460,7 @@ async function rs(s, t, e = {}) {
 }
 class os {
   /** Root directory handle for the file system */
-  root = null;
+  root;
   /** Map of watched paths and options */
   watchers = /* @__PURE__ */ new Map();
   /** Promise to prevent concurrent mount operations */
@@ -1543,13 +1543,14 @@ class os {
    * await fs.mount('/my-app');
    * \`\`\`
    */
-  async mount(t = this.options.root) {
-    return this.mountingPromise && await this.mountingPromise, t = Z(t), this.mountingPromise = new Promise(async (e, n) => {
+  async mount() {
+    const t = this.options.root;
+    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, n) => {
       try {
         const i = await navigator.storage.getDirectory();
-        t === "/" ? this.root = i : this.root = await this.getDirectoryHandle(t, !0, i), e(!0);
-      } catch {
-        n(new g("Failed to initialize OPFS", "INIT_FAILED"));
+        this.root = t === "/" ? i : await this.getDirectoryHandle(t, !0, i), e(!0);
+      } catch (i) {
+        n(new g("Failed to initialize OPFS", "INIT_FAILED", t, i));
       } finally {
         this.mountingPromise = null;
       }
@@ -1566,7 +1567,7 @@ class os {
    * @param options.broadcastChannel - Custom name for the broadcast channel
    */
   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 = t.root, this.options.namespace || (this.options.namespace = \`opfs-worker:\${this.options.root}\`), await this.mount(this.options.root));
+    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 = Z(t.root), this.options.namespace || (this.options.namespace = \`opfs-worker:\${this.options.root}\`), await this.mount());
   }
   /**
    * Get a directory handle from a path
@@ -1601,7 +1602,7 @@ class os {
    * 
    * @param path - The path to the file (string or array of segments)
    * @param create - Whether to create the file if it doesn't exist (default: false)
-   * @param from - The directory to start from (default: root directory)
+   * @param _from - The directory to start from (default: root directory)
    * @returns Promise that resolves to the file handle
    * @throws {PathError} If the path is empty
    * @throws {OPFSError} If the file cannot be accessed or created
@@ -1663,7 +1664,7 @@ class os {
   async readFile(t, e) {
     await this.mount(), e || (e = G(t) ? "binary" : "utf-8");
     try {
-      const n = await this.getFileHandle(t, !1), i = await ss(n, t);
+      const n = await this.getFileHandle(t, !1, this.root), i = await ss(n, t);
       return e === "binary" ? i : _t(i, e);
     } catch (n) {
       throw new _(t, n);
@@ -1887,7 +1888,8 @@ class os {
     try {
       n = await this.getDirectoryHandle(q(t), !1);
     } catch (i) {
-      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
+      if (n = null, i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+        throw i;
     }
     if (!n || !e)
       return !1;
@@ -1964,8 +1966,8 @@ class os {
   async remove(t, e) {
     if (await this.mount(), t === "/")
       throw new g("Cannot remove root directory", "EROOT");
-    const n = await this.getDirectoryHandle(q(t), !1);
-    await rs(n, t, e), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
+    const { recursive: n = !1, force: i = !1 } = e || {}, r = await this.getDirectoryHandle(q(t), !1);
+    await rs(r, t, { recursive: n, force: i }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
   }
   /**
    * Resolve a path to an absolute path
@@ -2000,26 +2002,35 @@ class os {
    * Rename a file or directory
    * 
    * Changes the name of a file or directory. If the target path already exists,
-   * it will be replaced.
+   * it will be replaced only if overwrite option is enabled.
    * 
    * @param oldPath - The current path of the file or directory
    * @param newPath - The new path for the file or directory
+   * @param options - Options for renaming
+   * @param options.overwrite - Whether to overwrite existing files (default: false)
    * @returns Promise that resolves when the rename operation is complete
    * @throws {OPFSError} If the rename operation fails
    * 
    * @example
    * \`\`\`typescript
+   * // Basic rename (fails if target exists)
    * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
+   * 
+   * // Rename with overwrite
+   * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt', { overwrite: true });
    * \`\`\`
    */
-  async rename(t, e) {
+  async rename(t, e, n) {
     await this.mount();
     try {
+      const i = n?.overwrite ?? !1;
       if (!await this.exists(t))
         throw new _(t);
-      await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
-    } catch (n) {
-      throw n instanceof g ? n : new g(\`Failed to rename from \${t} to \${e}\`, "RENAME_FAILED", void 0, n);
+      if (await this.exists(e) && !i)
+        throw new g(\`Destination already exists: \${e}\`, "EEXIST", void 0);
+      await this.copy(t, e, { recursive: !0, overwrite: i }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
+    } catch (i) {
+      throw i instanceof g ? i : new g(\`Failed to rename from \${t} to \${e}\`, "RENAME_FAILED", void 0, i);
     }
   }
   /**
@@ -2031,7 +2042,7 @@ class os {
    * @param destination - The destination path to copy to
    * @param options - Options for copying
    * @param options.recursive - Whether to copy directories recursively (default: false)
-   * @param options.force - Whether to overwrite existing files (default: true)
+   * @param options.overwrite - Whether to overwrite existing files (default: true)
    * @returns Promise that resolves when the copy operation is complete
    * @throws {OPFSError} If the copy operation fails
    * 
@@ -2044,13 +2055,13 @@ class os {
    * await fs.copy('/source/dir', '/dest/dir', { recursive: true });
    * 
    * // Copy without overwriting existing files
-   * await fs.copy('/source', '/dest', { recursive: true, force: false });
+   * await fs.copy('/source', '/dest', { recursive: true, overwrite: false });
    * \`\`\`
    */
   async copy(t, e, n) {
     await this.mount();
     try {
-      const i = n?.recursive ?? !1, r = n?.force ?? !0;
+      const i = n?.recursive ?? !1, r = n?.overwrite ?? !0;
       if (!await this.exists(t))
         throw new g(\`Source does not exist: \${t}\`, "ENOENT", void 0);
       if (await this.exists(e) && !r)
@@ -2065,7 +2076,7 @@ class os {
         const h = await this.readDir(t);
         for (const c of h) {
           const f = \`\${t}/\${c.name}\`, u = \`\${e}/\${c.name}\`;
-          await this.copy(f, u, { recursive: !0, force: r });
+          await this.copy(f, u, { recursive: !0, overwrite: r });
         }
       }
     } catch (i) {
@@ -2165,7 +2176,7 @@ class os {
   }
 }
 typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && J(new os());
-//# sourceMappingURL=worker-DYhMhDRt.js.map
+//# sourceMappingURL=worker-CccfxYdr.js.map
 `, s = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", r], { type: "text/javascript;charset=utf-8" });
 function o(n) {
   let t;
@@ -2206,8 +2217,8 @@ export {
   x as basename,
   S as buffersEqual,
   E as calculateFileHash,
-  A as checkOPFSSupport,
-  P as convertBlobToUint8Array,
+  P as checkOPFSSupport,
+  A as convertBlobToUint8Array,
   F as createBuffer,
   h as createWorker,
   O as decodeBuffer,
@@ -2224,7 +2235,7 @@ export {
   k as removeEntry,
   L as resolvePath,
   z as splitPath,
-  U as withLock,
-  W as writeFileData
+  W as withLock,
+  U as writeFileData
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSOptions, OPFSWorker, RemoteOPFSWorker } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport async function createWorker(\n    options?: OPFSOptions\n): Promise<RemoteOPFSWorker> {\n    const wrapped = wrap<OPFSWorker>(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        await wrapped.setOptions(options);\n    }\n\n    return wrapped;\n}\n"],"names":["createWorker","options","wrapped","wrap","WorkerCtor"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,eAAsBA,EAClBC,GACyB;AACzB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIH,MAEIA,EAAQ,oBAAoBA,EAAQ,4BAA4B,qBAChEA,EAAQ,mBAAmBA,EAAQ,iBAAiB,OAGxD,MAAMC,EAAQ,WAAWD,CAAO,IAG7BC;AACX;"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSOptions, OPFSWorker, RemoteOPFSWorker } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport async function createWorker(\n    options?: OPFSOptions\n): Promise<RemoteOPFSWorker> {\n    const wrapped = wrap<OPFSWorker>(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        await wrapped.setOptions(options);\n    }\n\n    return wrapped;\n}\n"],"names":["createWorker","options","wrapped","wrap","WorkerCtor"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,eAAsBA,EAClBC,GACyB;AACzB,QAAMC,IAAUC,EAAiB,IAAIC,GAAY;AAGjD,SAAIH,MAEIA,EAAQ,oBAAoBA,EAAQ,4BAA4B,qBAChEA,EAAQ,mBAAmBA,EAAQ,iBAAiB,OAGxD,MAAMC,EAAQ,WAAWD,CAAO,IAG7BC;AACX;"}

package/dist/raw.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const m=require("comlink"),i=require("./helpers-BfBe8lFJ.cjs");class w{root=null;watchers=new Map;mountingPromise=null;broadcastChannel=null;options={root:"/",namespace:"",maxFileSize:50*1024*1024,hashAlgorithm:null,broadcastChannel:"opfs-worker"};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(o=>o&&i.matchMinimatch(e,o))&&!s.exclude.some(o=>o&&i.matchMinimatch(e,o))))return;let a;if(this.options.hashAlgorithm)try{a=(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,...a&&{hash:a}};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(t=this.options.root){return this.mountingPromise&&await this.mountingPromise,t=i.normalizePath(t),this.mountingPromise=new Promise(async(e,r)=>{try{const a=await navigator.storage.getDirectory();t==="/"?this.root=a:this.root=await this.getDirectoryHandle(t,!0,a),e(!0)}catch{r(new i.OPFSError("Failed to initialize OPFS","INIT_FAILED"))}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=t.root,this.options.namespace||(this.options.namespace=`opfs-worker:${this.options.root}`),await this.mount(this.options.root))}async getDirectoryHandle(t,e=!1,r=this.root){const a=Array.isArray(t)?t:i.splitPath(t);let s=r;for(const o of a)s=await s.getDirectoryHandle(o,{create:e});return s}async getFileHandle(t,e=!1,r=this.root){const a=i.splitPath(t);if(a.length===0)throw new i.PathError("Path must not be empty",Array.isArray(t)?t.join("/"):t);const s=a.pop();return(await this.getDirectoryHandle(a,e,r)).getFileHandle(s,{create:e})}async index(){const t=new Map,e=async r=>{const a=await this.readDir(r);for(const s of a){const o=`${r==="/"?"":r}/${s.name}`;try{const n=await this.stat(o);t.set(o,n),n.isDirectory&&await e(o)}catch(n){console.warn(`Skipping broken entry: ${o}`,n)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t,e){await this.mount(),e||(e=i.isBinaryFileExtension(t)?"binary":"utf-8");try{const r=await this.getFileHandle(t,!1),a=await i.readFileData(r,t);return e==="binary"?a:i.decodeBuffer(a,e)}catch(r){throw new i.FileNotFoundError(t,r)}}async writeFile(t,e,r){await this.mount();const a=await this.exists(t),s=await this.getFileHandle(t,!0);r||(r=typeof e!="string"||i.isBinaryFileExtension(t)?"binary":"utf-8"),await i.writeFileData(s,e,r,t),a?await this.notifyChange({path:t,type:"changed",isDirectory:!1}):await this.notifyChange({path:t,type:"added",isDirectory:!1})}async appendFile(t,e,r){await this.mount();const a=await this.getFileHandle(t,!0);r||(r=typeof e!="string"||i.isBinaryFileExtension(t)?"binary":"utf-8"),await i.writeFileData(a,e,r,t,{append:!0}),await this.notifyChange({path:t,type:"changed",isDirectory:!1})}async mkdir(t,e){await this.mount();const r=e?.recursive??!1,a=i.splitPath(t);let s=this.root;for(let o=0;o<a.length;o++){const n=a[o];try{s=await s.getDirectoryHandle(n,{create:r||o===a.length-1})}catch(c){throw c.name==="NotFoundError"?new i.OPFSError(`Parent directory does not exist: ${i.joinPath(a.slice(0,o+1))}`,"ENOENT",void 0,c):c.name==="TypeMismatchError"?new i.OPFSError(`Path segment is not a directory: ${n}`,"ENOTDIR",void 0,c):new i.OPFSError("Failed to create directory","MKDIR_FAILED",void 0,c)}}await this.notifyChange({path:t,type:"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),r=await this.getDirectoryHandle(i.dirname(t),!1),a=this.options.hashAlgorithm!==null;try{const o=await(await r.getFileHandle(e,{create:!1})).getFile(),n={kind:"file",size:o.size,mtime:new Date(o.lastModified).toISOString(),ctime:new Date(o.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(a&&this.options.hashAlgorithm)try{const c=await i.calculateFileHash(o,this.options.hashAlgorithm,this.options.maxFileSize);n.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return n}catch(s){if(s.name!=="TypeMismatchError"&&s.name!=="NotFoundError")throw new i.OPFSError("Failed to stat (file)","STAT_FAILED",void 0,s)}try{return await r.getDirectoryHandle(e,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(s){throw s.name==="NotFoundError"?new i.OPFSError(`No such file or directory: ${t}`,"ENOENT",void 0,s):new i.OPFSError("Failed to stat (directory)","STAT_FAILED",void 0,s)}}async readDir(t){await this.mount();const e=await this.getDirectoryHandle(t,!1),r=[];for await(const[a,s]of e.entries()){const o=s.kind==="file";r.push({name:a,kind:s.kind,isFile:o,isDirectory:!o})}return r}async exists(t){if(await this.mount(),t==="/")return!0;const e=i.basename(t);let r=null;try{r=await this.getDirectoryHandle(i.dirname(t),!1)}catch(a){throw(a.name==="NotFoundError"||a.name==="TypeMismatchError")&&(r=null),a}if(!r||!e)return!1;try{return await r.getFileHandle(e,{create:!1}),!0}catch(a){if(a.name!=="NotFoundError"&&a.name!=="TypeMismatchError")throw a;try{return await r.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 r of e){const a=`${t==="/"?"":t}/${r.name}`;await this.remove(a,{recursive:!0})}await this.notifyChange({path:t,type:"changed",isDirectory:!0})}catch(e){throw e instanceof i.OPFSError?e:new i.OPFSError(`Failed to clear directory: ${t}`,"CLEAR_FAILED",void 0,e)}}async remove(t,e){if(await this.mount(),t==="/")throw new i.OPFSError("Cannot remove root directory","EROOT");const r=await this.getDirectoryHandle(i.dirname(t),!1);await i.removeEntry(r,t,e),await this.notifyChange({path:t,type:"removed",isDirectory:!1})}async realpath(t){await this.mount();try{const e=i.resolvePath(t);if(!await this.exists(e))throw new i.FileNotFoundError(e);return e}catch(e){throw e instanceof i.OPFSError?e:new i.OPFSError(`Failed to resolve path: ${t}`,"REALPATH_FAILED",void 0,e)}}async rename(t,e){await this.mount();try{if(!await this.exists(t))throw new i.FileNotFoundError(t);await this.copy(t,e,{recursive:!0}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:"removed",isDirectory:!1}),await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(r){throw r instanceof i.OPFSError?r:new i.OPFSError(`Failed to rename from ${t} to ${e}`,"RENAME_FAILED",void 0,r)}}async copy(t,e,r){await this.mount();try{const a=r?.recursive??!1,s=r?.force??!0;if(!await this.exists(t))throw new i.OPFSError(`Source does not exist: ${t}`,"ENOENT",void 0);if(await this.exists(e)&&!s)throw new i.OPFSError(`Destination already exists: ${e}`,"EEXIST",void 0);if((await this.stat(t)).isFile){const l=await this.readFile(t,"binary");await this.writeFile(e,l)}else{if(!a)throw new i.OPFSError(`Cannot copy directory without recursive option: ${t}`,"EISDIR",void 0);await this.mkdir(e,{recursive:!0});const l=await this.readDir(t);for(const h of l){const d=`${t}/${h.name}`,f=`${e}/${h.name}`;await this.copy(d,f,{recursive:!0,force:s})}}}catch(a){throw a instanceof i.OPFSError?a:new i.OPFSError(`Failed to copy from ${t} to ${e}`,"CP_FAILED",void 0,a)}}async watch(t,e){if(!this.options.broadcastChannel)throw new i.OPFSError("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.","ENOENT");const r={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,r)}unwatch(t){this.watchers.delete(t)}dispose(){this.broadcastChannel&&(this.broadcastChannel.close(),this.broadcastChannel=null),this.watchers.clear()}async sync(t,e){await this.mount();try{(e?.cleanBefore??!1)&&await this.clear("/");for(const[a,s]of t){const o=i.normalizePath(a);let n;s instanceof Blob?n=await i.convertBlobToUint8Array(s):n=s,await this.writeFile(o,n)}}catch(r){throw r instanceof i.OPFSError?r:new i.OPFSError("Failed to sync file system","SYNC_FAILED",void 0,r)}}}typeof globalThis<"u"&&globalThis.constructor.name==="DedicatedWorkerGlobalScope"&&m.expose(new w);exports.OPFSWorker=w;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const m=require("comlink"),i=require("./helpers-Cvjm0f_r.cjs");class w{root;watchers=new Map;mountingPromise=null;broadcastChannel=null;options={root:"/",namespace:"",maxFileSize:50*1024*1024,hashAlgorithm:null,broadcastChannel:"opfs-worker"};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(o=>o&&i.matchMinimatch(e,o))&&!s.exclude.some(o=>o&&i.matchMinimatch(e,o))))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.OPFSError("Failed to initialize OPFS","INIT_FAILED",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 o of r)s=await s.getDirectoryHandle(o,{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 o=`${a==="/"?"":a}/${s.name}`;try{const n=await this.stat(o);t.set(o,n),n.isDirectory&&await e(o)}catch(n){console.warn(`Skipping broken entry: ${o}`,n)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await e("/"),t}async readFile(t,e){await this.mount(),e||(e=i.isBinaryFileExtension(t)?"binary":"utf-8");try{const a=await this.getFileHandle(t,!1,this.root),r=await i.readFileData(a,t);return e==="binary"?r:i.decodeBuffer(r,e)}catch(a){throw new i.FileNotFoundError(t,a)}}async writeFile(t,e,a){await this.mount();const r=await this.exists(t),s=await this.getFileHandle(t,!0);a||(a=typeof e!="string"||i.isBinaryFileExtension(t)?"binary":"utf-8"),await i.writeFileData(s,e,a,t),r?await this.notifyChange({path:t,type:"changed",isDirectory:!1}):await this.notifyChange({path:t,type:"added",isDirectory:!1})}async appendFile(t,e,a){await this.mount();const r=await this.getFileHandle(t,!0);a||(a=typeof e!="string"||i.isBinaryFileExtension(t)?"binary":"utf-8"),await i.writeFileData(r,e,a,t,{append:!0}),await this.notifyChange({path:t,type:"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 o=0;o<r.length;o++){const n=r[o];try{s=await s.getDirectoryHandle(n,{create:a||o===r.length-1})}catch(c){throw c.name==="NotFoundError"?new i.OPFSError(`Parent directory does not exist: ${i.joinPath(r.slice(0,o+1))}`,"ENOENT",void 0,c):c.name==="TypeMismatchError"?new i.OPFSError(`Path segment is not a directory: ${n}`,"ENOTDIR",void 0,c):new i.OPFSError("Failed to create directory","MKDIR_FAILED",void 0,c)}}await this.notifyChange({path:t,type:"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),a=await this.getDirectoryHandle(i.dirname(t),!1),r=this.options.hashAlgorithm!==null;try{const o=await(await a.getFileHandle(e,{create:!1})).getFile(),n={kind:"file",size:o.size,mtime:new Date(o.lastModified).toISOString(),ctime:new Date(o.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(r&&this.options.hashAlgorithm)try{const c=await i.calculateFileHash(o,this.options.hashAlgorithm,this.options.maxFileSize);n.hash=c}catch(c){console.warn(`Failed to calculate hash for ${t}:`,c)}return n}catch(s){if(s.name!=="TypeMismatchError"&&s.name!=="NotFoundError")throw new i.OPFSError("Failed to stat (file)","STAT_FAILED",void 0,s)}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(s){throw s.name==="NotFoundError"?new i.OPFSError(`No such file or directory: ${t}`,"ENOENT",void 0,s):new i.OPFSError("Failed to stat (directory)","STAT_FAILED",void 0,s)}}async readDir(t){await this.mount();const e=await this.getDirectoryHandle(t,!1),a=[];for await(const[r,s]of e.entries()){const o=s.kind==="file";a.push({name:r,kind:s.kind,isFile:o,isDirectory:!o})}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:"changed",isDirectory:!0})}catch(e){throw e instanceof i.OPFSError?e:new i.OPFSError(`Failed to clear directory: ${t}`,"CLEAR_FAILED",void 0,e)}}async remove(t,e){if(await this.mount(),t==="/")throw new i.OPFSError("Cannot remove root directory","EROOT");const{recursive:a=!1,force:r=!1}=e||{},s=await this.getDirectoryHandle(i.dirname(t),!1);await i.removeEntry(s,t,{recursive:a,force:r}),await this.notifyChange({path:t,type:"removed",isDirectory:!1})}async realpath(t){await this.mount();try{const e=i.resolvePath(t);if(!await this.exists(e))throw new i.FileNotFoundError(e);return e}catch(e){throw e instanceof i.OPFSError?e:new i.OPFSError(`Failed to resolve path: ${t}`,"REALPATH_FAILED",void 0,e)}}async rename(t,e,a){await this.mount();try{const r=a?.overwrite??!1;if(!await this.exists(t))throw new i.FileNotFoundError(t);if(await this.exists(e)&&!r)throw new i.OPFSError(`Destination already exists: ${e}`,"EEXIST",void 0);await this.copy(t,e,{recursive:!0,overwrite:r}),await this.remove(t,{recursive:!0}),await this.notifyChange({path:t,type:"removed",isDirectory:!1}),await this.notifyChange({path:e,type:"added",isDirectory:!1})}catch(r){throw r instanceof i.OPFSError?r:new i.OPFSError(`Failed to rename from ${t} to ${e}`,"RENAME_FAILED",void 0,r)}}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.OPFSError(`Source does not exist: ${t}`,"ENOENT",void 0);if(await this.exists(e)&&!s)throw new i.OPFSError(`Destination already exists: ${e}`,"EEXIST",void 0);if((await this.stat(t)).isFile){const l=await this.readFile(t,"binary");await this.writeFile(e,l)}else{if(!r)throw new i.OPFSError(`Cannot copy directory without recursive option: ${t}`,"EISDIR",void 0);await this.mkdir(e,{recursive:!0});const l=await this.readDir(t);for(const h of l){const d=`${t}/${h.name}`,f=`${e}/${h.name}`;await this.copy(d,f,{recursive:!0,overwrite:s})}}}catch(r){throw r instanceof i.OPFSError?r:new i.OPFSError(`Failed to copy from ${t} to ${e}`,"CP_FAILED",void 0,r)}}async watch(t,e){if(!this.options.broadcastChannel)throw new i.OPFSError("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.","ENOENT");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)}dispose(){this.broadcastChannel&&(this.broadcastChannel.close(),this.broadcastChannel=null),this.watchers.clear()}async sync(t,e){await this.mount();try{(e?.cleanBefore??!1)&&await this.clear("/");for(const[r,s]of t){const o=i.normalizePath(r);let n;s instanceof Blob?n=await i.convertBlobToUint8Array(s):n=s,await this.writeFile(o,n)}}catch(a){throw a instanceof i.OPFSError?a:new i.OPFSError("Failed to sync file system","SYNC_FAILED",void 0,a)}}}typeof globalThis<"u"&&globalThis.constructor.name==="DedicatedWorkerGlobalScope"&&m.expose(new w);exports.OPFSWorker=w;
 //# sourceMappingURL=raw.cjs.map