opfs-worker 2.0.0 → 2.1.1

package/dist/shared.worker.js

@@ -0,0 +1,2240 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const St = Symbol("Comlink.proxy"), zt = Symbol("Comlink.endpoint"), Lt = Symbol("Comlink.releaseProxy"), Y = Symbol("Comlink.finalizer"), H = Symbol("Comlink.thrown"), bt = (s) => typeof s == "object" && s !== null || typeof s == "function", _t = {
+  canHandle: (s) => bt(s) && s[St],
+  serialize(s) {
+    const { port1: t, port2: e } = new MessageChannel();
+    return rt(s, t), [e, [e]];
+  },
+  deserialize(s) {
+    return s.start(), Bt(s);
+  }
+}, Wt = {
+  canHandle: (s) => bt(s) && H in s,
+  serialize({ value: s }) {
+    let t;
+    return s instanceof Error ? t = {
+      isError: !0,
+      value: {
+        message: s.message,
+        name: s.name,
+        stack: s.stack
+      }
+    } : t = { isError: !1, value: s }, [t, []];
+  },
+  deserialize(s) {
+    throw s.isError ? Object.assign(new Error(s.value.message), s.value) : s.value;
+  }
+}, xt = /* @__PURE__ */ new Map([
+  ["proxy", _t],
+  ["throw", Wt]
+]);
+function Ht(s, t) {
+  for (const e of s)
+    if (t === e || e === "*" || e instanceof RegExp && e.test(t))
+      return !0;
+  return !1;
+}
+function rt(s, t = globalThis, e = ["*"]) {
+  t.addEventListener("message", function n(r) {
+    if (!r || !r.data)
+      return;
+    if (!Ht(e, r.origin)) {
+      console.warn(`Invalid origin '${r.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: i, type: o, path: c } = Object.assign({ path: [] }, r.data), a = (r.data.argumentList || []).map(M);
+    let h;
+    try {
+      const l = c.slice(0, -1).reduce((u, d) => u[d], s), f = c.reduce((u, d) => u[d], s);
+      switch (o) {
+        case "GET":
+          h = f;
+          break;
+        case "SET":
+          l[c.slice(-1)[0]] = M(r.data.value), h = !0;
+          break;
+        case "APPLY":
+          h = f.apply(l, a);
+          break;
+        case "CONSTRUCT":
+          {
+            const u = new f(...a);
+            h = Vt(u);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: u, port2: d } = new MessageChannel();
+            rt(s, d), h = vt(u, [u]);
+          }
+          break;
+        case "RELEASE":
+          h = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (l) {
+      h = { value: l, [H]: 0 };
+    }
+    Promise.resolve(h).catch((l) => ({ value: l, [H]: 0 })).then((l) => {
+      const [f, u] = G(l);
+      t.postMessage(Object.assign(Object.assign({}, f), { id: i }), u), o === "RELEASE" && (t.removeEventListener("message", n), Ot(t), Y in s && typeof s[Y] == "function" && s[Y]());
+    }).catch((l) => {
+      const [f, u] = G({
+        value: new TypeError("Unserializable return value"),
+        [H]: 0
+      });
+      t.postMessage(Object.assign(Object.assign({}, f), { id: i }), u);
+    });
+  }), t.start && t.start();
+}
+function jt(s) {
+  return s.constructor.name === "MessagePort";
+}
+function Ot(s) {
+  jt(s) && s.close();
+}
+function Bt(s, t) {
+  const e = /* @__PURE__ */ new Map();
+  return s.addEventListener("message", function(r) {
+    const { data: i } = r;
+    if (!i || !i.id)
+      return;
+    const o = e.get(i.id);
+    if (o)
+      try {
+        o(i);
+      } finally {
+        e.delete(i.id);
+      }
+  }), K(s, e, [], t);
+}
+function _(s) {
+  if (s)
+    throw new Error("Proxy has been released and is not useable");
+}
+function Dt(s) {
+  return C(s, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    Ot(s);
+  });
+}
+const B = /* @__PURE__ */ new WeakMap(), U = "FinalizationRegistry" in globalThis && new FinalizationRegistry((s) => {
+  const t = (B.get(s) || 0) - 1;
+  B.set(s, t), t === 0 && Dt(s);
+});
+function Ut(s, t) {
+  const e = (B.get(t) || 0) + 1;
+  B.set(t, e), U && U.register(s, t, s);
+}
+function Gt(s) {
+  U && U.unregister(s);
+}
+function K(s, t, e = [], n = function() {
+}) {
+  let r = !1;
+  const i = new Proxy(n, {
+    get(o, c) {
+      if (_(r), c === Lt)
+        return () => {
+          Gt(i), Dt(s), t.clear(), r = !0;
+        };
+      if (c === "then") {
+        if (e.length === 0)
+          return { then: () => i };
+        const a = C(s, t, {
+          type: "GET",
+          path: e.map((h) => h.toString())
+        }).then(M);
+        return a.then.bind(a);
+      }
+      return K(s, t, [...e, c]);
+    },
+    set(o, c, a) {
+      _(r);
+      const [h, l] = G(a);
+      return C(s, t, {
+        type: "SET",
+        path: [...e, c].map((f) => f.toString()),
+        value: h
+      }, l).then(M);
+    },
+    apply(o, c, a) {
+      _(r);
+      const h = e[e.length - 1];
+      if (h === zt)
+        return C(s, t, {
+          type: "ENDPOINT"
+        }).then(M);
+      if (h === "bind")
+        return K(s, t, e.slice(0, -1));
+      const [l, f] = ct(a);
+      return C(s, t, {
+        type: "APPLY",
+        path: e.map((u) => u.toString()),
+        argumentList: l
+      }, f).then(M);
+    },
+    construct(o, c) {
+      _(r);
+      const [a, h] = ct(c);
+      return C(s, t, {
+        type: "CONSTRUCT",
+        path: e.map((l) => l.toString()),
+        argumentList: a
+      }, h).then(M);
+    }
+  });
+  return Ut(i, s), i;
+}
+function qt(s) {
+  return Array.prototype.concat.apply([], s);
+}
+function ct(s) {
+  const t = s.map(G);
+  return [t.map((e) => e[0]), qt(t.map((e) => e[1]))];
+}
+const At = /* @__PURE__ */ new WeakMap();
+function vt(s, t) {
+  return At.set(s, t), s;
+}
+function Vt(s) {
+  return Object.assign(s, { [St]: !0 });
+}
+function G(s) {
+  for (const [t, e] of xt)
+    if (e.canHandle(s)) {
+      const [n, r] = e.serialize(s);
+      return [
+        {
+          type: "HANDLER",
+          name: t,
+          value: n
+        },
+        r
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: s
+    },
+    At.get(s) || []
+  ];
+}
+function M(s) {
+  switch (s.type) {
+    case "HANDLER":
+      return xt.get(s.name).deserialize(s.value);
+    case "RAW":
+      return s.value;
+  }
+}
+function C(s, t, e, n) {
+  return new Promise((r) => {
+    const i = Yt();
+    t.set(i, r), s.start && s.start(), s.postMessage(Object.assign({ id: i }, e), n);
+  });
+}
+function Yt() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+var A = /* @__PURE__ */ ((s) => (s.Added = "added", s.Changed = "changed", s.Removed = "removed", s))(A || {});
+const Zt = {
+  ENOENT: -2,
+  // No such file or directory
+  EISDIR: -21,
+  // Is a directory
+  ENOTDIR: -20,
+  // Not a directory
+  EACCES: -13,
+  // Permission denied
+  EEXIST: -17,
+  // File exists
+  ENOTEMPTY: -39,
+  // Directory not empty
+  EINVAL: -22,
+  // Invalid argument
+  EIO: -5,
+  // I/O error
+  ENOSPC: -28,
+  // No space left on device
+  EBUSY: -16,
+  // Device or resource busy
+  EINTR: -4,
+  // Interrupted system call
+  ENOTSUP: -95,
+  // Operation not supported
+  ERANGE: -34,
+  // Result too large
+  EBADF: -9,
+  // Bad file descriptor
+  EROOT: -1
+  // Custom: Cannot remove root directory
+};
+class w extends Error {
+  errno;
+  syscall;
+  path;
+  constructor(t, e, n, r, i) {
+    super(t, { cause: i }), this.name = e, this.errno = Zt[e] || -1, this.path = n, this.syscall = r;
+  }
+}
+class Xt extends w {
+  constructor(t) {
+    super("OPFS is not supported in this browser", "ENOTSUP", void 0, void 0, t);
+  }
+}
+class Jt extends w {
+  constructor(t, e, n) {
+    super(t, "INVALID_PATH", e, "access", n);
+  }
+}
+class j extends w {
+  constructor(t, e, n) {
+    const r = {
+      file: `File not found: ${e}`,
+      directory: `Directory not found: ${e}`,
+      source: `Source does not exist: ${e}`
+    };
+    super(r[t], "ENOENT", e, "access", n);
+  }
+}
+class Qt extends w {
+  constructor(t, e, n) {
+    super(`Permission denied for ${e} on: ${t}`, "EACCES", t, e, n);
+  }
+}
+class Kt extends w {
+  constructor(t, e, n) {
+    super(t, "ENOSPC", e, "write", n);
+  }
+}
+class te extends w {
+  constructor(t, e) {
+    super(`File is busy: ${t}`, "EBUSY", t, "open", e);
+  }
+}
+class tt extends w {
+  constructor(t, e, n) {
+    const r = t === "directory" ? `Is a directory: ${e}` : `Not a directory: ${e}`, i = t === "directory" ? "EISDIR" : "ENOTDIR";
+    super(r, i, e, "access", n);
+  }
+}
+class lt extends w {
+  constructor(t, e, n, r) {
+    const i = {
+      argument: "EINVAL",
+      format: "INVALID_FORMAT",
+      descriptor: "EBADF",
+      overflow: "ERANGE"
+    };
+    super(e, i[t], n, "validate", r);
+  }
+}
+class ee extends w {
+  constructor(t, e) {
+    super(`Operation aborted: ${t}`, "EINTR", t, "interrupt", e);
+  }
+}
+class ht extends w {
+  constructor(t, e, n) {
+    super(t, "EIO", e, "io", n);
+  }
+}
+class v extends w {
+  constructor(t, e) {
+    super(`Operation not supported: ${t}`, "ENOTSUP", t, "operation", e);
+  }
+}
+class et extends w {
+  constructor(t, e, n) {
+    const r = {
+      RM_FAILED: `Failed to remove entry: ${e}`,
+      ENOTEMPTY: `Directory not empty: ${e}. Use recursive option to force removal.`,
+      EROOT: "Cannot remove root directory"
+    };
+    super(r[t] || `Directory operation failed: ${e}`, t, e, "unlink", n);
+  }
+}
+class se extends w {
+  constructor(t, e) {
+    super("Failed to initialize OPFS", "INIT_FAILED", t, "init", e);
+  }
+}
+class Z extends w {
+  constructor(t, e, n) {
+    super(`Failed to ${t}: ${e}`, `${t.toUpperCase()}_FAILED`, e, t, n);
+  }
+}
+class ut extends w {
+  constructor(t, e) {
+    super(`Destination already exists: ${t}`, "EEXIST", t, "open", e);
+  }
+}
+function x(s, t) {
+  const e = t?.path, n = t?.isDirectory, r = t?.existenceType ?? "file", i = t?.operation;
+  switch (s.name) {
+    case "InvalidStateError":
+      return new te(e || "unknown", s);
+    case "QuotaExceededError":
+      return new Kt(`No space left on device: ${e || "unknown"}`, e, s);
+    case "NotFoundError":
+      return new j(r, e, s);
+    case "TypeMismatchError":
+      return n !== void 0 ? n ? new tt("directory", e || "unknown", s) : new tt("file", e || "unknown", s) : new lt("argument", `Type mismatch: ${e || "unknown"}`, e, s);
+    case "NotAllowedError":
+    case "SecurityError":
+      return new Qt(e, "unknown", s);
+    case "InvalidModificationError":
+      return i === "remove" ? new et("ENOTEMPTY", e, s) : new lt("argument", `Invalid modification: ${e || "unknown"}`, e, s);
+    case "AbortError":
+      return new ee(e || "unknown", s);
+    case "OperationError":
+      return new ht(`Operation failed: ${e || "unknown"}`, e, s);
+    case "TypeError":
+      return new v(e || "unknown", s);
+    default:
+      return i === "remove" ? new et("RM_FAILED", e, s) : new ht(`I/O error: ${e || "unknown"}`, e, s);
+  }
+}
+const Nt = (s, t, e) => {
+  const n = s instanceof RegExp ? ft(s, e) : s, r = t instanceof RegExp ? ft(t, e) : t, i = n !== null && r != null && ne(n, r, e);
+  return i && {
+    start: i[0],
+    end: i[1],
+    pre: e.slice(0, i[0]),
+    body: e.slice(i[0] + n.length, i[1]),
+    post: e.slice(i[1] + r.length)
+  };
+}, ft = (s, t) => {
+  const e = t.match(s);
+  return e ? e[0] : null;
+}, ne = (s, t, e) => {
+  let n, r, i, o, c, a = e.indexOf(s), h = e.indexOf(t, a + 1), l = a;
+  if (a >= 0 && h > 0) {
+    if (s === t)
+      return [a, h];
+    for (n = [], i = e.length; l >= 0 && !c; ) {
+      if (l === a)
+        n.push(l), a = e.indexOf(s, l + 1);
+      else if (n.length === 1) {
+        const f = n.pop();
+        f !== void 0 && (c = [f, h]);
+      } else
+        r = n.pop(), r !== void 0 && r < i && (i = r, o = h), h = e.indexOf(t, l + 1);
+      l = a < h && a >= 0 ? a : h;
+    }
+    n.length && o !== void 0 && (c = [i, o]);
+  }
+  return c;
+}, Tt = "\0SLASH" + Math.random() + "\0", Mt = "\0OPEN" + Math.random() + "\0", it = "\0CLOSE" + Math.random() + "\0", Ct = "\0COMMA" + Math.random() + "\0", $t = "\0PERIOD" + Math.random() + "\0", re = new RegExp(Tt, "g"), ie = new RegExp(Mt, "g"), oe = new RegExp(it, "g"), ae = new RegExp(Ct, "g"), ce = new RegExp($t, "g"), le = /\\\\/g, he = /\\{/g, ue = /\\}/g, fe = /\\,/g, de = /\\./g;
+function X(s) {
+  return isNaN(s) ? s.charCodeAt(0) : parseInt(s, 10);
+}
+function pe(s) {
+  return s.replace(le, Tt).replace(he, Mt).replace(ue, it).replace(fe, Ct).replace(de, $t);
+}
+function ge(s) {
+  return s.replace(re, "\\").replace(ie, "{").replace(oe, "}").replace(ae, ",").replace(ce, ".");
+}
+function Pt(s) {
+  if (!s)
+    return [""];
+  const t = [], e = Nt("{", "}", s);
+  if (!e)
+    return s.split(",");
+  const { pre: n, body: r, post: i } = e, o = n.split(",");
+  o[o.length - 1] += "{" + r + "}";
+  const c = Pt(i);
+  return i.length && (o[o.length - 1] += c.shift(), o.push.apply(o, c)), t.push.apply(t, o), t;
+}
+function we(s) {
+  return s ? (s.slice(0, 2) === "{}" && (s = "\\{\\}" + s.slice(2)), F(pe(s), !0).map(ge)) : [];
+}
+function me(s) {
+  return "{" + s + "}";
+}
+function ye(s) {
+  return /^-?0\d/.test(s);
+}
+function Ee(s, t) {
+  return s <= t;
+}
+function Se(s, t) {
+  return s >= t;
+}
+function F(s, t) {
+  const e = [], n = Nt("{", "}", s);
+  if (!n)
+    return [s];
+  const r = n.pre, i = n.post.length ? F(n.post, !1) : [""];
+  if (/\$$/.test(n.pre))
+    for (let o = 0; o < i.length; o++) {
+      const c = r + "{" + n.body + "}" + i[o];
+      e.push(c);
+    }
+  else {
+    const o = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(n.body), c = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(n.body), a = o || c, h = n.body.indexOf(",") >= 0;
+    if (!a && !h)
+      return n.post.match(/,(?!,).*\}/) ? (s = n.pre + "{" + n.body + it + n.post, F(s)) : [s];
+    let l;
+    if (a)
+      l = n.body.split(/\.\./);
+    else if (l = Pt(n.body), l.length === 1 && l[0] !== void 0 && (l = F(l[0], !1).map(me), l.length === 1))
+      return i.map((u) => n.pre + l[0] + u);
+    let f;
+    if (a && l[0] !== void 0 && l[1] !== void 0) {
+      const u = X(l[0]), d = X(l[1]), g = Math.max(l[0].length, l[1].length);
+      let p = l.length === 3 && l[2] !== void 0 ? Math.abs(X(l[2])) : 1, S = Ee;
+      d < u && (p *= -1, S = Se);
+      const P = l.some(ye);
+      f = [];
+      for (let b = u; S(b, d); b += p) {
+        let m;
+        if (c)
+          m = String.fromCharCode(b), m === "\\" && (m = "");
+        else if (m = String(b), P) {
+          const k = g - m.length;
+          if (k > 0) {
+            const L = new Array(k + 1).join("0");
+            b < 0 ? m = "-" + L + m.slice(1) : m = L + m;
+          }
+        }
+        f.push(m);
+      }
+    } else {
+      f = [];
+      for (let u = 0; u < l.length; u++)
+        f.push.apply(f, F(l[u], !1));
+    }
+    for (let u = 0; u < f.length; u++)
+      for (let d = 0; d < i.length; d++) {
+        const g = r + f[u] + i[d];
+        (!t || a || g) && e.push(g);
+      }
+  }
+  return e;
+}
+const be = 1024 * 64, q = (s) => {
+  if (typeof s != "string")
+    throw new TypeError("invalid pattern");
+  if (s.length > be)
+    throw new TypeError("pattern is too long");
+}, xe = {
+  "[: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]
+}, R = (s) => s.replace(/[[\]\\-]/g, "\\$&"), Oe = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), dt = (s) => s.join(""), De = (s, t) => {
+  const e = t;
+  if (s.charAt(e) !== "[")
+    throw new Error("not in a brace expression");
+  const n = [], r = [];
+  let i = e + 1, o = !1, c = !1, a = !1, h = !1, l = e, f = "";
+  t: for (; i < s.length; ) {
+    const p = s.charAt(i);
+    if ((p === "!" || p === "^") && i === e + 1) {
+      h = !0, i++;
+      continue;
+    }
+    if (p === "]" && o && !a) {
+      l = i + 1;
+      break;
+    }
+    if (o = !0, p === "\\" && !a) {
+      a = !0, i++;
+      continue;
+    }
+    if (p === "[" && !a) {
+      for (const [S, [N, P, b]] of Object.entries(xe))
+        if (s.startsWith(S, i)) {
+          if (f)
+            return ["$.", !1, s.length - e, !0];
+          i += S.length, b ? r.push(N) : n.push(N), c = c || P;
+          continue t;
+        }
+    }
+    if (a = !1, f) {
+      p > f ? n.push(R(f) + "-" + R(p)) : p === f && n.push(R(p)), f = "", i++;
+      continue;
+    }
+    if (s.startsWith("-]", i + 1)) {
+      n.push(R(p + "-")), i += 2;
+      continue;
+    }
+    if (s.startsWith("-", i + 1)) {
+      f = p, i += 2;
+      continue;
+    }
+    n.push(R(p)), i++;
+  }
+  if (l < i)
+    return ["", !1, 0, !1];
+  if (!n.length && !r.length)
+    return ["$.", !1, s.length - e, !0];
+  if (r.length === 0 && n.length === 1 && /^\\?.$/.test(n[0]) && !h) {
+    const p = n[0].length === 2 ? n[0].slice(-1) : n[0];
+    return [Oe(p), !1, l - e, !1];
+  }
+  const u = "[" + (h ? "^" : "") + dt(n) + "]", d = "[" + (h ? "" : "^") + dt(r) + "]";
+  return [n.length && r.length ? "(" + u + "|" + d + ")" : n.length ? u : d, c, l - e, !0];
+}, I = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1"), Ae = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), pt = (s) => Ae.has(s), ve = "(?!(?:^|/)\\.\\.?(?:$|/))", W = "(?!\\.)", Ne = /* @__PURE__ */ new Set(["[", "."]), Te = /* @__PURE__ */ new Set(["..", "."]), Me = new Set("().*{}+?[]^$\\!"), Ce = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), ot = "[^/]", gt = ot + "*?", wt = ot + "+?";
+class E {
+  type;
+  #s;
+  #n;
+  #i = !1;
+  #t = [];
+  #e;
+  #o;
+  #c;
+  #a = !1;
+  #r;
+  #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.#r = this.#s === this ? n : this.#s.#r, 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 r = e.#o + 1; !n.type && r < n.#t.length; r++)
+          for (const i of t.#t) {
+            if (typeof i == "string")
+              throw new Error("string part in extglob AST??");
+            i.copyIn(n.#t[r]);
+          }
+        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, r) {
+    let i = !1, o = !1, c = -1, a = !1;
+    if (e.type === null) {
+      let d = n, g = "";
+      for (; d < t.length; ) {
+        const p = t.charAt(d++);
+        if (i || p === "\\") {
+          i = !i, g += p;
+          continue;
+        }
+        if (o) {
+          d === c + 1 ? (p === "^" || p === "!") && (a = !0) : p === "]" && !(d === c + 2 && a) && (o = !1), g += p;
+          continue;
+        } else if (p === "[") {
+          o = !0, c = d, a = !1, g += p;
+          continue;
+        }
+        if (!r.noext && pt(p) && t.charAt(d) === "(") {
+          e.push(g), g = "";
+          const S = new E(p, e);
+          d = E.#h(t, S, d, r), e.push(S);
+          continue;
+        }
+        g += p;
+      }
+      return e.push(g), d;
+    }
+    let h = n + 1, l = new E(null, e);
+    const f = [];
+    let u = "";
+    for (; h < t.length; ) {
+      const d = t.charAt(h++);
+      if (i || d === "\\") {
+        i = !i, u += d;
+        continue;
+      }
+      if (o) {
+        h === c + 1 ? (d === "^" || d === "!") && (a = !0) : d === "]" && !(h === c + 2 && a) && (o = !1), u += d;
+        continue;
+      } else if (d === "[") {
+        o = !0, c = h, a = !1, u += d;
+        continue;
+      }
+      if (pt(d) && t.charAt(h) === "(") {
+        l.push(u), u = "";
+        const g = new E(d, l);
+        l.push(g), h = E.#h(t, g, h, r);
+        continue;
+      }
+      if (d === "|") {
+        l.push(u), u = "", f.push(l), l = new E(null, e);
+        continue;
+      }
+      if (d === ")")
+        return u === "" && e.#t.length === 0 && (e.#u = !0), l.push(u), u = "", e.push(...f, l), 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, r, i] = this.toRegExpSource();
+    if (!(r || this.#n || this.#r.nocase && !this.#r.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase()))
+      return n;
+    const c = (this.#r.nocase ? "i" : "") + (i ? "u" : "");
+    return Object.assign(new RegExp(`^${e}$`, c), {
+      _src: e,
+      _glob: t
+    });
+  }
+  get options() {
+    return this.#r;
+  }
+  // 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.#r.dot;
+    if (this.#s === this && this.#d(), !this.type) {
+      const a = this.isStart() && this.isEnd(), h = this.#t.map((d) => {
+        const [g, p, S, N] = typeof d == "string" ? E.#p(d, this.#n, a) : d.toRegExpSource(t);
+        return this.#n = this.#n || S, this.#i = this.#i || N, g;
+      }).join("");
+      let l = "";
+      if (this.isStart() && typeof this.#t[0] == "string" && !(this.#t.length === 1 && Te.has(this.#t[0]))) {
+        const g = Ne, p = (
+          // dots are allowed, and the pattern starts with [ or .
+          e && g.has(h.charAt(0)) || // the pattern starts with \., and then [ or .
+          h.startsWith("\\.") && g.has(h.charAt(2)) || // the pattern starts with \.\., and then [ or .
+          h.startsWith("\\.\\.") && g.has(h.charAt(4))
+        ), S = !e && !t && g.has(h.charAt(0));
+        l = p ? ve : S ? W : "";
+      }
+      let f = "";
+      return this.isEnd() && this.#s.#a && this.#e?.type === "!" && (f = "(?:$|\\/)"), [
+        l + h + f,
+        I(h),
+        this.#n = !!this.#n,
+        this.#i
+      ];
+    }
+    const n = this.type === "*" || this.type === "+", r = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let i = this.#f(e);
+    if (this.isStart() && this.isEnd() && !i && this.type !== "!") {
+      const a = this.toString();
+      return this.#t = [a], this.type = null, this.#n = void 0, [a, I(this.toString()), !1, !1];
+    }
+    let o = !n || t || e || !W ? "" : this.#f(!0);
+    o === i && (o = ""), o && (i = `(?:${i})(?:${o})*?`);
+    let c = "";
+    if (this.type === "!" && this.#u)
+      c = (this.isStart() && !e ? W : "") + wt;
+    else {
+      const a = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !e && !t ? W : "") + gt + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : `)${this.type}`;
+      c = r + i + a;
+    }
+    return [
+      c,
+      I(i),
+      this.#n = !!this.#n,
+      this.#i
+    ];
+  }
+  #f(t) {
+    return this.#t.map((e) => {
+      if (typeof e == "string")
+        throw new Error("string type in extglob ast??");
+      const [n, r, i, o] = e.toRegExpSource(t);
+      return this.#i = this.#i || o, n;
+    }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+  }
+  static #p(t, e, n = !1) {
+    let r = !1, i = "", o = !1;
+    for (let c = 0; c < t.length; c++) {
+      const a = t.charAt(c);
+      if (r) {
+        r = !1, i += (Me.has(a) ? "\\" : "") + a;
+        continue;
+      }
+      if (a === "\\") {
+        c === t.length - 1 ? i += "\\\\" : r = !0;
+        continue;
+      }
+      if (a === "[") {
+        const [h, l, f, u] = De(t, c);
+        if (f) {
+          i += h, o = o || l, c += f - 1, e = e || u;
+          continue;
+        }
+      }
+      if (a === "*") {
+        n && t === "*" ? i += wt : i += gt, e = !0;
+        continue;
+      }
+      if (a === "?") {
+        i += ot, e = !0;
+        continue;
+      }
+      i += Ce(a);
+    }
+    return [i, I(t), !!e, o];
+  }
+}
+const $e = (s, { windowsPathsNoEscape: t = !1 } = {}) => t ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&"), y = (s, t, e = {}) => (q(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new V(t, e).match(s)), Pe = /^\*+([^+@!?\*\[\(]*)$/, ke = (s) => (t) => !t.startsWith(".") && t.endsWith(s), Re = (s) => (t) => t.endsWith(s), Fe = (s) => (s = s.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(s)), Ie = (s) => (s = s.toLowerCase(), (t) => t.toLowerCase().endsWith(s)), ze = /^\*+\.\*+$/, Le = (s) => !s.startsWith(".") && s.includes("."), _e = (s) => s !== "." && s !== ".." && s.includes("."), We = /^\.\*+$/, He = (s) => s !== "." && s !== ".." && s.startsWith("."), je = /^\*+$/, Be = (s) => s.length !== 0 && !s.startsWith("."), Ue = (s) => s.length !== 0 && s !== "." && s !== "..", Ge = /^\?+([^+@!?\*\[\(]*)?$/, qe = ([s, t = ""]) => {
+  const e = kt([s]);
+  return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
+}, Ve = ([s, t = ""]) => {
+  const e = Rt([s]);
+  return t ? (t = t.toLowerCase(), (n) => e(n) && n.toLowerCase().endsWith(t)) : e;
+}, Ye = ([s, t = ""]) => {
+  const e = Rt([s]);
+  return t ? (n) => e(n) && n.endsWith(t) : e;
+}, Ze = ([s, t = ""]) => {
+  const e = kt([s]);
+  return t ? (n) => e(n) && n.endsWith(t) : e;
+}, kt = ([s]) => {
+  const t = s.length;
+  return (e) => e.length === t && !e.startsWith(".");
+}, Rt = ([s]) => {
+  const t = s.length;
+  return (e) => e.length === t && e !== "." && e !== "..";
+}, Ft = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", mt = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+}, Xe = Ft === "win32" ? mt.win32.sep : mt.posix.sep;
+y.sep = Xe;
+const D = Symbol("globstar **");
+y.GLOBSTAR = D;
+const Je = "[^/]", Qe = Je + "*?", Ke = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", ts = "(?:(?!(?:\\/|^)\\.).)*?", es = (s, t = {}) => (e) => y(e, s, t);
+y.filter = es;
+const O = (s, t = {}) => Object.assign({}, s, t), ss = (s) => {
+  if (!s || typeof s != "object" || !Object.keys(s).length)
+    return y;
+  const t = y;
+  return Object.assign((n, r, i = {}) => t(n, r, O(s, i)), {
+    Minimatch: class extends t.Minimatch {
+      constructor(r, i = {}) {
+        super(r, O(s, i));
+      }
+      static defaults(r) {
+        return t.defaults(O(s, r)).Minimatch;
+      }
+    },
+    AST: class extends t.AST {
+      /* c8 ignore start */
+      constructor(r, i, o = {}) {
+        super(r, i, O(s, o));
+      }
+      /* c8 ignore stop */
+      static fromGlob(r, i = {}) {
+        return t.AST.fromGlob(r, O(s, i));
+      }
+    },
+    unescape: (n, r = {}) => t.unescape(n, O(s, r)),
+    escape: (n, r = {}) => t.escape(n, O(s, r)),
+    filter: (n, r = {}) => t.filter(n, O(s, r)),
+    defaults: (n) => t.defaults(O(s, n)),
+    makeRe: (n, r = {}) => t.makeRe(n, O(s, r)),
+    braceExpand: (n, r = {}) => t.braceExpand(n, O(s, r)),
+    match: (n, r, i = {}) => t.match(n, r, O(s, i)),
+    sep: t.sep,
+    GLOBSTAR: D
+  });
+};
+y.defaults = ss;
+const It = (s, t = {}) => (q(s), t.nobrace || !/\{(?:(?!\{).)*\}/.test(s) ? [s] : we(s));
+y.braceExpand = It;
+const ns = (s, t = {}) => new V(s, t).makeRe();
+y.makeRe = ns;
+const rs = (s, t, e = {}) => {
+  const n = new V(t, e);
+  return s = s.filter((r) => n.match(r)), n.options.nonull && !s.length && s.push(t), s;
+};
+y.match = rs;
+const yt = /[?*]|[+@!]\(.*?\)|\[|\]/, is = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+class V {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(t, e = {}) {
+    q(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || Ft, 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 = (...i) => console.error(...i)), this.debug(this.pattern, this.globSet);
+    const n = this.globSet.map((i) => this.slashSplit(i));
+    this.globParts = this.preprocess(n), this.debug(this.pattern, this.globParts);
+    let r = this.globParts.map((i, o, c) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const a = i[0] === "" && i[1] === "" && (i[2] === "?" || !yt.test(i[2])) && !yt.test(i[3]), h = /^[a-z]:/i.test(i[0]);
+        if (a)
+          return [...i.slice(0, 4), ...i.slice(4).map((l) => this.parse(l))];
+        if (h)
+          return [i[0], ...i.slice(1).map((l) => this.parse(l))];
+      }
+      return i.map((a) => this.parse(a));
+    });
+    if (this.debug(this.pattern, r), this.set = r.filter((i) => i.indexOf(!1) === -1), this.isWindows)
+      for (let i = 0; i < this.set.length; i++) {
+        const o = this.set[i];
+        o[0] === "" && o[1] === "" && this.globParts[i][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 r = 0; r < t[n].length; r++)
+          t[n][r] === "**" && (t[n][r] = "*");
+    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 r = n;
+        for (; e[r + 1] === "**"; )
+          r++;
+        r !== n && e.splice(n, r - n);
+      }
+      return e;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(t) {
+    return t.map((e) => (e = e.reduce((n, r) => {
+      const i = n[n.length - 1];
+      return r === "**" && i === "**" ? n : r === ".." && i && i !== ".." && i !== "." && i !== "**" ? (n.pop(), n) : (n.push(r), 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 r = 1; r < t.length - 1; r++) {
+          const i = t[r];
+          r === 1 && i === "" && t[0] === "" || (i === "." || i === "") && (e = !0, t.splice(r, 1), r--);
+        }
+        t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+      }
+      let n = 0;
+      for (; (n = t.indexOf("..", n + 1)) !== -1; ) {
+        const r = t[n - 1];
+        r && r !== "." && r !== ".." && r !== "**" && (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 r = -1;
+        for (; (r = n.indexOf("**", r + 1)) !== -1; ) {
+          let o = r;
+          for (; n[o + 1] === "**"; )
+            o++;
+          o > r && n.splice(r + 1, o - r);
+          let c = n[r + 1];
+          const a = n[r + 2], h = n[r + 3];
+          if (c !== ".." || !a || a === "." || a === ".." || !h || h === "." || h === "..")
+            continue;
+          e = !0, n.splice(r, 1);
+          const l = n.slice(0);
+          l[r] = "**", t.push(l), r--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let o = 1; o < n.length - 1; o++) {
+            const c = n[o];
+            o === 1 && c === "" && n[0] === "" || (c === "." || c === "") && (e = !0, n.splice(o, 1), o--);
+          }
+          n[0] === "." && n.length === 2 && (n[1] === "." || n[1] === "") && (e = !0, n.pop());
+        }
+        let i = 0;
+        for (; (i = n.indexOf("..", i + 1)) !== -1; ) {
+          const o = n[i - 1];
+          if (o && o !== "." && o !== ".." && o !== "**") {
+            e = !0;
+            const a = i === 1 && n[i + 1] === "**" ? ["."] : [];
+            n.splice(i - 1, 2, ...a), n.length === 0 && n.push(""), i -= 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 r = this.partsMatch(t[e], t[n], !this.preserveMultipleSlashes);
+        if (r) {
+          t[e] = [], t[n] = r;
+          break;
+        }
+      }
+    return t.filter((e) => e.length);
+  }
+  partsMatch(t, e, n = !1) {
+    let r = 0, i = 0, o = [], c = "";
+    for (; r < t.length && i < e.length; )
+      if (t[r] === e[i])
+        o.push(c === "b" ? e[i] : t[r]), r++, i++;
+      else if (n && t[r] === "**" && e[i] === t[r + 1])
+        o.push(t[r]), r++;
+      else if (n && e[i] === "**" && t[r] === e[i + 1])
+        o.push(e[i]), i++;
+      else if (t[r] === "*" && e[i] && (this.options.dot || !e[i].startsWith(".")) && e[i] !== "**") {
+        if (c === "b")
+          return !1;
+        c = "a", o.push(t[r]), r++, i++;
+      } else if (e[i] === "*" && t[r] && (this.options.dot || !t[r].startsWith(".")) && t[r] !== "**") {
+        if (c === "a")
+          return !1;
+        c = "b", o.push(e[i]), r++, i++;
+      } 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 r = 0; r < t.length && t.charAt(r) === "!"; r++)
+      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 r = 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]), N = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), P = !N && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), b = S ? 3 : p ? 0 : void 0, m = P ? 3 : N ? 0 : void 0;
+      if (typeof b == "number" && typeof m == "number") {
+        const [k, L] = [t[b], e[m]];
+        k.toLowerCase() === L.toLowerCase() && (e[m] = k, m > b ? e = e.slice(m) : b > m && (t = t.slice(b)));
+      }
+    }
+    const { optimizationLevel: i = 1 } = this.options;
+    i >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, { file: t, pattern: e }), this.debug("matchOne", t.length, e.length);
+    for (var o = 0, c = 0, a = t.length, h = e.length; o < a && c < h; o++, c++) {
+      this.debug("matchOne loop");
+      var l = e[c], f = t[o];
+      if (this.debug(e, l, f), l === !1)
+        return !1;
+      if (l === D) {
+        this.debug("GLOBSTAR", [e, l, f]);
+        var u = o, d = c + 1;
+        if (d === h) {
+          for (this.debug("** at the end"); o < a; o++)
+            if (t[o] === "." || t[o] === ".." || !r.dot && t[o].charAt(0) === ".")
+              return !1;
+          return !0;
+        }
+        for (; u < a; ) {
+          var g = t[u];
+          if (this.debug(`
+globstar while`, t, u, e, d, g), this.matchOne(t.slice(u), e.slice(d), n))
+            return this.debug("globstar found match!", u, a, g), !0;
+          if (g === "." || g === ".." || !r.dot && g.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 === a));
+      }
+      let p;
+      if (typeof l == "string" ? (p = f === l, this.debug("string match", l, f, p)) : (p = l.test(f), this.debug("pattern match", l, f, p)), !p)
+        return !1;
+    }
+    if (o === a && c === h)
+      return !0;
+    if (o === a)
+      return n;
+    if (c === h)
+      return o === a - 1 && t[o] === "";
+    throw new Error("wtf?");
+  }
+  braceExpand() {
+    return It(this.pattern, this.options);
+  }
+  parse(t) {
+    q(t);
+    const e = this.options;
+    if (t === "**")
+      return D;
+    if (t === "")
+      return "";
+    let n, r = null;
+    (n = t.match(je)) ? r = e.dot ? Ue : Be : (n = t.match(Pe)) ? r = (e.nocase ? e.dot ? Ie : Fe : e.dot ? Re : ke)(n[1]) : (n = t.match(Ge)) ? r = (e.nocase ? e.dot ? Ve : qe : e.dot ? Ye : Ze)(n) : (n = t.match(ze)) ? r = e.dot ? _e : Le : (n = t.match(We)) && (r = He);
+    const i = E.fromGlob(t, this.options).toMMPattern();
+    return r && typeof i == "object" && Reflect.defineProperty(i, "test", { value: r }), i;
+  }
+  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 ? Qe : e.dot ? Ke : ts, r = new Set(e.nocase ? ["i"] : []);
+    let i = t.map((a) => {
+      const h = a.map((l) => {
+        if (l instanceof RegExp)
+          for (const f of l.flags.split(""))
+            r.add(f);
+        return typeof l == "string" ? is(l) : l === D ? D : l._src;
+      });
+      return h.forEach((l, f) => {
+        const u = h[f + 1], d = h[f - 1];
+        l !== D || d === D || (d === void 0 ? u !== void 0 && u !== D ? h[f + 1] = "(?:\\/|" + n + "\\/)?" + u : h[f] = n : u === void 0 ? h[f - 1] = d + "(?:\\/|" + n + ")?" : u !== D && (h[f - 1] = d + "(?:\\/|\\/" + n + "\\/)" + u, h[f + 1] = D));
+      }), h.filter((l) => l !== D).join("/");
+    }).join("|");
+    const [o, c] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+    i = "^" + o + i + c + "$", this.negate && (i = "^(?!" + i + ").+$");
+    try {
+      this.regexp = new RegExp(i, [...r].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 r = this.slashSplit(t);
+    this.debug(this.pattern, "split", r);
+    const i = this.set;
+    this.debug(this.pattern, "set", i);
+    let o = r[r.length - 1];
+    if (!o)
+      for (let c = r.length - 2; !o && c >= 0; c--)
+        o = r[c];
+    for (let c = 0; c < i.length; c++) {
+      const a = i[c];
+      let h = r;
+      if (n.matchBase && a.length === 1 && (h = [o]), this.matchOne(h, a, 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 = V;
+y.escape = $e;
+y.unescape = I;
+function os() {
+  if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
+    throw new Xt();
+}
+async function z(s, t) {
+  return typeof navigator < "u" && navigator.locks?.request ? navigator.locks.request(`opfs:${s.replace(/\/+/g, "/")}`, { mode: "exclusive" }, t) : t();
+}
+function $(s) {
+  return Array.isArray(s) ? s : (s.startsWith("~/") ? s.slice(2) : s).split("/").filter(Boolean);
+}
+function at(s) {
+  return typeof s == "string" ? s ?? "/" : `/${s.join("/")}`;
+}
+function st(s) {
+  const t = $(s);
+  return t[t.length - 1] || "";
+}
+function J(s) {
+  const t = $(s);
+  return t.pop(), at(t);
+}
+function nt(s) {
+  return !s || s === "/" ? "/" : s.startsWith("~/") ? `/${s.slice(2)}` : s.startsWith("/") ? s : `/${s}`;
+}
+function as(s, t = !1) {
+  return s = s.replace(/\/$/, ""), t && !s.includes("*") ? `${s}/**` : s;
+}
+function Q(s, t) {
+  return y(s, t, {
+    dot: !0,
+    matchBase: !0
+  });
+}
+function cs(s) {
+  const t = nt(s), e = $(t), n = [];
+  for (const r of e)
+    if (!(r === "." || r === ""))
+      if (r === "..") {
+        if (n.length === 0)
+          continue;
+        n.pop();
+      } else
+        n.push(r);
+  return at(n);
+}
+async function ls(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), r = await crypto.subtle.digest(t, n);
+  return Array.from(new Uint8Array(r)).map((o) => o.toString(16).padStart(2, "0")).join("");
+}
+async function hs(s, t, e = {}) {
+  const n = st(t);
+  return z(t, async () => {
+    const r = e.recursive ?? !1, i = e.force ?? !1;
+    try {
+      await s.removeEntry(n, { recursive: r });
+    } catch (o) {
+      if (o.name === "NotFoundError" && i)
+        return;
+      const c = o.name === "TypeMismatchError" && !r;
+      throw x(o, {
+        path: t,
+        operation: "remove",
+        isDirectory: c
+      });
+    }
+  });
+}
+class us {
+  /** Root directory handle for the file system */
+  root;
+  /** Map of watched paths and options */
+  watchers = /* @__PURE__ */ new Map();
+  /** Promise to prevent concurrent mount operations */
+  mountingPromise = null;
+  /** BroadcastChannel instance for sending events */
+  broadcastChannel = null;
+  /** Configuration options */
+  options = {
+    root: "/",
+    namespace: "",
+    maxFileSize: 50 * 1024 * 1024,
+    hashAlgorithm: "etag",
+    broadcastChannel: "opfs-worker"
+  };
+  /**
+   * Notify about internal changes to the file system
+   * 
+   * This method is called by internal operations to notify clients about
+   * changes, even when no specific paths are being watched.
+   * 
+   * @param event - The event describing the change
+   */
+  async notifyChange(t) {
+    if (!this.options.broadcastChannel)
+      return;
+    const e = t.path;
+    if (![...this.watchers.values()].some((i) => Q(e, i.pattern) && i.include.some((o) => o && Q(e, o)) && !i.exclude.some((o) => o && Q(e, o))))
+      return;
+    let r;
+    if (this.options.hashAlgorithm)
+      try {
+        r = (await this.stat(e)).hash;
+      } catch {
+      }
+    try {
+      this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
+      const i = {
+        namespace: this.options.namespace,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...t,
+        ...r && { hash: r }
+      };
+      this.broadcastChannel.postMessage(i);
+    } catch (i) {
+      console.warn("Failed to send event via BroadcastChannel:", i);
+    }
+  }
+  constructor(t) {
+    os(), t && this.setOptions(t);
+  }
+  /**
+   * Initialize the file system within a given directory.
+   * If no root is specified, uses the OPFS root directory.
+   */
+  async mount() {
+    const t = this.options.root;
+    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, n) => {
+      try {
+        const r = await navigator.storage.getDirectory();
+        this.root = t === "/" ? r : await this.getDirectoryHandle(t, !0, r), e(!0);
+      } catch (r) {
+        n(new se(t, r));
+      } finally {
+        this.mountingPromise = null;
+      }
+    }), this.mountingPromise;
+  }
+  /**
+   * 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
+   */
+  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 = nt(t.root), this.options.namespace || (this.options.namespace = `opfs-worker:${this.options.root}`), await this.mount());
+  }
+  /**
+   * Get a directory handle from a path
+   * 
+   * Navigates through the directory structure to find or create a directory
+   * at the specified path.
+   * 
+   * @param path - The path to the directory (string or array of segments)
+   * @param create - Whether to create the directory if it doesn't exist (default: false)
+   * @param from - The directory to start from (default: root directory)
+   * @returns Promise that resolves to the directory handle
+   * @throws {OPFSError} If the directory cannot be accessed or created
+   * 
+   * @example
+   * ```typescript
+   * const docsDir = await fs.getDirectoryHandle('/users/john/documents', true);
+   * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
+   * ```
+   */
+  async getDirectoryHandle(t, e = !1, n = this.root) {
+    const r = Array.isArray(t) ? t : $(t);
+    let i = n;
+    for (const o of r)
+      i = await i.getDirectoryHandle(o, { create: e });
+    return i;
+  }
+  /**
+   * Get a file handle from a path
+   * 
+   * Navigates to the parent directory and retrieves or creates a file handle
+   * for the specified file path.
+   * 
+   * @param path - The path to the file (string or array of segments)
+   * @param create - Whether to create the file if it doesn't exist (default: false)
+   * @param _from - The directory to start from (default: root directory)
+   * @returns Promise that resolves to the file handle
+   * @throws {PathError} If the path is empty
+   * @throws {OPFSError} If the file cannot be accessed or created
+   * 
+   * @example
+   * ```typescript
+   * const fileHandle = await fs.getFileHandle('/config/settings.json', true);
+   * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
+   * ```
+   */
+  async getFileHandle(t, e = !1, n = this.root) {
+    const r = $(t);
+    if (r.length === 0)
+      throw new Jt("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+    const i = r.pop();
+    return (await this.getDirectoryHandle(r, e, n)).getFileHandle(i, { create: e });
+  }
+  /**
+   * Get a complete index of all files and directories in the file system
+   * 
+   * This method recursively traverses the entire file system and returns
+   * a Map containing FileStat objects for every file and directory.
+   * 
+   * @returns Promise that resolves to a Map of paths to FileStat objects
+   * @throws {OPFSError} If the file system is not mounted
+   * 
+   * @example
+   * ```typescript
+   * const index = await fs.index();
+   * const fileStats = index.get('/data/config.json');
+   * if (fileStats) {
+   *   console.log(`File size: ${fileStats.size} bytes`);
+   *   if (fileStats.hash) console.log(`Hash: ${fileStats.hash}`);
+   * }
+   * ```
+   */
+  async index() {
+    const t = /* @__PURE__ */ new Map(), e = async (n) => {
+      const r = await this.readDir(n);
+      for (const i of r) {
+        const o = `${n === "/" ? "" : n}/${i.name}`;
+        try {
+          const c = await this.stat(o);
+          t.set(o, c), c.isDirectory && await e(o);
+        } catch (c) {
+          console.warn(`Skipping broken entry: ${o}`, c);
+        }
+      }
+    };
+    return t.set("/", {
+      kind: "directory",
+      size: 0,
+      mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      isFile: !1,
+      isDirectory: !0
+    }), await e("/"), t;
+  }
+  /**
+   * Create a directory
+   * 
+   * Creates a new directory at the specified path. If the recursive option
+   * is enabled, parent directories will be created as needed.
+   * 
+   * @param path - The path where the directory should be created
+   * @param options - Options for directory creation
+   * @param options.recursive - Whether to create parent directories if they don't exist (default: false)
+   * @returns Promise that resolves when the directory is created
+   * @throws {OPFSError} If the directory cannot be created
+   * 
+   * @example
+   * ```typescript
+   * // Create a single directory
+   * await fs.mkdir('/users/john');
+   * 
+   * // Create nested directories
+   * await fs.mkdir('/users/john/documents/projects', { recursive: true });
+   * ```
+   */
+  async mkdir(t, e) {
+    await this.mount();
+    const n = e?.recursive ?? !1, r = $(t);
+    let i = this.root;
+    for (let o = 0; o < r.length; o++) {
+      const c = r[o];
+      try {
+        i = await i.getDirectoryHandle(c, { create: n || o === r.length - 1 });
+      } catch (a) {
+        throw a.name === "NotFoundError" ? x(a, {
+          path: at(r.slice(0, o + 1)),
+          existenceType: "directory"
+        }) : a.name === "TypeMismatchError" ? x(a, { path: c, isDirectory: !1 }) : new Z("create directory", c, a);
+      }
+    }
+    await this.notifyChange({ path: t, type: A.Added, isDirectory: !0 });
+  }
+  /**
+   * Get file or directory statistics
+   * 
+   * Returns detailed information about a file or directory, including
+   * size, modification time, and optionally a hash of the file content.
+   * 
+   * @param path - The path to the file or directory
+   * @returns Promise that resolves to FileStat object
+   * @throws {OPFSError} If the path does not exist or cannot be accessed
+   * 
+   * @example
+   * ```typescript
+   * const stats = await fs.stat('/data/config.json');
+   * console.log(`File size: ${stats.size} bytes`);
+   * console.log(`Last modified: ${stats.mtime}`);
+   * 
+   * // If hashing is enabled, hash will be included
+   * if (stats.hash) {
+   *   console.log(`Hash: ${stats.hash}`);
+   * }
+   * ```
+   */
+  async stat(t) {
+    if (await this.mount(), t === "/")
+      return {
+        kind: "directory",
+        size: 0,
+        mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        isFile: !1,
+        isDirectory: !0
+      };
+    const e = st(t);
+    let n;
+    try {
+      n = await this.getDirectoryHandle(J(t), !1);
+      const r = this.options.hashAlgorithm, o = await (await n.getFileHandle(e, { create: !1 })).getFile(), c = {
+        kind: "file",
+        size: o.size,
+        mtime: new Date(o.lastModified).toISOString(),
+        ctime: new Date(o.lastModified).toISOString(),
+        isFile: !0,
+        isDirectory: !1
+      };
+      if (r === "etag")
+        c.hash = `${o.lastModified.toString(36)}-${o.size.toString(36)}`;
+      else if (typeof r == "string")
+        try {
+          const a = await ls(o, r, this.options.maxFileSize);
+          c.hash = a;
+        } catch (a) {
+          console.warn(`Failed to calculate hash for ${t}:`, a);
+        }
+      return c;
+    } catch (r) {
+      if (r.name === "NotFoundError")
+        throw new j("file", t, r);
+      if (r.name !== "TypeMismatchError")
+        throw new Z("stat", t, r);
+    }
+    try {
+      return await n.getDirectoryHandle(e, { create: !1 }), {
+        kind: "directory",
+        size: 0,
+        mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        isFile: !1,
+        isDirectory: !0
+      };
+    } catch (r) {
+      throw new Z("stat", t, r);
+    }
+  }
+  /**
+   * Read a directory's contents
+   * 
+   * Lists all files and subdirectories within the specified directory.
+   * 
+   * @param path - The path to the directory to read
+   * @returns Promise that resolves to an array of detailed file/directory information
+   * @throws {OPFSError} If the directory does not exist or cannot be accessed
+   * 
+   * @example
+   * ```typescript
+   * // Get detailed information about files and directories
+   * const detailed = await fs.readDir('/users/john/documents');
+   * detailed.forEach(item => {
+   *   console.log(`${item.name} - ${item.isFile ? 'file' : 'directory'}`);
+   * });
+   * ```
+   */
+  async readDir(t) {
+    await this.mount();
+    const e = await this.getDirectoryHandle(t, !1), n = [];
+    for await (const [r, i] of e.entries()) {
+      const o = i.kind === "file";
+      n.push({
+        name: r,
+        kind: i.kind,
+        isFile: o,
+        isDirectory: !o
+      });
+    }
+    return n;
+  }
+  /**
+   * Check if a file or directory exists
+   * 
+   * Verifies if a file or directory exists at the specified path.
+   * 
+   * @param path - The path to check
+   * @returns Promise that resolves to true if the file or directory exists, false otherwise  
+   * 
+   * @example
+   * ```typescript
+   * const exists = await fs.exists('/config/settings.json');
+   * console.log(`File exists: ${exists}`);
+   * ```
+   */
+  async exists(t) {
+    if (await this.mount(), t === "/")
+      return !0;
+    const e = st(t);
+    let n = null;
+    try {
+      n = await this.getDirectoryHandle(J(t), !1);
+    } catch (r) {
+      if (n = null, r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
+    }
+    if (!n || !e)
+      return !1;
+    try {
+      return await n.getFileHandle(e, { create: !1 }), !0;
+    } catch (r) {
+      if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
+      try {
+        return await n.getDirectoryHandle(e, { create: !1 }), !0;
+      } catch (i) {
+        if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+          throw i;
+        return !1;
+      }
+    }
+  }
+  /**
+   * Clear all contents of a directory without removing the directory itself
+   * 
+   * Removes all files and subdirectories within the specified directory,
+   * but keeps the directory itself.
+   * 
+   * @param path - The path to the directory to clear (default: '/')
+   * @returns Promise that resolves when all contents are removed
+   * @throws {OPFSError} If the operation fails
+   * 
+   * @example
+   * ```typescript
+   * // Clear root directory contents
+   * await fs.clear('/');
+   * 
+   * // Clear specific directory contents
+   * await fs.clear('/data');
+   * ```
+   */
+  async clear(t = "/") {
+    await this.mount();
+    try {
+      const e = await this.readDir(t);
+      for (const n of e) {
+        const r = `${t === "/" ? "" : t}/${n.name}`;
+        await this.remove(r, { recursive: !0 });
+      }
+      await this.notifyChange({ path: t, type: A.Changed, isDirectory: !0 });
+    } catch (e) {
+      throw e instanceof w ? e : x(e, { path: t, isDirectory: !0 });
+    }
+  }
+  /**
+   * Remove files and directories
+   * 
+   * Removes files and directories. Similar to Node.js fs.rm().
+   * 
+   * @param path - The path to remove
+   * @param options - Options for removal
+   * @param options.recursive - Whether to remove directories and their contents recursively (default: false)
+   * @param options.force - Whether to ignore errors if the path doesn't exist (default: false)
+   * @returns Promise that resolves when the removal is complete
+   * @throws {OPFSError} If the removal fails
+   * 
+   * @example
+   * ```typescript
+   * // Remove a file
+   * await fs.rm('/path/to/file.txt');
+   * 
+   * // Remove a directory and all its contents
+   * await fs.rm('/path/to/directory', { recursive: true });
+   * 
+   * // Remove with force (ignore if doesn't exist)
+   * await fs.rm('/maybe/exists', { force: true });
+   * ```
+   */
+  async remove(t, e) {
+    if (await this.mount(), t === "/")
+      throw new et("EROOT", t);
+    const { recursive: n = !1, force: r = !1 } = e || {}, i = await this.getDirectoryHandle(J(t), !1), o = await this.stat(t);
+    await hs(i, t, { recursive: n, force: r }), await this.notifyChange({ path: t, type: A.Removed, isDirectory: o.isDirectory });
+  }
+  /**
+   * Resolve a path to an absolute path
+   * 
+   * Resolves relative paths and normalizes path segments (like '..' and '.').
+   * Similar to Node.js fs.realpath() but without symlink resolution since OPFS doesn't support symlinks.
+   * 
+   * @param path - The path to resolve
+   * @returns Promise that resolves to the absolute normalized path
+   * @throws {FileNotFoundError} If the path does not exist
+   * @throws {OPFSError} If path resolution fails
+   * 
+   * @example
+   * ```typescript
+   * // Resolve relative path
+   * const absolute = await fs.realpath('./config/../data/file.txt');
+   * console.log(absolute); // '/data/file.txt'
+   * ```
+   */
+  async realpath(t) {
+    await this.mount();
+    try {
+      const e = cs(t);
+      if (!await this.exists(e))
+        throw new j("file", e);
+      return e;
+    } catch (e) {
+      throw e instanceof w ? e : x(e, { path: t });
+    }
+  }
+  /**
+   * Rename a file or directory
+   * 
+   * Changes the name of a file or directory. If the target path already exists,
+   * 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, n) {
+    await this.mount();
+    try {
+      const r = n?.overwrite ?? !1, i = await this.stat(t);
+      if (await this.exists(e) && !r)
+        throw new ut(e);
+      await this.copy(t, e, { recursive: !0, overwrite: r }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: A.Removed, isDirectory: i.isDirectory }), await this.notifyChange({ path: e, type: A.Added, isDirectory: i.isDirectory });
+    } catch (r) {
+      throw r instanceof w ? r : x(r, { path: t });
+    }
+  }
+  /**
+   * Copy files and directories
+   * 
+   * Copies files and directories. Similar to Node.js fs.cp().
+   * 
+   * @param source - The source path to copy from
+   * @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.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
+   * 
+   * @example
+   * ```typescript
+   * // Copy a file
+   * await fs.copy('/source/file.txt', '/dest/file.txt');
+   * 
+   * // Copy a directory and all its contents
+   * await fs.copy('/source/dir', '/dest/dir', { recursive: true });
+   * 
+   * // Copy without overwriting existing files
+   * await fs.copy('/source', '/dest', { recursive: true, overwrite: false });
+   * ```
+   */
+  async copy(t, e, n) {
+    await this.mount();
+    try {
+      const r = n?.recursive ?? !1, i = n?.overwrite ?? !0;
+      if (!await this.exists(t))
+        throw new j("source", t);
+      if (await this.exists(e) && !i)
+        throw new ut(e);
+      if ((await this.stat(t)).isFile) {
+        const h = await this.readFile(t);
+        await this.writeFile(e, h);
+      } else {
+        if (!r)
+          throw new tt("directory", t);
+        await this.mkdir(e, { recursive: !0 });
+        const h = await this.readDir(t);
+        for (const l of h) {
+          const f = `${t}/${l.name}`, u = `${e}/${l.name}`;
+          await this.copy(f, u, { recursive: !0, overwrite: i });
+        }
+      }
+    } catch (r) {
+      throw r instanceof w ? r : x(r, { path: t });
+    }
+  }
+  /**
+   * 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, e) {
+    if (!this.options.broadcastChannel)
+      throw new v("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.");
+    const n = {
+      pattern: as(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) {
+    this.watchers.delete(t);
+  }
+  /**
+   * Read a file as a `Blob` without copying its bytes into memory.
+   *
+   * OPFS hands back a disk-backed `File`, so the browser can stream it on
+   * demand — pass it to `URL.createObjectURL()` for `<video>` / `<audio>` /
+   * `<img>` and only the played range is actually read. Structured clone keeps
+   * the reference intact when the file system runs in a worker.
+   *
+   * @param path - Path to the file
+   * @returns Lazy `File` handle backed by OPFS storage
+   * @throws {OPFSError} If the path is missing or is a directory
+   *
+   * @example
+   * ```typescript
+   * const blob = await fs.readBlob('/media/clip.mp4');
+   * video.src = URL.createObjectURL(blob);
+   * ```
+   */
+  async readBlob(t) {
+    await this.mount();
+    try {
+      return await (await this.getFileHandle(t, !1)).getFile();
+    } catch (e) {
+      throw e instanceof w ? e : x(e, { path: t, isDirectory: e?.name === "TypeMismatchError" });
+    }
+  }
+  /**
+   * Bulk-import files from `[path, data]` entries (strings, bytes, Blobs, or Files).
+   * Each entry is written via {@link writeStream} so large Blobs/Files are not
+   * fully buffered in memory.
+   *
+   * Accepts an array of tuples, a `Map`, or any iterable of `[path, data]` pairs.
+   *
+   * @param entries - Files to write
+   * @param onProgress - Per-chunk progress with path, index, and byte counts
+   * @returns Written paths, count, and total bytes
+   * @throws {OPFSError} If a write fails
+   *
+   * @example
+   * ```typescript
+   * const result = await fs.importFiles([
+   *   ['/config.json', JSON.stringify({ theme: 'dark' })],
+   *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],
+   *   ['/upload.txt', fileFromInput],
+   * ], (p) => console.log(`${p.path}: ${p.bytesWritten}/${p.bytesTotal}`));
+   *
+   * console.log(result.count, result.bytesWritten, result.paths);
+   * ```
+   */
+  async importFiles(t, e) {
+    await this.mount();
+    const n = [...t].map(([a, h]) => [nt(a), h]), r = n.length, i = n.map(([a]) => a), o = n.reduce((a, [, h]) => a + fs(h), 0);
+    let c = 0;
+    try {
+      for (let a = 0; a < r; a++) {
+        const [h, l] = n[a], { stream: f, size: u } = ds(l), d = c, g = await this.writeStream(
+          h,
+          f,
+          e ? (p) => e({
+            path: h,
+            index: a,
+            count: r,
+            bytesWritten: p,
+            bytesTotal: u,
+            totalBytesWritten: d + p,
+            totalBytes: o
+          }) : void 0
+        );
+        c += g;
+      }
+      return {
+        paths: i,
+        count: r,
+        bytesWritten: c
+      };
+    } catch (a) {
+      throw a instanceof w ? a : x(a);
+    }
+  }
+  /**
+   * @deprecated Use {@link importFiles} instead.
+   */
+  async createIndex(t) {
+    ps(), await this.importFiles(t);
+  }
+  /**
+   * Dispose of resources and clean up the file system instance
+   */
+  dispose() {
+    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchers.clear();
+  }
+}
+function fs(s) {
+  return typeof s == "string" ? new TextEncoder().encode(s).byteLength : s instanceof Blob ? s.size : s.byteLength;
+}
+function ds(s) {
+  if (s instanceof Blob)
+    return { stream: s.stream(), size: s.size };
+  const t = typeof s == "string" ? new TextEncoder().encode(s) : s;
+  return {
+    size: t.byteLength,
+    stream: new ReadableStream({
+      start(e) {
+        e.enqueue(t), e.close();
+      }
+    })
+  };
+}
+let Et = !1;
+function ps() {
+  Et || (Et = !0, console.warn("[opfs-worker] createIndex() is deprecated; use importFiles() instead"));
+}
+const T = "file descriptors are not available in the async backend, use the dedicated worker backend (`createOPFSDedicated`) for positional I/O";
+class gs extends us {
+  async readFile(t) {
+    await this.mount();
+    try {
+      return await z(t, async () => {
+        const n = await (await this.getFileHandle(t, !1)).getFile(), r = new Uint8Array(await n.arrayBuffer());
+        return vt(r, [r.buffer]);
+      });
+    } catch (e) {
+      throw e instanceof w ? e : x(e, { path: t, isDirectory: e?.name === "TypeMismatchError" });
+    }
+  }
+  async writeFile(t, e) {
+    await this.mount();
+    const n = e instanceof Uint8Array ? e : new Uint8Array(e);
+    try {
+      await z(t, async () => {
+        const r = await this.exists(t), i = await this.getFileHandle(t, !0);
+        await this._writeStream(i, async (o) => o.write(n)), await this.notifyChange({ path: t, type: r ? A.Changed : A.Added, isDirectory: !1 });
+      });
+    } catch (r) {
+      throw r instanceof w ? r : x(r, { path: t, isDirectory: r?.name === "TypeMismatchError" });
+    }
+  }
+  async appendFile(t, e) {
+    await this.mount();
+    const n = e instanceof Uint8Array ? e : new Uint8Array(e);
+    try {
+      await z(t, async () => {
+        const r = await this.getFileHandle(t, !0), { size: i } = await r.getFile();
+        await this._writeStream(
+          r,
+          async (o) => o.write({ type: "write", position: i, data: n }),
+          { keepExistingData: !0 }
+        ), await this.notifyChange({ path: t, type: A.Changed, isDirectory: !1 });
+      });
+    } catch (r) {
+      throw r instanceof w ? r : x(r, { path: t, isDirectory: r?.name === "TypeMismatchError" });
+    }
+  }
+  async writeStream(t, e, n) {
+    await this.mount();
+    try {
+      return await z(t, async () => {
+        const r = await this.exists(t), i = await this.getFileHandle(t, !0), o = e.getReader();
+        let c = 0;
+        try {
+          await this._writeStream(i, async (a) => {
+            for (; ; ) {
+              const { done: h, value: l } = await o.read();
+              if (h)
+                break;
+              await a.write(l), c += l.byteLength, await n?.(c);
+            }
+          });
+        } catch (a) {
+          throw await o.cancel(a).catch(() => {
+          }), a;
+        } finally {
+          o.releaseLock();
+        }
+        return await this.notifyChange({
+          path: t,
+          type: r ? A.Changed : A.Added,
+          isDirectory: !1
+        }), c;
+      });
+    } catch (r) {
+      throw r instanceof w ? r : x(r, { path: t, isDirectory: r?.name === "TypeMismatchError" });
+    }
+  }
+  /**
+   * Open a writable stream, run the write callback and commit via close().
+   * Aborts the stream (discarding the swap file) if the callback fails.
+   * @private
+   */
+  async _writeStream(t, e, n) {
+    if (typeof t.createWritable != "function")
+      throw new v("createWritable() is not available in this browser (Safari supports it since version 26), use the dedicated worker backend (`createOPFSDedicated`) instead");
+    const r = await t.createWritable(n);
+    try {
+      await e(r);
+    } catch (i) {
+      throw await r.abort().catch(() => {
+      }), i;
+    }
+    await r.close();
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async open(t, e) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async close(t) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async read(t, e, n, r, i) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async write(t, e, n, r, i, o) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async fstat(t) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async ftruncate(t, e) {
+    throw new v(T);
+  }
+  /** @throws {OperationNotSupportedError} Always — no FD support in the async backend */
+  async fsync(t) {
+    throw new v(T);
+  }
+}
+const ws = new gs();
+globalThis.onconnect = (s) => {
+  rt(ws, s.ports[0]);
+};
+//# sourceMappingURL=shared.worker.js.map