opfs-worker 0.3.3 → 0.5.0

package/dist/index.js

@@ -1,77 +1,77 @@
 import { wrap as i } from "comlink";
-import { D as d, F as f, O as p, b as u, a as y, P as m, c as w, S as g, T as v, e as b, k as E, d as S, l as F, h as P, o as x, f as D, m as C, g as T, j as A, n as O, i as _, r as I, s as U, w as R } from "./helpers-DxFcNkZe.js";
-const a = `/**
+import { D as p, F as f, O as d, b as u, a as g, P as m, c as w, S as y, T as b, e as v, q as S, p as x, d as E, t as P, k as A, x as F, f as O, v as C, h as T, i as R, j as $, m as _, g as D, n as I, l as M, u as j, r as N, s as k, w as L, o as U } from "./helpers-Bm2TWyPQ.js";
+const r = `/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), C = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (e) => typeof e == "object" && e !== null || typeof e == "function", W = {
-  canHandle: (e) => $(e) && e[H],
-  serialize(e) {
-    const { port1: t, port2: r } = new MessageChannel();
-    return x(e, t), [r, [r]];
+const ht = Symbol("Comlink.proxy"), Dt = Symbol("Comlink.endpoint"), Ot = Symbol("Comlink.releaseProxy"), U = Symbol("Comlink.finalizer"), L = Symbol("Comlink.thrown"), ut = (s) => typeof s == "object" && s !== null || typeof s == "function", Nt = {
+  canHandle: (s) => ut(s) && s[ht],
+  serialize(s) {
+    const { port1: t, port2: e } = new MessageChannel();
+    return Y(s, t), [e, [e]];
   },
-  deserialize(e) {
-    return e.start(), Y(e);
+  deserialize(s) {
+    return s.start(), $t(s);
   }
-}, j = {
-  canHandle: (e) => $(e) && p in e,
-  serialize({ value: e }) {
+}, Ft = {
+  canHandle: (s) => ut(s) && L in s,
+  serialize({ value: s }) {
     let t;
-    return e instanceof Error ? t = {
+    return s instanceof Error ? t = {
       isError: !0,
       value: {
-        message: e.message,
-        name: e.name,
-        stack: e.stack
+        message: s.message,
+        name: s.name,
+        stack: s.stack
       }
-    } : t = { isError: !1, value: e }, [t, []];
+    } : t = { isError: !1, value: s }, [t, []];
   },
-  deserialize(e) {
-    throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
+  deserialize(s) {
+    throw s.isError ? Object.assign(new Error(s.value.message), s.value) : s.value;
   }
-}, z = /* @__PURE__ */ new Map([
-  ["proxy", W],
-  ["throw", j]
+}, ft = /* @__PURE__ */ new Map([
+  ["proxy", Nt],
+  ["throw", Ft]
 ]);
-function V(e, t) {
-  for (const r of e)
-    if (t === r || r === "*" || r instanceof RegExp && r.test(t))
+function Tt(s, t) {
+  for (const e of s)
+    if (t === e || e === "*" || e instanceof RegExp && e.test(t))
       return !0;
   return !1;
 }
-function x(e, t = globalThis, r = ["*"]) {
-  t.addEventListener("message", function i(n) {
-    if (!n || !n.data)
+function Y(s, t = globalThis, e = ["*"]) {
+  t.addEventListener("message", function n(i) {
+    if (!i || !i.data)
       return;
-    if (!V(r, n.origin)) {
-      console.warn(\`Invalid origin '\${n.origin}' for comlink proxy\`);
+    if (!Tt(e, i.origin)) {
+      console.warn(\`Invalid origin '\${i.origin}' for comlink proxy\`);
       return;
     }
-    const { id: a, type: s, path: o } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(d);
+    const { id: r, type: o, path: a } = Object.assign({ path: [] }, i.data), l = (i.data.argumentList || []).map(C);
     let h;
     try {
-      const u = o.slice(0, -1).reduce((f, g) => f[g], e), w = o.reduce((f, g) => f[g], e);
-      switch (s) {
+      const c = a.slice(0, -1).reduce((u, d) => u[d], s), f = a.reduce((u, d) => u[d], s);
+      switch (o) {
         case "GET":
-          h = w;
+          h = f;
           break;
         case "SET":
-          u[o.slice(-1)[0]] = d(n.data.value), h = !0;
+          c[a.slice(-1)[0]] = C(i.data.value), h = !0;
           break;
         case "APPLY":
-          h = w.apply(u, l);
+          h = f.apply(c, l);
           break;
         case "CONSTRUCT":
           {
-            const f = new w(...l);
-            h = Q(f);
+            const u = new f(...l);
+            h = It(u);
           }
           break;
         case "ENDPOINT":
           {
-            const { port1: f, port2: g } = new MessageChannel();
-            x(e, g), h = J(f, [f]);
+            const { port1: u, port2: d } = new MessageChannel();
+            Y(s, d), h = Lt(u, [u]);
           }
           break;
         case "RELEASE":
@@ -80,360 +80,1334 @@ function x(e, t = globalThis, r = ["*"]) {
         default:
           return;
       }
-    } catch (u) {
-      h = { value: u, [p]: 0 };
+    } catch (c) {
+      h = { value: c, [L]: 0 };
     }
-    Promise.resolve(h).catch((u) => ({ value: u, [p]: 0 })).then((u) => {
-      const [w, f] = A(u);
-      t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f), s === "RELEASE" && (t.removeEventListener("message", i), L(t), C in e && typeof e[C] == "function" && e[C]());
-    }).catch((u) => {
-      const [w, f] = A({
+    Promise.resolve(h).catch((c) => ({ value: c, [L]: 0 })).then((c) => {
+      const [f, u] = H(c);
+      t.postMessage(Object.assign(Object.assign({}, f), { id: r }), u), o === "RELEASE" && (t.removeEventListener("message", n), dt(t), U in s && typeof s[U] == "function" && s[U]());
+    }).catch((c) => {
+      const [f, u] = H({
         value: new TypeError("Unserializable return value"),
-        [p]: 0
+        [L]: 0
       });
-      t.postMessage(Object.assign(Object.assign({}, w), { id: a }), f);
+      t.postMessage(Object.assign(Object.assign({}, f), { id: r }), u);
     });
   }), t.start && t.start();
 }
-function G(e) {
-  return e.constructor.name === "MessagePort";
+function Mt(s) {
+  return s.constructor.name === "MessagePort";
 }
-function L(e) {
-  G(e) && e.close();
+function dt(s) {
+  Mt(s) && s.close();
 }
-function Y(e, t) {
-  const r = /* @__PURE__ */ new Map();
-  return e.addEventListener("message", function(n) {
-    const { data: a } = n;
-    if (!a || !a.id)
+function $t(s, t) {
+  const e = /* @__PURE__ */ new Map();
+  return s.addEventListener("message", function(i) {
+    const { data: r } = i;
+    if (!r || !r.id)
       return;
-    const s = r.get(a.id);
-    if (s)
+    const o = e.get(r.id);
+    if (o)
       try {
-        s(a);
+        o(r);
       } finally {
-        r.delete(a.id);
+        e.delete(r.id);
       }
-  }), M(e, r, [], t);
+  }), V(s, e, [], t);
 }
-function E(e) {
-  if (e)
+function R(s) {
+  if (s)
     throw new Error("Proxy has been released and is not useable");
 }
-function U(e) {
-  return y(e, /* @__PURE__ */ new Map(), {
+function pt(s) {
+  return D(s, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
-    L(e);
+    dt(s);
   });
 }
-const S = /* @__PURE__ */ new WeakMap(), D = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
-  const t = (S.get(e) || 0) - 1;
-  S.set(e, t), t === 0 && U(e);
+const I = /* @__PURE__ */ new WeakMap(), z = "FinalizationRegistry" in globalThis && new FinalizationRegistry((s) => {
+  const t = (I.get(s) || 0) - 1;
+  I.set(s, t), t === 0 && pt(s);
 });
-function X(e, t) {
-  const r = (S.get(t) || 0) + 1;
-  S.set(t, r), D && D.register(e, t, e);
+function Pt(s, t) {
+  const e = (I.get(t) || 0) + 1;
+  I.set(t, e), z && z.register(s, t, s);
 }
-function q(e) {
-  D && D.unregister(e);
+function Rt(s) {
+  z && z.unregister(s);
 }
-function M(e, t, r = [], i = function() {
+function V(s, t, e = [], n = function() {
 }) {
-  let n = !1;
-  const a = new Proxy(i, {
-    get(s, o) {
-      if (E(n), o === B)
+  let i = !1;
+  const r = new Proxy(n, {
+    get(o, a) {
+      if (R(i), a === Ot)
         return () => {
-          q(a), U(e), t.clear(), n = !0;
+          Rt(r), pt(s), t.clear(), i = !0;
         };
-      if (o === "then") {
-        if (r.length === 0)
-          return { then: () => a };
-        const l = y(e, t, {
+      if (a === "then") {
+        if (e.length === 0)
+          return { then: () => r };
+        const l = D(s, t, {
           type: "GET",
-          path: r.map((h) => h.toString())
-        }).then(d);
+          path: e.map((h) => h.toString())
+        }).then(C);
         return l.then.bind(l);
       }
-      return M(e, t, [...r, o]);
+      return V(s, t, [...e, a]);
     },
-    set(s, o, l) {
-      E(n);
-      const [h, u] = A(l);
-      return y(e, t, {
+    set(o, a, l) {
+      R(i);
+      const [h, c] = H(l);
+      return D(s, t, {
         type: "SET",
-        path: [...r, o].map((w) => w.toString()),
+        path: [...e, a].map((f) => f.toString()),
         value: h
-      }, u).then(d);
+      }, c).then(C);
     },
-    apply(s, o, l) {
-      E(n);
-      const h = r[r.length - 1];
-      if (h === R)
-        return y(e, t, {
+    apply(o, a, l) {
+      R(i);
+      const h = e[e.length - 1];
+      if (h === Dt)
+        return D(s, t, {
           type: "ENDPOINT"
-        }).then(d);
+        }).then(C);
       if (h === "bind")
-        return M(e, t, r.slice(0, -1));
-      const [u, w] = v(l);
-      return y(e, t, {
+        return V(s, t, e.slice(0, -1));
+      const [c, f] = et(l);
+      return D(s, t, {
         type: "APPLY",
-        path: r.map((f) => f.toString()),
-        argumentList: u
-      }, w).then(d);
+        path: e.map((u) => u.toString()),
+        argumentList: c
+      }, f).then(C);
     },
-    construct(s, o) {
-      E(n);
-      const [l, h] = v(o);
-      return y(e, t, {
+    construct(o, a) {
+      R(i);
+      const [l, h] = et(a);
+      return D(s, t, {
         type: "CONSTRUCT",
-        path: r.map((u) => u.toString()),
+        path: e.map((c) => c.toString()),
         argumentList: l
-      }, h).then(d);
+      }, h).then(C);
     }
   });
-  return X(a, e), a;
+  return Pt(r, s), r;
 }
-function K(e) {
-  return Array.prototype.concat.apply([], e);
+function kt(s) {
+  return Array.prototype.concat.apply([], s);
 }
-function v(e) {
-  const t = e.map(A);
-  return [t.map((r) => r[0]), K(t.map((r) => r[1]))];
+function et(s) {
+  const t = s.map(H);
+  return [t.map((e) => e[0]), kt(t.map((e) => e[1]))];
 }
-const _ = /* @__PURE__ */ new WeakMap();
-function J(e, t) {
-  return _.set(e, t), e;
+const gt = /* @__PURE__ */ new WeakMap();
+function Lt(s, t) {
+  return gt.set(s, t), s;
 }
-function Q(e) {
-  return Object.assign(e, { [H]: !0 });
+function It(s) {
+  return Object.assign(s, { [ht]: !0 });
 }
-function A(e) {
-  for (const [t, r] of z)
-    if (r.canHandle(e)) {
-      const [i, n] = r.serialize(e);
+function H(s) {
+  for (const [t, e] of ft)
+    if (e.canHandle(s)) {
+      const [n, i] = e.serialize(s);
       return [
         {
           type: "HANDLER",
           name: t,
-          value: i
+          value: n
         },
-        n
+        i
       ];
     }
   return [
     {
       type: "RAW",
-      value: e
+      value: s
     },
-    _.get(e) || []
+    gt.get(s) || []
   ];
 }
-function d(e) {
-  switch (e.type) {
+function C(s) {
+  switch (s.type) {
     case "HANDLER":
-      return z.get(e.name).deserialize(e.value);
+      return ft.get(s.name).deserialize(s.value);
     case "RAW":
-      return e.value;
+      return s.value;
   }
 }
-function y(e, t, r, i) {
-  return new Promise((n) => {
-    const a = Z();
-    t.set(a, n), e.start && e.start(), e.postMessage(Object.assign({ id: a }, r), i);
+function D(s, t, e, n) {
+  return new Promise((i) => {
+    const r = zt();
+    t.set(r, i), s.start && s.start(), s.postMessage(Object.assign({ id: r }, e), n);
   });
 }
-function Z() {
+function zt() {
   return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
 }
-class c extends Error {
-  constructor(t, r, i) {
-    super(t), this.code = r, this.path = i, this.name = "OPFSError";
+class g extends Error {
+  constructor(t, e, n, i) {
+    super(t, { cause: i }), this.code = e, this.path = n, this.name = "OPFSError";
   }
 }
-class tt extends c {
-  constructor() {
-    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
-  }
-}
-class b extends c {
-  constructor() {
-    super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
+class Ht extends g {
+  constructor(t) {
+    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED", void 0, t);
   }
 }
-class N extends c {
-  constructor(t, r) {
-    super(t, "INVALID_PATH", r);
+class Wt extends g {
+  constructor(t, e, n) {
+    super(t, "INVALID_PATH", e, n);
   }
 }
-class T extends c {
-  constructor(t) {
-    super(\`File not found: \${t}\`, "FILE_NOT_FOUND", t);
+class _ extends g {
+  constructor(t, e) {
+    super(\`File not found: \${t}\`, "FILE_NOT_FOUND", t, e);
   }
 }
-function et(e, t = "utf-8") {
+function jt(s, t = "utf-8") {
   switch (t) {
     case "utf8":
     case "utf-8":
-      return new TextEncoder().encode(e);
+      return new TextEncoder().encode(s);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return nt(e);
+      return _t(s);
     case "ascii":
-      return st(e);
+      return qt(s);
     case "latin1":
-      return at(e);
+      return Gt(s);
     case "binary":
-      return Uint8Array.from(e, (r) => r.charCodeAt(0));
+      return Uint8Array.from(s, (e) => e.charCodeAt(0));
     case "base64":
-      return Uint8Array.from(atob(e), (r) => r.charCodeAt(0));
+      return Uint8Array.from(atob(s), (e) => e.charCodeAt(0));
     case "hex":
-      if (!/^[\\da-f]+$/i.test(e) || e.length % 2 !== 0)
-        throw new c("Invalid hex string", "INVALID_HEX_FORMAT");
-      return Uint8Array.from(e.match(/.{1,2}/g).map((r) => parseInt(r, 16)));
+      if (!/^[\\da-f]+$/i.test(s) || s.length % 2 !== 0)
+        throw new g("Invalid hex string", "INVALID_HEX_FORMAT");
+      return Uint8Array.from(s.match(/.{1,2}/g).map((e) => parseInt(e, 16)));
     default:
-      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(e);
+      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(s);
   }
 }
-function rt(e, t = "utf-8") {
+function Ut(s, t = "utf-8") {
   switch (t) {
     case "utf8":
     case "utf-8":
-      return new TextDecoder().decode(e);
+      return new TextDecoder().decode(s);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return it(e);
+      return Bt(s);
     case "latin1":
-      return String.fromCharCode(...e);
+      return String.fromCharCode(...s);
     case "binary":
-      return String.fromCharCode(...e);
+      return String.fromCharCode(...s);
     case "ascii":
-      return String.fromCharCode(...e.map((r) => r & 127));
+      return String.fromCharCode(...s.map((e) => e & 127));
     case "base64":
-      return btoa(String.fromCharCode(...e));
+      return btoa(String.fromCharCode(...s));
     case "hex":
-      return Array.from(e).map((r) => r.toString(16).padStart(2, "0")).join("");
+      return Array.from(s).map((e) => e.toString(16).padStart(2, "0")).join("");
     default:
-      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(e);
+      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(s);
   }
 }
-function nt(e) {
-  const t = new Uint8Array(e.length * 2);
-  for (let r = 0; r < e.length; r++) {
-    const i = e.charCodeAt(r);
-    t[r * 2] = i & 255, t[r * 2 + 1] = i >> 8;
+function _t(s) {
+  const t = new Uint8Array(s.length * 2);
+  for (let e = 0; e < s.length; e++) {
+    const n = s.charCodeAt(e);
+    t[e * 2] = n & 255, t[e * 2 + 1] = n >> 8;
   }
   return t;
 }
-function it(e) {
-  e.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), e = e.slice(0, e.length - 1));
-  const t = new Uint16Array(e.buffer, e.byteOffset, e.byteLength / 2);
+function Bt(s) {
+  s.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), s = s.slice(0, s.length - 1));
+  const t = new Uint16Array(s.buffer, s.byteOffset, s.byteLength / 2);
   return String.fromCharCode(...t);
 }
-function at(e) {
-  const t = new Uint8Array(e.length);
-  for (let r = 0; r < e.length; r++)
-    t[r] = e.charCodeAt(r) & 255;
+function Gt(s) {
+  const t = new Uint8Array(s.length);
+  for (let e = 0; e < s.length; e++)
+    t[e] = s.charCodeAt(e) & 255;
   return t;
 }
-function st(e) {
-  const t = new Uint8Array(e.length);
-  for (let r = 0; r < e.length; r++)
-    t[r] = e.charCodeAt(r) & 127;
+function qt(s) {
+  const t = new Uint8Array(s.length);
+  for (let e = 0; e < s.length; e++)
+    t[e] = s.charCodeAt(e) & 127;
   return t;
 }
-function ot() {
+const mt = (s, t, e) => {
+  const n = s instanceof RegExp ? st(s, e) : s, i = t instanceof RegExp ? st(t, e) : t, r = n !== null && i != null && Vt(n, i, e);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: e.slice(0, r[0]),
+    body: e.slice(r[0] + n.length, r[1]),
+    post: e.slice(r[1] + i.length)
+  };
+}, st = (s, t) => {
+  const e = t.match(s);
+  return e ? e[0] : null;
+}, Vt = (s, t, e) => {
+  let n, i, r, o, a, l = e.indexOf(s), h = e.indexOf(t, l + 1), c = l;
+  if (l >= 0 && h > 0) {
+    if (s === t)
+      return [l, h];
+    for (n = [], r = e.length; c >= 0 && !a; ) {
+      if (c === l)
+        n.push(c), l = e.indexOf(s, c + 1);
+      else if (n.length === 1) {
+        const f = n.pop();
+        f !== void 0 && (a = [f, h]);
+      } else
+        i = n.pop(), i !== void 0 && i < r && (r = i, o = h), h = e.indexOf(t, c + 1);
+      c = l < h && l >= 0 ? l : h;
+    }
+    n.length && o !== void 0 && (a = [r, o]);
+  }
+  return a;
+}, wt = "\\0SLASH" + Math.random() + "\\0", yt = "\\0OPEN" + Math.random() + "\\0", J = "\\0CLOSE" + Math.random() + "\\0", Et = "\\0COMMA" + Math.random() + "\\0", St = "\\0PERIOD" + Math.random() + "\\0", Zt = new RegExp(wt, "g"), Xt = new RegExp(yt, "g"), Yt = new RegExp(J, "g"), Jt = new RegExp(Et, "g"), Kt = new RegExp(St, "g"), Qt = /\\\\\\\\/g, te = /\\\\{/g, ee = /\\\\}/g, se = /\\\\,/g, ne = /\\\\./g;
+function B(s) {
+  return isNaN(s) ? s.charCodeAt(0) : parseInt(s, 10);
+}
+function ie(s) {
+  return s.replace(Qt, wt).replace(te, yt).replace(ee, J).replace(se, Et).replace(ne, St);
+}
+function re(s) {
+  return s.replace(Zt, "\\\\").replace(Xt, "{").replace(Yt, "}").replace(Jt, ",").replace(Kt, ".");
+}
+function xt(s) {
+  if (!s)
+    return [""];
+  const t = [], e = mt("{", "}", s);
+  if (!e)
+    return s.split(",");
+  const { pre: n, body: i, post: r } = e, o = n.split(",");
+  o[o.length - 1] += "{" + i + "}";
+  const a = xt(r);
+  return r.length && (o[o.length - 1] += a.shift(), o.push.apply(o, a)), t.push.apply(t, o), t;
+}
+function oe(s) {
+  return s ? (s.slice(0, 2) === "{}" && (s = "\\\\{\\\\}" + s.slice(2)), M(ie(s), !0).map(re)) : [];
+}
+function ae(s) {
+  return "{" + s + "}";
+}
+function ce(s) {
+  return /^-?0\\d/.test(s);
+}
+function le(s, t) {
+  return s <= t;
+}
+function he(s, t) {
+  return s >= t;
+}
+function M(s, t) {
+  const e = [], n = mt("{", "}", s);
+  if (!n)
+    return [s];
+  const i = n.pre, r = n.post.length ? M(n.post, !1) : [""];
+  if (/\\$$/.test(n.pre))
+    for (let o = 0; o < r.length; o++) {
+      const a = i + "{" + n.body + "}" + r[o];
+      e.push(a);
+    }
+  else {
+    const o = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(n.body), a = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(n.body), l = o || a, h = n.body.indexOf(",") >= 0;
+    if (!l && !h)
+      return n.post.match(/,(?!,).*\\}/) ? (s = n.pre + "{" + n.body + J + n.post, M(s)) : [s];
+    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(ae), c.length === 1))
+      return r.map((u) => n.pre + c[0] + u);
+    let f;
+    if (l && c[0] !== void 0 && c[1] !== void 0) {
+      const u = B(c[0]), d = B(c[1]), m = Math.max(c[0].length, c[1].length);
+      let p = c.length === 3 && c[2] !== void 0 ? Math.abs(B(c[2])) : 1, S = le;
+      d < u && (p *= -1, S = he);
+      const N = c.some(ce);
+      f = [];
+      for (let x = u; S(x, d); x += p) {
+        let w;
+        if (a)
+          w = String.fromCharCode(x), w === "\\\\" && (w = "");
+        else if (w = String(x), N) {
+          const F = m - w.length;
+          if (F > 0) {
+            const P = new Array(F + 1).join("0");
+            x < 0 ? w = "-" + P + w.slice(1) : w = P + w;
+          }
+        }
+        f.push(w);
+      }
+    } else {
+      f = [];
+      for (let u = 0; u < c.length; u++)
+        f.push.apply(f, M(c[u], !1));
+    }
+    for (let u = 0; u < f.length; u++)
+      for (let d = 0; d < r.length; d++) {
+        const m = i + f[u] + r[d];
+        (!t || l || m) && e.push(m);
+      }
+  }
+  return e;
+}
+const ue = 1024 * 64, W = (s) => {
+  if (typeof s != "string")
+    throw new TypeError("invalid pattern");
+  if (s.length > ue)
+    throw new TypeError("pattern is too long");
+}, fe = {
+  "[:alnum:]": ["\\\\p{L}\\\\p{Nl}\\\\p{Nd}", !0],
+  "[:alpha:]": ["\\\\p{L}\\\\p{Nl}", !0],
+  "[:ascii:]": ["\\\\x00-\\\\x7f", !1],
+  "[:blank:]": ["\\\\p{Zs}\\\\t", !0],
+  "[:cntrl:]": ["\\\\p{Cc}", !0],
+  "[:digit:]": ["\\\\p{Nd}", !0],
+  "[:graph:]": ["\\\\p{Z}\\\\p{C}", !0, !0],
+  "[:lower:]": ["\\\\p{Ll}", !0],
+  "[:print:]": ["\\\\p{C}", !0],
+  "[:punct:]": ["\\\\p{P}", !0],
+  "[:space:]": ["\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f", !0],
+  "[: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, "\\\\$&"), de = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), nt = (s) => s.join(""), pe = (s, t) => {
+  const e = t;
+  if (s.charAt(e) !== "[")
+    throw new Error("not in a brace expression");
+  const n = [], i = [];
+  let r = e + 1, o = !1, a = !1, l = !1, h = !1, c = e, f = "";
+  t: for (; r < s.length; ) {
+    const p = s.charAt(r);
+    if ((p === "!" || p === "^") && r === e + 1) {
+      h = !0, r++;
+      continue;
+    }
+    if (p === "]" && o && !l) {
+      c = r + 1;
+      break;
+    }
+    if (o = !0, p === "\\\\" && !l) {
+      l = !0, r++;
+      continue;
+    }
+    if (p === "[" && !l) {
+      for (const [S, [v, N, x]] of Object.entries(fe))
+        if (s.startsWith(S, r)) {
+          if (f)
+            return ["$.", !1, s.length - e, !0];
+          r += S.length, x ? i.push(v) : n.push(v), 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++;
+      continue;
+    }
+    if (s.startsWith("-]", r + 1)) {
+      n.push(T(p + "-")), r += 2;
+      continue;
+    }
+    if (s.startsWith("-", r + 1)) {
+      f = p, r += 2;
+      continue;
+    }
+    n.push(T(p)), r++;
+  }
+  if (c < r)
+    return ["", !1, 0, !1];
+  if (!n.length && !i.length)
+    return ["$.", !1, s.length - e, !0];
+  if (i.length === 0 && n.length === 1 && /^\\\\?.$/.test(n[0]) && !h) {
+    const p = n[0].length === 2 ? n[0].slice(-1) : n[0];
+    return [de(p), !1, c - e, !1];
+  }
+  const u = "[" + (h ? "^" : "") + nt(n) + "]", d = "[" + (h ? "" : "^") + nt(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"), ge = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), it = (s) => ge.has(s), me = "(?!(?:^|/)\\\\.\\\\.?(?:$|/))", k = "(?!\\\\.)", we = /* @__PURE__ */ new Set(["[", "."]), ye = /* @__PURE__ */ new Set(["..", "."]), Ee = new Set("().*{}+?[]^$\\\\!"), Se = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&"), K = "[^/]", rt = K + "*?", ot = K + "+?";
+class E {
+  type;
+  #s;
+  #n;
+  #r = !1;
+  #t = [];
+  #e;
+  #o;
+  #c;
+  #a = !1;
+  #i;
+  #l;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #u = !1;
+  constructor(t, e, n = {}) {
+    this.type = t, t && (this.#n = !0), this.#e = e, this.#s = this.#e ? this.#e.#s : this, this.#i = this.#s === this ? n : this.#s.#i, this.#c = this.#s === this ? [] : this.#s.#c, t === "!" && !this.#s.#a && this.#c.push(this), this.#o = this.#e ? this.#e.#t.length : 0;
+  }
+  get hasMagic() {
+    if (this.#n !== void 0)
+      return this.#n;
+    for (const t of this.#t)
+      if (typeof t != "string" && (t.type || t.hasMagic))
+        return this.#n = !0;
+    return this.#n;
+  }
+  // reconstructs the pattern
+  toString() {
+    return this.#l !== void 0 ? this.#l : this.type ? this.#l = this.type + "(" + this.#t.map((t) => String(t)).join("|") + ")" : this.#l = this.#t.map((t) => String(t)).join("");
+  }
+  #d() {
+    if (this !== this.#s)
+      throw new Error("should only call on root");
+    if (this.#a)
+      return this;
+    this.toString(), this.#a = !0;
+    let t;
+    for (; t = this.#c.pop(); ) {
+      if (t.type !== "!")
+        continue;
+      let e = t, n = e.#e;
+      for (; n; ) {
+        for (let i = e.#o + 1; !n.type && i < n.#t.length; i++)
+          for (const r of t.#t) {
+            if (typeof r == "string")
+              throw new Error("string part in extglob AST??");
+            r.copyIn(n.#t[i]);
+          }
+        e = n, n = e.#e;
+      }
+    }
+    return this;
+  }
+  push(...t) {
+    for (const e of t)
+      if (e !== "") {
+        if (typeof e != "string" && !(e instanceof E && e.#e === this))
+          throw new Error("invalid part: " + e);
+        this.#t.push(e);
+      }
+  }
+  toJSON() {
+    const t = this.type === null ? this.#t.slice().map((e) => typeof e == "string" ? e : e.toJSON()) : [this.type, ...this.#t.map((e) => e.toJSON())];
+    return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === this.#s || this.#s.#a && this.#e?.type === "!") && t.push({}), t;
+  }
+  isStart() {
+    if (this.#s === this)
+      return !0;
+    if (!this.#e?.isStart())
+      return !1;
+    if (this.#o === 0)
+      return !0;
+    const t = this.#e;
+    for (let e = 0; e < this.#o; e++) {
+      const n = t.#t[e];
+      if (!(n instanceof E && n.type === "!"))
+        return !1;
+    }
+    return !0;
+  }
+  isEnd() {
+    if (this.#s === this || this.#e?.type === "!")
+      return !0;
+    if (!this.#e?.isEnd())
+      return !1;
+    if (!this.type)
+      return this.#e?.isEnd();
+    const t = this.#e ? this.#e.#t.length : 0;
+    return this.#o === t - 1;
+  }
+  copyIn(t) {
+    typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+  }
+  clone(t) {
+    const e = new E(this.type, t);
+    for (const n of this.#t)
+      e.copyIn(n);
+    return e;
+  }
+  static #h(t, e, n, i) {
+    let r = !1, o = !1, a = -1, l = !1;
+    if (e.type === null) {
+      let d = n, m = "";
+      for (; d < t.length; ) {
+        const p = t.charAt(d++);
+        if (r || p === "\\\\") {
+          r = !r, m += p;
+          continue;
+        }
+        if (o) {
+          d === a + 1 ? (p === "^" || p === "!") && (l = !0) : p === "]" && !(d === a + 2 && l) && (o = !1), m += p;
+          continue;
+        } else if (p === "[") {
+          o = !0, a = d, l = !1, m += p;
+          continue;
+        }
+        if (!i.noext && it(p) && t.charAt(d) === "(") {
+          e.push(m), m = "";
+          const S = new E(p, e);
+          d = E.#h(t, S, d, i), e.push(S);
+          continue;
+        }
+        m += p;
+      }
+      return e.push(m), d;
+    }
+    let h = n + 1, c = new E(null, e);
+    const f = [];
+    let u = "";
+    for (; h < t.length; ) {
+      const d = t.charAt(h++);
+      if (r || d === "\\\\") {
+        r = !r, u += d;
+        continue;
+      }
+      if (o) {
+        h === a + 1 ? (d === "^" || d === "!") && (l = !0) : d === "]" && !(h === a + 2 && l) && (o = !1), u += d;
+        continue;
+      } else if (d === "[") {
+        o = !0, a = h, l = !1, u += d;
+        continue;
+      }
+      if (it(d) && t.charAt(h) === "(") {
+        c.push(u), u = "";
+        const m = new E(d, c);
+        c.push(m), h = E.#h(t, m, h, i);
+        continue;
+      }
+      if (d === "|") {
+        c.push(u), u = "", f.push(c), c = new E(null, e);
+        continue;
+      }
+      if (d === ")")
+        return u === "" && e.#t.length === 0 && (e.#u = !0), c.push(u), u = "", e.push(...f, c), h;
+      u += d;
+    }
+    return e.type = null, e.#n = void 0, e.#t = [t.substring(n - 1)], h;
+  }
+  static fromGlob(t, e = {}) {
+    const n = new E(null, void 0, e);
+    return E.#h(t, n, 0, e), n;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#s)
+      return this.#s.toMMPattern();
+    const t = this.toString(), [e, n, i, r] = this.toRegExpSource();
+    if (!(i || this.#n || this.#i.nocase && !this.#i.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase()))
+      return n;
+    const a = (this.#i.nocase ? "i" : "") + (r ? "u" : "");
+    return Object.assign(new RegExp(\`^\${e}$\`, a), {
+      _src: e,
+      _glob: t
+    });
+  }
+  get options() {
+    return this.#i;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\\.\\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\\.\\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\\.\\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\\.) and the start for a part
+  // is ^(?!\\.), we can just prepend (?!\\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(t) {
+    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;
+      }).join("");
+      let c = "";
+      if (this.isStart() && typeof this.#t[0] == "string" && !(this.#t.length === 1 && ye.has(this.#t[0]))) {
+        const m = we, p = (
+          // dots are allowed, and the pattern starts with [ or .
+          e && m.has(h.charAt(0)) || // the pattern starts with \\., and then [ or .
+          h.startsWith("\\\\.") && m.has(h.charAt(2)) || // the pattern starts with \\.\\., and then [ or .
+          h.startsWith("\\\\.\\\\.") && m.has(h.charAt(4))
+        ), S = !e && !t && m.has(h.charAt(0));
+        c = p ? me : S ? k : "";
+      }
+      let f = "";
+      return this.isEnd() && this.#s.#a && this.#e?.type === "!" && (f = "(?:$|\\\\/)"), [
+        c + h + f,
+        $(h),
+        this.#n = !!this.#n,
+        this.#r
+      ];
+    }
+    const n = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let r = this.#f(e);
+    if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+      const l = this.toString();
+      return this.#t = [l], this.type = null, this.#n = void 0, [l, $(this.toString()), !1, !1];
+    }
+    let o = !n || t || e || !k ? "" : this.#f(!0);
+    o === r && (o = ""), o && (r = \`(?:\${r})(?:\${o})*?\`);
+    let a = "";
+    if (this.type === "!" && this.#u)
+      a = (this.isStart() && !e ? k : "") + ot;
+    else {
+      const l = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !e && !t ? k : "") + rt + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : \`)\${this.type}\`;
+      a = i + r + l;
+    }
+    return [
+      a,
+      $(r),
+      this.#n = !!this.#n,
+      this.#r
+    ];
+  }
+  #f(t) {
+    return this.#t.map((e) => {
+      if (typeof e == "string")
+        throw new Error("string type in extglob ast??");
+      const [n, i, r, o] = e.toRegExpSource(t);
+      return this.#r = this.#r || o, n;
+    }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+  }
+  static #p(t, e, n = !1) {
+    let i = !1, r = "", o = !1;
+    for (let a = 0; a < t.length; a++) {
+      const l = t.charAt(a);
+      if (i) {
+        i = !1, r += (Ee.has(l) ? "\\\\" : "") + l;
+        continue;
+      }
+      if (l === "\\\\") {
+        a === t.length - 1 ? r += "\\\\\\\\" : i = !0;
+        continue;
+      }
+      if (l === "[") {
+        const [h, c, f, u] = pe(t, a);
+        if (f) {
+          r += h, o = o || c, a += f - 1, e = e || u;
+          continue;
+        }
+      }
+      if (l === "*") {
+        n && t === "*" ? r += ot : r += rt, e = !0;
+        continue;
+      }
+      if (l === "?") {
+        r += K, e = !0;
+        continue;
+      }
+      r += Se(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)), be = /^\\*+([^+@!?\\*\\[\\(]*)$/, Ae = (s) => (t) => !t.startsWith(".") && t.endsWith(s), ve = (s) => (t) => t.endsWith(s), Ce = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), De = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), Oe = /^\\*+\\.\\*+$/, Ne = (s) => !s.startsWith(".") && s.includes("."), Fe = (s) => s !== "." && s !== ".." && s.includes("."), Te = /^\\.\\*+$/, Me = (s) => s !== "." && s !== ".." && s.startsWith("."), $e = /^\\*+$/, Pe = (s) => s.length !== 0 && !s.startsWith("."), Re = (s) => s.length !== 0 && s !== "." && s !== "..", ke = /^\\?+([^+@!?\\*\\[\\(]*)?$/, Le = ([s, t = ""]) => {
+  const e = bt([s]);
+  return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
+}, Ie = ([s, t = ""]) => {
+  const e = At([s]);
+  return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
+}, ze = ([s, t = ""]) => {
+  const e = At([s]);
+  return t ? (n) => e(n) && n.endsWith(t) : e;
+}, He = ([s, t = ""]) => {
+  const e = bt([s]);
+  return t ? (n) => e(n) && n.endsWith(t) : e;
+}, bt = ([s]) => {
+  const t = s.length;
+  return (e) => e.length === t && !e.startsWith(".");
+}, At = ([s]) => {
+  const t = s.length;
+  return (e) => e.length === t && e !== "." && e !== "..";
+}, vt = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", at = {
+  win32: { sep: "\\\\" },
+  posix: { sep: "/" }
+}, We = vt === "win32" ? at.win32.sep : at.posix.sep;
+y.sep = We;
+const A = Symbol("globstar **");
+y.GLOBSTAR = A;
+const je = "[^/]", Ue = je + "*?", _e = "(?:(?!(?:\\\\/|^)(?:\\\\.{1,2})($|\\\\/)).)*?", Be = "(?:(?!(?:\\\\/|^)\\\\.).)*?", Ge = (s, t = {}) => (e) => y(e, s, t);
+y.filter = Ge;
+const b = (s, t = {}) => Object.assign({}, s, t), qe = (s) => {
+  if (!s || typeof s != "object" || !Object.keys(s).length)
+    return y;
+  const t = y;
+  return Object.assign((n, i, r = {}) => t(n, i, b(s, r)), {
+    Minimatch: class extends t.Minimatch {
+      constructor(i, r = {}) {
+        super(i, b(s, r));
+      }
+      static defaults(i) {
+        return t.defaults(b(s, i)).Minimatch;
+      }
+    },
+    AST: class extends t.AST {
+      /* c8 ignore start */
+      constructor(i, r, o = {}) {
+        super(i, r, b(s, o));
+      }
+      /* c8 ignore stop */
+      static fromGlob(i, r = {}) {
+        return t.AST.fromGlob(i, b(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
+  });
+};
+y.defaults = qe;
+const Ct = (s, t = {}) => (W(s), t.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(s) ? [s] : oe(s));
+y.braceExpand = Ct;
+const Ve = (s, t = {}) => new j(s, t).makeRe();
+y.makeRe = Ve;
+const Ze = (s, t, e = {}) => {
+  const n = new j(t, e);
+  return s = s.filter((i) => n.match(i)), n.options.nonull && !s.length && s.push(t), s;
+};
+y.match = Ze;
+const ct = /[?*]|[+@!]\\(.*?\\)|\\[|\\]/, Xe = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, "\\\\$&");
+class j {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(t, e = {}) {
+    W(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || vt, 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)
+      return !0;
+    for (const t of this.set)
+      for (const e of t)
+        if (typeof e != "string")
+          return !0;
+    return !1;
+  }
+  debug(...t) {
+  }
+  make() {
+    const t = this.pattern, e = this.options;
+    if (!e.nocomment && t.charAt(0) === "#") {
+      this.comment = !0;
+      return;
+    }
+    if (!t) {
+      this.empty = !0;
+      return;
+    }
+    this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+    const n = this.globSet.map((r) => this.slashSplit(r));
+    this.globParts = this.preprocess(n), this.debug(this.pattern, this.globParts);
+    let i = this.globParts.map((r, o, a) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const l = r[0] === "" && r[1] === "" && (r[2] === "?" || !ct.test(r[2])) && !ct.test(r[3]), h = /^[a-z]:/i.test(r[0]);
+        if (l)
+          return [...r.slice(0, 4), ...r.slice(4).map((c) => this.parse(c))];
+        if (h)
+          return [r[0], ...r.slice(1).map((c) => this.parse(c))];
+      }
+      return r.map((l) => this.parse(l));
+    });
+    if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows)
+      for (let r = 0; r < this.set.length; r++) {
+        const o = this.set[r];
+        o[0] === "" && o[1] === "" && this.globParts[r][2] === "?" && typeof o[3] == "string" && /^[a-z]:$/i.test(o[3]) && (o[2] = "?");
+      }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(t) {
+    if (this.options.noglobstar)
+      for (let n = 0; n < t.length; n++)
+        for (let i = 0; i < t[n].length; i++)
+          t[n][i] === "**" && (t[n][i] = "*");
+    const { optimizationLevel: e = 1 } = this.options;
+    return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(t) {
+    return t.map((e) => {
+      let n = -1;
+      for (; (n = e.indexOf("**", n + 1)) !== -1; ) {
+        let i = n;
+        for (; e[i + 1] === "**"; )
+          i++;
+        i !== n && e.splice(n, i - n);
+      }
+      return e;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(t) {
+    return t.map((e) => (e = e.reduce((n, i) => {
+      const r = n[n.length - 1];
+      return i === "**" && r === "**" ? n : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (n.pop(), n) : (n.push(i), n);
+    }, []), e.length === 0 ? [""] : e));
+  }
+  levelTwoFileOptimize(t) {
+    Array.isArray(t) || (t = this.slashSplit(t));
+    let e = !1;
+    do {
+      if (e = !1, !this.preserveMultipleSlashes) {
+        for (let i = 1; i < t.length - 1; i++) {
+          const r = t[i];
+          i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(i, 1), i--);
+        }
+        t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+      }
+      let n = 0;
+      for (; (n = t.indexOf("..", n + 1)) !== -1; ) {
+        const i = t[n - 1];
+        i && i !== "." && i !== ".." && i !== "**" && (e = !0, t.splice(n - 1, 2), n -= 2);
+      }
+    } while (e);
+    return t.length === 0 ? [""] : t;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(t) {
+    let e = !1;
+    do {
+      e = !1;
+      for (let n of t) {
+        let i = -1;
+        for (; (i = n.indexOf("**", i + 1)) !== -1; ) {
+          let o = i;
+          for (; n[o + 1] === "**"; )
+            o++;
+          o > i && n.splice(i + 1, o - i);
+          let a = n[i + 1];
+          const l = n[i + 2], h = n[i + 3];
+          if (a !== ".." || !l || l === "." || l === ".." || !h || h === "." || h === "..")
+            continue;
+          e = !0, n.splice(i, 1);
+          const c = n.slice(0);
+          c[i] = "**", t.push(c), i--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let o = 1; o < n.length - 1; o++) {
+            const a = n[o];
+            o === 1 && a === "" && n[0] === "" || (a === "." || a === "") && (e = !0, n.splice(o, 1), o--);
+          }
+          n[0] === "." && n.length === 2 && (n[1] === "." || n[1] === "") && (e = !0, n.pop());
+        }
+        let r = 0;
+        for (; (r = n.indexOf("..", r + 1)) !== -1; ) {
+          const o = n[r - 1];
+          if (o && o !== "." && o !== ".." && o !== "**") {
+            e = !0;
+            const l = r === 1 && n[r + 1] === "**" ? ["."] : [];
+            n.splice(r - 1, 2, ...l), n.length === 0 && n.push(""), r -= 2;
+          }
+        }
+      }
+    } while (e);
+    return t;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(t) {
+    for (let e = 0; e < t.length - 1; e++)
+      for (let n = e + 1; n < t.length; n++) {
+        const i = this.partsMatch(t[e], t[n], !this.preserveMultipleSlashes);
+        if (i) {
+          t[e] = [], t[n] = i;
+          break;
+        }
+      }
+    return t.filter((e) => e.length);
+  }
+  partsMatch(t, e, n = !1) {
+    let i = 0, r = 0, o = [], a = "";
+    for (; i < t.length && r < e.length; )
+      if (t[i] === e[r])
+        o.push(a === "b" ? e[r] : t[i]), i++, r++;
+      else if (n && t[i] === "**" && e[r] === t[i + 1])
+        o.push(t[i]), i++;
+      else if (n && e[r] === "**" && t[i] === e[r + 1])
+        o.push(e[r]), r++;
+      else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+        if (a === "b")
+          return !1;
+        a = "a", o.push(t[i]), i++, r++;
+      } else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+        if (a === "a")
+          return !1;
+        a = "b", o.push(e[r]), i++, r++;
+      } else
+        return !1;
+    return t.length === e.length && o;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const t = this.pattern;
+    let e = !1, n = 0;
+    for (let i = 0; i < t.length && t.charAt(i) === "!"; i++)
+      e = !e, n++;
+    n && (this.pattern = t.slice(n)), this.negate = e;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  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]), x = S ? 3 : p ? 0 : void 0, w = N ? 3 : v ? 0 : void 0;
+      if (typeof x == "number" && typeof w == "number") {
+        const [F, P] = [t[x], e[w]];
+        F.toLowerCase() === P.toLowerCase() && (e[w] = F, w > x ? e = e.slice(w) : x > w && (t = t.slice(x)));
+      }
+    }
+    const { optimizationLevel: r = 1 } = this.options;
+    r >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, { file: t, pattern: e }), this.debug("matchOne", t.length, e.length);
+    for (var o = 0, a = 0, l = t.length, h = e.length; o < l && a < h; o++, a++) {
+      this.debug("matchOne loop");
+      var c = e[a], f = t[o];
+      if (this.debug(e, c, f), c === !1)
+        return !1;
+      if (c === A) {
+        this.debug("GLOBSTAR", [e, c, f]);
+        var u = o, d = a + 1;
+        if (d === h) {
+          for (this.debug("** at the end"); o < l; o++)
+            if (t[o] === "." || t[o] === ".." || !i.dot && t[o].charAt(0) === ".")
+              return !1;
+          return !0;
+        }
+        for (; u < l; ) {
+          var m = t[u];
+          if (this.debug(\`
+globstar while\`, t, u, e, d, m), this.matchOne(t.slice(u), e.slice(d), n))
+            return this.debug("globstar found match!", u, l, m), !0;
+          if (m === "." || m === ".." || !i.dot && m.charAt(0) === ".") {
+            this.debug("dot detected!", t, u, e, d);
+            break;
+          }
+          this.debug("globstar swallow a segment, and continue"), u++;
+        }
+        return !!(n && (this.debug(\`
+>>> no match, partial?\`, t, u, e, d), u === l));
+      }
+      let p;
+      if (typeof c == "string" ? (p = f === c, this.debug("string match", c, f, p)) : (p = c.test(f), this.debug("pattern match", c, f, p)), !p)
+        return !1;
+    }
+    if (o === l && a === h)
+      return !0;
+    if (o === l)
+      return n;
+    if (a === h)
+      return o === l - 1 && t[o] === "";
+    throw new Error("wtf?");
+  }
+  braceExpand() {
+    return Ct(this.pattern, this.options);
+  }
+  parse(t) {
+    W(t);
+    const e = this.options;
+    if (t === "**")
+      return A;
+    if (t === "")
+      return "";
+    let n, i = null;
+    (n = t.match($e)) ? i = e.dot ? Re : Pe : (n = t.match(be)) ? i = (e.nocase ? e.dot ? De : Ce : e.dot ? ve : Ae)(n[1]) : (n = t.match(ke)) ? i = (e.nocase ? e.dot ? Ie : Le : e.dot ? ze : He)(n) : (n = t.match(Oe)) ? i = e.dot ? Fe : Ne : (n = t.match(Te)) && (i = Me);
+    const r = E.fromGlob(t, this.options).toMMPattern();
+    return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === !1)
+      return this.regexp;
+    const t = this.set;
+    if (!t.length)
+      return this.regexp = !1, this.regexp;
+    const e = this.options, n = e.noglobstar ? Ue : e.dot ? _e : Be, i = new Set(e.nocase ? ["i"] : []);
+    let r = t.map((l) => {
+      const h = l.map((c) => {
+        if (c instanceof RegExp)
+          for (const f of c.flags.split(""))
+            i.add(f);
+        return typeof c == "string" ? Xe(c) : c === A ? A : 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("/");
+    }).join("|");
+    const [o, a] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+    r = "^" + o + r + a + "$", this.negate && (r = "^(?!" + r + ").+$");
+    try {
+      this.regexp = new RegExp(r, [...i].join(""));
+    } catch {
+      this.regexp = !1;
+    }
+    return this.regexp;
+  }
+  slashSplit(t) {
+    return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\\/\\/[^\\/]+/.test(t) ? ["", ...t.split(/\\/+/)] : t.split(/\\/+/);
+  }
+  match(t, e = this.partial) {
+    if (this.debug("match", t, this.pattern), this.comment)
+      return !1;
+    if (this.empty)
+      return t === "";
+    if (t === "/" && e)
+      return !0;
+    const n = this.options;
+    this.isWindows && (t = t.split("\\\\").join("/"));
+    const i = this.slashSplit(t);
+    this.debug(this.pattern, "split", i);
+    const r = this.set;
+    this.debug(this.pattern, "set", r);
+    let o = i[i.length - 1];
+    if (!o)
+      for (let a = i.length - 2; !o && a >= 0; a--)
+        o = i[a];
+    for (let a = 0; a < r.length; a++) {
+      const l = r[a];
+      let h = i;
+      if (n.matchBase && l.length === 1 && (h = [o]), this.matchOne(h, l, e))
+        return n.flipNegate ? !0 : !this.negate;
+    }
+    return n.flipNegate ? !1 : this.negate;
+  }
+  static defaults(t) {
+    return y.defaults(t).Minimatch;
+  }
+}
+y.AST = E;
+y.Minimatch = j;
+y.escape = xe;
+y.unescape = $;
+function Ye() {
   if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
-    throw new tt();
+    throw new Ht();
+}
+async function Q(s, t, e) {
+  return typeof navigator < "u" && navigator.locks?.request ? navigator.locks.request(\`opfs:\${s.replace(/\\/+/g, "/").toLowerCase()}\`, { mode: t }, e) : e();
 }
-function m(e) {
-  return Array.isArray(e) ? e : (e.startsWith("~/") ? e.slice(2) : e).split("/").filter(Boolean);
+function O(s) {
+  return Array.isArray(s) ? s : (s.startsWith("~/") ? s.slice(2) : s).split("/").filter(Boolean);
 }
-function I(e) {
-  return typeof e == "string" ? e ?? "/" : \`/\${e.join("/")}\`;
+function tt(s) {
+  return typeof s == "string" ? s ?? "/" : \`/\${s.join("/")}\`;
 }
-function O(e) {
-  const t = m(e);
+function Z(s) {
+  const t = O(s);
   return t[t.length - 1] || "";
 }
-function P(e) {
-  const t = m(e);
-  return t.pop(), I(t);
+function G(s) {
+  const t = O(s);
+  return t.pop(), tt(t);
+}
+function X(s) {
+  return !s || s === "/" ? "/" : s.startsWith("~/") ? \`/\${s.slice(2)}\` : s.startsWith("/") ? s : \`/\${s}\`;
 }
-function F(e) {
-  return !e || e === "/" ? "/" : e.startsWith("~/") ? \`/\${e.slice(2)}\` : e.startsWith("/") ? e : \`/\${e}\`;
+function Je(s, t = !1) {
+  return s = s.replace(/\\/$/, ""), t && !s.includes("*") ? \`\${s}/**\` : s;
 }
-function ct(e) {
-  const t = F(e), r = m(t), i = [];
-  for (const n of r)
-    if (!(n === "." || n === ""))
-      if (n === "..") {
-        if (i.length === 0)
+function q(s, t) {
+  return y(s, t, {
+    dot: !0,
+    matchBase: !0
+  });
+}
+function Ke(s) {
+  const t = X(s), e = O(t), n = [];
+  for (const i of e)
+    if (!(i === "." || i === ""))
+      if (i === "..") {
+        if (n.length === 0)
           continue;
-        i.pop();
+        n.pop();
       } else
-        i.push(n);
-  return I(i);
+        n.push(i);
+  return tt(n);
 }
-function lt(e, t = "utf-8") {
-  return typeof e == "string" ? et(e, t) : e instanceof Uint8Array ? e : new Uint8Array(e);
+function Qe(s, t = "utf-8") {
+  return typeof s == "string" ? jt(s, t) : s instanceof Uint8Array ? s : new Uint8Array(s);
 }
-async function ht(e) {
-  const t = await e.createSyncAccessHandle();
-  try {
-    const r = t.getSize(), i = new Uint8Array(r);
-    return t.read(i, { at: 0 }), i;
-  } finally {
-    t.close();
-  }
+async function ts(s, t) {
+  return Q(t, "shared", async () => {
+    const n = await (await s.getFile()).arrayBuffer();
+    return new Uint8Array(n);
+  });
 }
-async function k(e, t, r, i = {}) {
-  let n = null;
-  try {
-    n = await e.createSyncAccessHandle();
-    const a = lt(t, r), s = i.append ? n.getSize() : 0;
-    n.write(a, { at: s }), i.truncate && !i.append && n.truncate(a.byteLength), n.flush();
-  } catch (a) {
-    console.error(a);
-    const s = i.append ? "append" : "write";
-    throw new c(\`Failed to \${s} file\`, \`\${s.toUpperCase()}_FAILED\`);
-  } finally {
-    if (n)
+async function lt(s, t, e, n = {}, i) {
+  const r = async () => {
+    let o = null;
+    const a = n.append || !1, l = !a && (n.truncate ?? !0);
+    try {
+      o = await s.createSyncAccessHandle();
+      const h = Qe(t, e), c = a ? o.getSize() : 0;
+      o.write(h, { at: c }), l && o.truncate(h.byteLength), o.flush();
+    } catch (h) {
+      console.error(h);
+      const c = a ? "append" : "write";
+      throw new g(\`Failed to \${c} file\`, \`\${c.toUpperCase()}_FAILED\`, void 0, h);
+    } finally {
       try {
-        n.close();
+        o?.close();
       } catch {
       }
-  }
+    }
+  };
+  return i ? Q(i, "exclusive", r) : r();
 }
-async function ut(e, t = "SHA-1", r = 50 * 1024 * 1024) {
-  if (e instanceof File && (e = await e.arrayBuffer()), e.byteLength > r)
-    throw new Error(\`File size \${e.byteLength} bytes exceeds maximum allowed size \${r} bytes\`);
-  const i = new Uint8Array(e), n = await crypto.subtle.digest(t, i);
-  return Array.from(new Uint8Array(n)).map((s) => s.toString(16).padStart(2, "0")).join("");
+async function es(s, t = "SHA-1", e = 50 * 1024 * 1024) {
+  if (s instanceof File && (s = await s.arrayBuffer()), s.byteLength > e)
+    throw new Error(\`File size \${s.byteLength} bytes exceeds maximum allowed size \${e} bytes\`);
+  const n = new Uint8Array(s), i = await crypto.subtle.digest(t, n);
+  return Array.from(new Uint8Array(i)).map((o) => o.toString(16).padStart(2, "0")).join("");
 }
-async function ft(e) {
-  const t = await e.arrayBuffer();
+async function ss(s) {
+  const t = await s.arrayBuffer();
   return new Uint8Array(t);
 }
-class wt {
+async function ns(s, t, e = {}) {
+  const n = Z(t);
+  return Q(t, "exclusive", async () => {
+    const i = e.recursive ?? !1, r = e.force ?? !1;
+    try {
+      await s.removeEntry(n, { recursive: i });
+    } catch (o) {
+      if (o.name === "NotFoundError") {
+        if (!r)
+          throw new g(\`No such file or directory: \${t}\`, "ENOENT", void 0, o);
+      } else throw o.name === "InvalidModificationError" ? new g(\`Directory not empty: \${t}. Use recursive option to force removal.\`, "ENOTEMPTY", void 0, o) : o.name === "TypeMismatchError" && !i ? new g(\`Cannot remove directory without recursive option: \${t}\`, "EISDIR", void 0, o) : new g(\`Failed to remove entry: \${t}\`, "RM_FAILED", void 0, o);
+    }
+  });
+}
+class is {
   /** Root directory handle for the file system */
   root = null;
-  /** Map of watched paths to their last known state */
+  /** Map of watched paths and options */
   watchers = /* @__PURE__ */ new Map();
-  /** Interval handle for polling watched paths */
-  watchTimer = null;
-  /** Flag to avoid concurrent scans */
-  scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
   /** BroadcastChannel instance for sending events */
   broadcastChannel = null;
   /** Configuration options */
   options = {
-    watchInterval: 1e3,
+    root: "/",
+    namespace: "",
     maxFileSize: 50 * 1024 * 1024,
     hashAlgorithm: null,
     broadcastChannel: "opfs-worker"
@@ -450,38 +1424,40 @@ class wt {
   async notifyChange(t) {
     if (!this.options.broadcastChannel)
       return;
-    let r;
-    if (this.options.hashAlgorithm && !t.isDirectory && t.type !== "removed")
+    const e = t.path;
+    if (![...this.watchers.values()].some((r) => q(e, r.pattern) && r.include.some((o) => o && q(e, o)) && !r.exclude.some((o) => o && q(e, o))))
+      return;
+    let i;
+    if (this.options.hashAlgorithm)
       try {
-        const i = await this.stat(t.path);
-        i.isFile && i.hash && (r = i.hash);
-      } catch (i) {
-        console.warn(\`Failed to calculate hash for \${t.path}:\`, i);
+        i = (await this.stat(e)).hash;
+      } catch {
       }
     try {
       this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
-      const i = {
-        root: this.root.name,
+      const r = {
+        namespace: this.options.namespace,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         ...t,
-        ...r && { hash: r }
+        ...i && { hash: i }
       };
-      this.broadcastChannel.postMessage(i);
-    } catch (i) {
-      console.warn("Failed to send event via BroadcastChannel:", i);
+      this.broadcastChannel.postMessage(r);
+    } catch (r) {
+      console.warn("Failed to send event via BroadcastChannel:", r);
     }
   }
   /**
    * Creates a new OPFSFileSystem instance
    * 
    * @param options - Optional configuration options
+   * @param options.root - Root path for the file system (default: '/')
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t) {
-    ot(), t && this.setOptions(t), this.mount("/");
+    Ye(), t && this.setOptions(t);
   }
   /**
    * Initialize the file system within a given directory
@@ -504,14 +1480,13 @@ class wt {
    * await fs.mount('/my-app');
    * \`\`\`
    */
-  async mount(t = "/") {
-    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (r, i) => {
-      this.root = null;
+  async mount(t = this.options.root) {
+    return this.mountingPromise && await this.mountingPromise, t = X(t), this.mountingPromise = new Promise(async (e, n) => {
       try {
-        const n = await navigator.storage.getDirectory();
-        t === "/" ? this.root = n : this.root = await this.getDirectoryHandle(t, !0, n), r(!0);
-      } catch (n) {
-        console.error(n), i(new c("Failed to initialize OPFS", "INIT_FAILED"));
+        const i = await navigator.storage.getDirectory();
+        t === "/" ? this.root = i : this.root = await this.getDirectoryHandle(t, !0, i), e(!0);
+      } catch {
+        n(new g("Failed to initialize OPFS", "INIT_FAILED"));
       } finally {
         this.mountingPromise = null;
       }
@@ -521,31 +1496,14 @@ class wt {
    * Update configuration options
    * 
    * @param options - Configuration options to update
+   * @param options.root - Root path for the file system
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes
    * @param options.broadcastChannel - Custom name for the broadcast channel
    */
-  setOptions(t) {
-    t.watchInterval !== void 0 && (this.options.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel);
-  }
-  /**
-   * Automatically mount the OPFS root if not already mounted
-   * 
-   * This method is called internally when file operations are performed
-   * without explicitly mounting first.
-   * 
-   * @returns Promise that resolves when auto-mount is complete
-   * @throws {OPFSError} If auto-mount fails
-   */
-  async ensureMounted() {
-    if (!this.root) {
-      if (this.mountingPromise) {
-        await this.mountingPromise;
-        return;
-      }
-      throw new c("OPFS not mounted", "NOT_MOUNTED");
-    }
+  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));
   }
   /**
    * Get a directory handle from a path
@@ -565,14 +1523,12 @@ class wt {
    * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
    * \`\`\`
    */
-  async getDirectoryHandle(t, r = !1, i = this.root) {
-    if (!i)
-      throw new b();
-    const n = Array.isArray(t) ? t : m(t);
-    let a = i;
-    for (const s of n)
-      a = await a.getDirectoryHandle(s, { create: r });
-    return a;
+  async getDirectoryHandle(t, e = !1, n = this.root) {
+    const i = Array.isArray(t) ? t : O(t);
+    let r = n;
+    for (const o of i)
+      r = await r.getDirectoryHandle(o, { create: e });
+    return r;
   }
   /**
    * Get a file handle from a path
@@ -593,14 +1549,12 @@ class wt {
    * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
    * \`\`\`
    */
-  async getFileHandle(t, r = !1, i = this.root) {
-    if (!i)
-      throw new b();
-    const n = m(t);
-    if (n.length === 0)
-      throw new N("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
-    const a = n.pop();
-    return (await this.getDirectoryHandle(n, r, i)).getFileHandle(a, { create: r });
+  async getFileHandle(t, e = !1, n = this.root) {
+    const i = O(t);
+    if (i.length === 0)
+      throw new Wt("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+    const r = i.pop();
+    return (await this.getDirectoryHandle(i, e, n)).getFileHandle(r, { create: e });
   }
   /**
    * Get a complete index of all files and directories in the file system
@@ -622,15 +1576,15 @@ class wt {
    * \`\`\`
    */
   async index() {
-    const t = /* @__PURE__ */ new Map(), r = async (i) => {
-      const n = await this.readDir(i);
-      for (const a of n) {
-        const s = \`\${i === "/" ? "" : i}/\${a.name}\`;
+    const t = /* @__PURE__ */ new Map(), e = async (n) => {
+      const i = await this.readDir(n);
+      for (const r of i) {
+        const o = \`\${n === "/" ? "" : n}/\${r.name}\`;
         try {
-          const o = await this.stat(s);
-          t.set(s, o), o.isDirectory && await r(s);
-        } catch (o) {
-          console.warn(\`Skipping broken entry: \${s}\`, o);
+          const a = await this.stat(o);
+          t.set(o, a), a.isDirectory && await e(o);
+        } catch (a) {
+          console.warn(\`Skipping broken entry: \${o}\`, a);
         }
       }
     };
@@ -641,15 +1595,15 @@ class wt {
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await r("/"), t;
+    }), await e("/"), t;
   }
-  async readFile(t, r = "utf-8") {
-    await this.ensureMounted();
+  async readFile(t, e = "utf-8") {
+    await this.mount();
     try {
-      const i = await this.getFileHandle(t, !1), n = await ht(i);
-      return r === "binary" ? n : rt(n, r);
-    } catch (i) {
-      throw console.error(i), new T(t);
+      const n = await this.getFileHandle(t, !1), i = await ts(n, t);
+      return e === "binary" ? i : Ut(i, e);
+    } catch (n) {
+      throw new _(t, n);
     }
   }
   /**
@@ -677,10 +1631,10 @@ class wt {
    * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
    * \`\`\`
    */
-  async writeFile(t, r, i) {
-    await this.ensureMounted();
-    const n = await this.getFileHandle(t, !0);
-    await k(n, r, i, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+  async writeFile(t, e, n) {
+    await this.mount();
+    const i = await this.exists(t), r = await this.getFileHandle(t, !0);
+    await lt(r, e, n, {}, t), i ? await this.notifyChange({ path: t, type: "changed", isDirectory: !1 }) : await this.notifyChange({ path: t, type: "added", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -704,10 +1658,10 @@ class wt {
    * await fs.appendFile('/data/binary.dat', additionalData);
    * \`\`\`
    */
-  async appendFile(t, r, i) {
-    await this.ensureMounted();
-    const n = await this.getFileHandle(t, !0);
-    await k(n, r, i, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+  async appendFile(t, e, n) {
+    await this.mount();
+    const i = await this.getFileHandle(t, !0);
+    await lt(i, e, n, { append: !0 }, t), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -730,20 +1684,21 @@ class wt {
    * await fs.mkdir('/users/john/documents/projects', { recursive: true });
    * \`\`\`
    */
-  async mkdir(t, r) {
-    if (await this.ensureMounted(), !this.root)
-      throw new b();
-    const i = r?.recursive ?? !1, n = m(t);
-    let a = this.root;
-    for (let s = 0; s < n.length; s++) {
-      const o = n[s];
+  async mkdir(t, e) {
+    await this.mount();
+    const n = e?.recursive ?? !1, i = O(t);
+    let r = this.root;
+    for (let o = 0; o < i.length; o++) {
+      const a = i[o];
       try {
-        a = await a.getDirectoryHandle(o, { create: i || s === n.length - 1 });
+        r = await r.getDirectoryHandle(a, { create: n || o === i.length - 1 });
       } catch (l) {
-        throw l.name === "NotFoundError" ? new c(
-          \`Parent directory does not exist: \${I(n.slice(0, s + 1))}\`,
-          "ENOENT"
-        ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${o}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
+        throw l.name === "NotFoundError" ? new g(
+          \`Parent directory does not exist: \${tt(i.slice(0, o + 1))}\`,
+          "ENOENT",
+          void 0,
+          l
+        ) : l.name === "TypeMismatchError" ? new g(\`Path segment is not a directory: \${a}\`, "ENOTDIR", void 0, l) : new g("Failed to create directory", "MKDIR_FAILED", void 0, l);
       }
     }
     await this.notifyChange({ path: t, type: "added", isDirectory: !0 });
@@ -771,7 +1726,7 @@ class wt {
    * \`\`\`
    */
   async stat(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return {
         kind: "directory",
         size: 0,
@@ -780,30 +1735,30 @@ class wt {
         isFile: !1,
         isDirectory: !0
       };
-    const r = O(t), i = await this.getDirectoryHandle(P(t), !1), n = this.options.hashAlgorithm !== null;
+    const e = Z(t), n = await this.getDirectoryHandle(G(t), !1), i = this.options.hashAlgorithm !== null;
     try {
-      const s = await (await i.getFileHandle(r, { create: !1 })).getFile(), o = {
+      const o = await (await n.getFileHandle(e, { create: !1 })).getFile(), a = {
         kind: "file",
-        size: s.size,
-        mtime: new Date(s.lastModified).toISOString(),
-        ctime: new Date(s.lastModified).toISOString(),
+        size: o.size,
+        mtime: new Date(o.lastModified).toISOString(),
+        ctime: new Date(o.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (n && this.options.hashAlgorithm)
+      if (i && this.options.hashAlgorithm)
         try {
-          const l = await ut(s, this.options.hashAlgorithm, this.options.maxFileSize);
-          o.hash = l;
+          const l = await es(o, this.options.hashAlgorithm, this.options.maxFileSize);
+          a.hash = l;
         } catch (l) {
           console.warn(\`Failed to calculate hash for \${t}:\`, l);
         }
-      return o;
-    } catch (a) {
-      if (a.name !== "TypeMismatchError" && a.name !== "NotFoundError")
-        throw new c("Failed to stat (file)", "STAT_FAILED");
+      return a;
+    } catch (r) {
+      if (r.name !== "TypeMismatchError" && r.name !== "NotFoundError")
+        throw new g("Failed to stat (file)", "STAT_FAILED", void 0, r);
     }
     try {
-      return await i.getDirectoryHandle(r, { create: !1 }), {
+      return await n.getDirectoryHandle(e, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
@@ -811,8 +1766,8 @@ class wt {
         isFile: !1,
         isDirectory: !0
       };
-    } catch (a) {
-      throw a.name === "NotFoundError" ? new c(\`No such file or directory: \${t}\`, "ENOENT") : new c("Failed to stat (directory)", "STAT_FAILED");
+    } catch (r) {
+      throw r.name === "NotFoundError" ? new g(\`No such file or directory: \${t}\`, "ENOENT", void 0, r) : new g("Failed to stat (directory)", "STAT_FAILED", void 0, r);
     }
   }
   /**
@@ -834,18 +1789,18 @@ class wt {
    * \`\`\`
    */
   async readDir(t) {
-    await this.ensureMounted();
-    const r = await this.getDirectoryHandle(t, !1), i = [];
-    for await (const [n, a] of r.entries()) {
-      const s = a.kind === "file";
-      i.push({
-        name: n,
-        kind: a.kind,
-        isFile: s,
-        isDirectory: !s
+    await this.mount();
+    const e = await this.getDirectoryHandle(t, !1), n = [];
+    for await (const [i, r] of e.entries()) {
+      const o = r.kind === "file";
+      n.push({
+        name: i,
+        kind: r.kind,
+        isFile: o,
+        isDirectory: !o
       });
     }
-    return i;
+    return n;
   }
   /**
    * Check if a file or directory exists
@@ -862,30 +1817,30 @@ class wt {
    * \`\`\`
    */
   async exists(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return !0;
-    const r = O(t);
-    let i = null;
+    const e = Z(t);
+    let n = null;
     try {
-      i = await this.getDirectoryHandle(P(t), !1);
-    } catch (n) {
-      throw (n.name === "NotFoundError" || n.name === "TypeMismatchError") && (i = null), n;
+      n = await this.getDirectoryHandle(G(t), !1);
+    } catch (i) {
+      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
     }
-    if (!i || !r)
+    if (!n || !e)
       return !1;
     try {
-      return await i.getFileHandle(r, { create: !1 }), !0;
-    } catch (n) {
-      if (n.name !== "NotFoundError" && n.name !== "TypeMismatchError")
-        throw n;
-    }
-    try {
-      return await i.getDirectoryHandle(r, { create: !1 }), !0;
-    } catch (n) {
-      if (n.name !== "NotFoundError" && n.name !== "TypeMismatchError")
-        throw n;
+      return await n.getFileHandle(e, { create: !1 }), !0;
+    } catch (i) {
+      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+        throw i;
+      try {
+        return await n.getDirectoryHandle(e, { create: !1 }), !0;
+      } catch (r) {
+        if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+          throw r;
+        return !1;
+      }
     }
-    return !1;
   }
   /**
    * Clear all contents of a directory without removing the directory itself
@@ -907,16 +1862,16 @@ class wt {
    * \`\`\`
    */
   async clear(t = "/") {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const r = await this.readDir(t);
-      for (const i of r) {
-        const n = \`\${t === "/" ? "" : t}/\${i.name}\`;
-        await this.remove(n, { recursive: !0 });
+      const e = await this.readDir(t);
+      for (const n of e) {
+        const i = \`\${t === "/" ? "" : t}/\${n.name}\`;
+        await this.remove(i, { recursive: !0 });
       }
       await this.notifyChange({ path: t, type: "changed", isDirectory: !0 });
-    } catch (r) {
-      throw r instanceof c ? r : new c(\`Failed to clear directory: \${t}\`, "CLEAR_FAILED");
+    } catch (e) {
+      throw e instanceof g ? e : new g(\`Failed to clear directory: \${t}\`, "CLEAR_FAILED", void 0, e);
     }
   }
   /**
@@ -943,24 +1898,11 @@ class wt {
    * await fs.rm('/maybe/exists', { force: true });
    * \`\`\`
    */
-  async remove(t, r) {
-    await this.ensureMounted();
-    const i = r?.recursive ?? !1, n = r?.force ?? !1;
-    if (t === "/")
-      throw new c("Cannot remove root directory", "EROOT");
-    const a = O(t);
-    if (!a)
-      throw new N("Invalid path", t);
-    const s = await this.getDirectoryHandle(P(t), !1);
-    try {
-      await s.removeEntry(a, { recursive: i });
-    } catch (o) {
-      if (o.name === "NotFoundError") {
-        if (!n)
-          throw new c(\`No such file or directory: \${t}\`, "ENOENT");
-      } else throw o.name === "InvalidModificationError" ? new c(\`Directory not empty: \${t}. Use recursive option to force removal.\`, "ENOTEMPTY") : o.name === "TypeMismatchError" && !i ? new c(\`Cannot remove directory without recursive option: \${t}\`, "EISDIR") : new c(\`Failed to remove path: \${t}\`, "RM_FAILED");
-    }
-    await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
+  async remove(t, e) {
+    if (await this.mount(), t === "/")
+      throw new g("Cannot remove root directory", "EROOT");
+    const n = await this.getDirectoryHandle(G(t), !1);
+    await ns(n, t, e), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
   }
   /**
    * Resolve a path to an absolute path
@@ -981,14 +1923,14 @@ class wt {
    * \`\`\`
    */
   async realpath(t) {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const r = ct(t);
-      if (!await this.exists(r))
-        throw new T(r);
-      return r;
-    } catch (r) {
-      throw r instanceof c ? r : new c(\`Failed to resolve path: \${t}\`, "REALPATH_FAILED");
+      const e = Ke(t);
+      if (!await this.exists(e))
+        throw new _(e);
+      return e;
+    } catch (e) {
+      throw e instanceof g ? e : new g(\`Failed to resolve path: \${t}\`, "REALPATH_FAILED", void 0, e);
     }
   }
   /**
@@ -1007,14 +1949,14 @@ class wt {
    * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
    * \`\`\`
    */
-  async rename(t, r) {
-    await this.ensureMounted();
+  async rename(t, e) {
+    await this.mount();
     try {
       if (!await this.exists(t))
-        throw new T(t);
-      await this.copy(t, r, { recursive: !0 }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: r, type: "added", isDirectory: !1 });
-    } catch (i) {
-      throw i instanceof c ? i : new c(\`Failed to rename from \${t} to \${r}\`, "RENAME_FAILED");
+        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);
     }
   }
   /**
@@ -1042,48 +1984,71 @@ class wt {
    * await fs.copy('/source', '/dest', { recursive: true, force: false });
    * \`\`\`
    */
-  async copy(t, r, i) {
-    await this.ensureMounted();
+  async copy(t, e, n) {
+    await this.mount();
     try {
-      const n = i?.recursive ?? !1, a = i?.force ?? !0;
+      const i = n?.recursive ?? !1, r = n?.force ?? !0;
       if (!await this.exists(t))
-        throw new c(\`Source does not exist: \${t}\`, "ENOENT");
-      if (await this.exists(r) && !a)
-        throw new c(\`Destination already exists: \${r}\`, "EEXIST");
+        throw new g(\`Source does not exist: \${t}\`, "ENOENT", void 0);
+      if (await this.exists(e) && !r)
+        throw new g(\`Destination already exists: \${e}\`, "EEXIST", void 0);
       if ((await this.stat(t)).isFile) {
         const h = await this.readFile(t, "binary");
-        await this.writeFile(r, h);
+        await this.writeFile(e, h);
       } else {
-        if (!n)
-          throw new c(\`Cannot copy directory without recursive option: \${t}\`, "EISDIR");
-        await this.mkdir(r, { recursive: !0 });
+        if (!i)
+          throw new g(\`Cannot copy directory without recursive option: \${t}\`, "EISDIR", void 0);
+        await this.mkdir(e, { recursive: !0 });
         const h = await this.readDir(t);
-        for (const u of h) {
-          const w = \`\${t}/\${u.name}\`, f = \`\${r}/\${u.name}\`;
-          await this.copy(w, f, { recursive: !0, force: a });
+        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.notifyChange({ path: r, type: "added", isDirectory: !1 });
-    } catch (n) {
-      throw n instanceof c ? n : new c(\`Failed to copy from \${t} to \${r}\`, "CP_FAILED");
+    } catch (i) {
+      throw i instanceof g ? i : new g(\`Failed to copy from \${t} to \${e}\`, "CP_FAILED", void 0, i);
     }
   }
   /**
    * Start watching a file or directory for changes
+   * 
+   * @param path - The path to watch (minimatch syntax allowed)
+   * @param options - Watch options
+   * @param options.recursive - Whether to watch recursively (default: true)
+   * @param options.exclude - Glob pattern(s) to exclude (minimatch).
+   * @returns Promise that resolves when watching starts
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Watch entire directory tree recursively (default)
+   * await fs.watch('/data');
+   * 
+   * // Watch only immediate children (shallow)
+   * await fs.watch('/data', { recursive: false });
+   * 
+   * // Watch a single file
+   * await fs.watch('/config.json', { recursive: false });
+   * 
+   * // Watch all json files but not in dist directory
+   * await fs.watch('/**\\/*.json', { recursive: false, exclude: ['dist/**'] });
+   *
+   * \`\`\`
    */
-  async watch(t) {
-    await this.ensureMounted();
-    const r = F(t), i = await this.buildSnapshot(r);
-    this.watchers.set(r, i), this.watchTimer || (this.watchTimer = setInterval(() => {
-      this.scanWatches();
-    }, this.options.watchInterval));
+  async watch(t, e) {
+    if (!this.options.broadcastChannel)
+      throw new g("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.", "ENOENT");
+    const n = {
+      pattern: Je(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, n);
   }
   /**
    * Stop watching a previously watched path
    */
   unwatch(t) {
-    const r = F(t);
-    this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+    this.watchers.delete(t);
   }
   /**
    * Dispose of resources and clean up the file system instance
@@ -1092,49 +2057,7 @@ class wt {
    * to properly clean up resources like the broadcast channel and watch timers.
    */
   dispose() {
-    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null), this.watchers.clear();
-  }
-  async buildSnapshot(t) {
-    const r = /* @__PURE__ */ new Map(), i = async (n) => {
-      const a = await this.stat(n);
-      if (r.set(n, a), a.isDirectory) {
-        const s = await this.readDir(n);
-        for (const o of s) {
-          const l = \`\${n === "/" ? "" : n}/\${o.name}\`;
-          await i(l);
-        }
-      }
-    };
-    return await i(t), r;
-  }
-  async scanWatches() {
-    if (!this.scanning) {
-      this.scanning = !0;
-      try {
-        await Promise.all(
-          [...this.watchers.entries()].map(async ([t, r]) => {
-            let i;
-            try {
-              i = await this.buildSnapshot(t);
-            } catch {
-              i = /* @__PURE__ */ new Map();
-            }
-            for (const [n, a] of i) {
-              const s = r.get(n);
-              s ? (s.mtime !== a.mtime || s.size !== a.size) && await this.notifyChange({ path: n, type: "changed", isDirectory: a.isDirectory }) : await this.notifyChange({ path: n, type: "added", isDirectory: a.isDirectory });
-            }
-            for (const n of r.keys())
-              if (!i.has(n)) {
-                const a = r.get(n);
-                await this.notifyChange({ path: n, type: "removed", isDirectory: a?.isDirectory ?? !1 });
-              }
-            this.watchers.set(t, i);
-          })
-        );
-      } finally {
-        this.scanning = !1;
-      }
-    }
+    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchers.clear();
   }
   /**
    * Synchronize the file system with external data
@@ -1164,74 +2087,79 @@ class wt {
    * await fs.sync(entries, { cleanBefore: true });
    * \`\`\`
    */
-  async sync(t, r) {
-    await this.ensureMounted();
+  async sync(t, e) {
+    await this.mount();
     try {
-      (r?.cleanBefore ?? !1) && await this.clear("/");
-      for (const [n, a] of t) {
-        const s = F(n);
-        let o;
-        a instanceof Blob ? o = await ft(a) : o = a, await this.writeFile(s, o);
+      (e?.cleanBefore ?? !1) && await this.clear("/");
+      for (const [i, r] of t) {
+        const o = X(i);
+        let a;
+        r instanceof Blob ? a = await ss(r) : a = r, await this.writeFile(o, a);
       }
-      await this.notifyChange({ path: "/", type: "changed", isDirectory: !0 });
-    } catch (i) {
-      throw i instanceof c ? i : new c("Failed to sync file system", "SYNC_FAILED");
+    } catch (n) {
+      throw n instanceof g ? n : new g("Failed to sync file system", "SYNC_FAILED", void 0, n);
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && x(new wt());
-//# sourceMappingURL=worker-CLK22qZk.js.map
-`, r = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", a], { type: "text/javascript;charset=utf-8" });
-function o(t) {
-  let n;
+typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && Y(new is());
+//# sourceMappingURL=worker-3SMz_DAt.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;
   try {
-    if (n = r && (self.URL || self.webkitURL).createObjectURL(r), !n) throw "";
-    const e = new Worker(n, {
+    if (t = s && (self.URL || self.webkitURL).createObjectURL(s), !t) throw "";
+    const e = new Worker(t, {
       type: "module",
-      name: t?.name
+      name: n?.name
     });
     return e.addEventListener("error", () => {
-      (self.URL || self.webkitURL).revokeObjectURL(n);
+      (self.URL || self.webkitURL).revokeObjectURL(t);
     }), e;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(a),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(r),
       {
         type: "module",
-        name: t?.name
+        name: n?.name
       }
     );
   }
 }
-function c(t) {
-  const n = i(new o());
-  return t && n.setOptions(t), n;
+async function h(n) {
+  const t = i(new o());
+  return n && (n.broadcastChannel && n.broadcastChannel instanceof BroadcastChannel && (n.broadcastChannel = n.broadcastChannel.name), await t.setOptions(n)), t;
 }
 export {
-  d as DirectoryNotFoundError,
+  p as DirectoryNotFoundError,
   f as FileNotFoundError,
-  p as OPFSError,
+  d as OPFSError,
   u as OPFSNotMountedError,
-  y as OPFSNotSupportedError,
+  g as OPFSNotSupportedError,
   m as PathError,
   w as PermissionError,
-  g as StorageError,
-  v as TimeoutError,
-  b as basename,
-  E as calculateFileHash,
-  S as checkOPFSSupport,
-  F as convertBlobToUint8Array,
-  P as createBuffer,
-  c as createWorker,
-  x as decodeBuffer,
-  D as dirname,
+  y as StorageError,
+  b as TimeoutError,
+  v as basename,
+  S as buffersEqual,
+  x as calculateFileHash,
+  E as checkOPFSSupport,
+  P as convertBlobToUint8Array,
+  A as createBuffer,
+  h as createWorker,
+  F as decodeBuffer,
+  O as dirname,
   C as encodeString,
   T as extname,
-  A as joinPath,
-  O as normalizePath,
-  _ as readFileData,
-  I as resolvePath,
-  U as splitPath,
-  R as writeFileData
+  R as isPathExcluded,
+  $ as joinPath,
+  _ as matchMinimatch,
+  D as normalizeMinimatch,
+  I as normalizePath,
+  M as readFileData,
+  j as removeEntry,
+  N as resolvePath,
+  k as splitPath,
+  L as withLock,
+  U as writeFileData
 };
 //# sourceMappingURL=index.js.map