opfs-worker 0.5.1 → 1.0.0

package/dist/index.cjs

@@ -1,9 +1,9 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("comlink"),n=require("./helpers-BfBe8lFJ.cjs"),i=`/**
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("comlink"),n=require("./helpers-Cvjm0f_r.cjs"),i=`/**
  * @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();
@@ -12,7 +12,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;
@@ -29,8 +29,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)
@@ -296,13 +296,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":
@@ -368,17 +367,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);
@@ -386,7 +385,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) {
@@ -421,7 +420,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) {
@@ -430,15 +429,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);
@@ -476,7 +475,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");
@@ -497,27 +496,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];
@@ -529,7 +528,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;
@@ -782,8 +781,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]))) {
@@ -863,27 +862,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 = {
@@ -891,42 +890,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;
@@ -1167,10 +1166,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;
@@ -1180,7 +1179,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) {
@@ -1222,11 +1221,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;
   }
@@ -1242,12 +1241,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 + ").+$");
@@ -1292,7 +1291,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
@@ -1446,6 +1445,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) {
@@ -1458,7 +1458,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 */
@@ -1541,13 +1541,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;
       }
@@ -1564,7 +1565,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
@@ -1661,7 +1662,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);
@@ -1962,8 +1963,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
@@ -1998,26 +1999,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);
     }
   }
   /**
@@ -2029,7 +2039,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
    * 
@@ -2042,13 +2052,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)
@@ -2063,7 +2073,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) {
@@ -2163,6 +2173,6 @@ class os {
   }
 }
 typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && J(new os());
-//# sourceMappingURL=worker-DYhMhDRt.js.map
+//# sourceMappingURL=worker-XHCzp1qX.js.map
 `,r=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",i],{type:"text/javascript;charset=utf-8"});function a(t){let e;try{if(e=r&&(self.URL||self.webkitURL).createObjectURL(r),!e)throw"";const s=new Worker(e,{type:"module",name:t?.name});return s.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(e)}),s}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(i),{type:"module",name:t?.name})}}async function h(t){const e=o.wrap(new a);return t&&(t.broadcastChannel&&t.broadcastChannel instanceof BroadcastChannel&&(t.broadcastChannel=t.broadcastChannel.name),await e.setOptions(t)),e}exports.BINARY_FILE_EXTENSIONS=n.BINARY_FILE_EXTENSIONS;exports.DirectoryNotFoundError=n.DirectoryNotFoundError;exports.FileNotFoundError=n.FileNotFoundError;exports.OPFSError=n.OPFSError;exports.OPFSNotMountedError=n.OPFSNotMountedError;exports.OPFSNotSupportedError=n.OPFSNotSupportedError;exports.PathError=n.PathError;exports.PermissionError=n.PermissionError;exports.StorageError=n.StorageError;exports.TimeoutError=n.TimeoutError;exports.basename=n.basename;exports.buffersEqual=n.buffersEqual;exports.calculateFileHash=n.calculateFileHash;exports.checkOPFSSupport=n.checkOPFSSupport;exports.convertBlobToUint8Array=n.convertBlobToUint8Array;exports.createBuffer=n.createBuffer;exports.decodeBuffer=n.decodeBuffer;exports.dirname=n.dirname;exports.encodeString=n.encodeString;exports.extname=n.extname;exports.isBinaryFileExtension=n.isBinaryFileExtension;exports.isPathExcluded=n.isPathExcluded;exports.joinPath=n.joinPath;exports.matchMinimatch=n.matchMinimatch;exports.normalizeMinimatch=n.normalizeMinimatch;exports.normalizePath=n.normalizePath;exports.readFileData=n.readFileData;exports.removeEntry=n.removeEntry;exports.resolvePath=n.resolvePath;exports.splitPath=n.splitPath;exports.withLock=n.withLock;exports.writeFileData=n.writeFileData;exports.createWorker=h;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAgBA,eAAsBA,EAClBC,EACyB,CACzB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIH,IAEIA,EAAQ,kBAAoBA,EAAQ,4BAA4B,mBAChEA,EAAQ,iBAAmBA,EAAQ,iBAAiB,MAGxD,MAAMC,EAAQ,WAAWD,CAAO,GAG7BC,CACX"}
+{"version":3,"file":"index.cjs","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAgBA,eAAsBA,EAClBC,EACyB,CACzB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIH,IAEIA,EAAQ,kBAAoBA,EAAQ,4BAA4B,mBAChEA,EAAQ,iBAAmBA,EAAQ,iBAAiB,MAGxD,MAAMC,EAAQ,WAAWD,CAAO,GAG7BC,CACX"}